btucker

I built a terminal app for myself that conflates worktrees & tabs, runs every pane through a terminal multiplexer, lets me join in from my phone and generally makes me happy.

https://github.com/btucker/graftty

You can find the 4 versions of Benedict's deck here: https://www.ben-evans.com/presentations I appreciate the temporal view into this thinking. My interpretation:

Nov 2024: Don’t dismiss this; it may be the next platform shift. But the actual questions are still unsettled: scaling, usefulness, deployment, and business model.

May 2025: The model layer is already showing signs of commoditization, so the important question shifts toward deployment: products, use cases, UX, errors, and enterprise adoption.

Nov 2025: The capital cycle has become the story: everyone is spending because missing the platform shift is worse than overbuilding, but there is still no clarity on product shape, moats, or value capture. That creates bubble-like dynamics.

May 2026: Provisional thesis: models look likely to become infrastructure, while value probably moves up-stack into apps, workflows, product, proprietary data/context, GTM, and new questions made possible by cheap automation. But he is still explicitly calling this provisional.

This has increasingly been my take. If we accept that AI is an amplifier of impact, then it follows it will amplify disparities.

One of my most humbling experiences was entering a puzzle hunt at CMU in the mid 2000s with early undergrad friends. We completely flailed. I still remember watching other groups out the window running around the campus while it took us most of the day just to get out of our room on the first puzzle.

It was a great reminder for a bunch of hotshot underclassmen that there were so many skills we all had yet to develop.

I hacked this together last fall to let you use Apple Foundation Models with llm: https://github.com/btucker/llm-apple . To enable that I built python bindings with Claude Code: https://github.com/btucker/apple-foundation-models-py

Unfortunately, I found the small context window makes the utility pretty limited.

It's not necessarily an AI-generated infographics issue, it's that these aren't good infographics. The graphic part is adding minimal value.

I am convinced they’ve done research that says they would sell a meaningfully smaller number of units if they added this feature. Sigh…

Anthropic made it an open standard: https://agentskills.io/home

Completely agree. But I wonder how much of that is just accomplished with well placed code comments that explain the why for future agent interactions to prevent them from misunderstanding. I have something like this in my AGENTS.md.

I hacked together something similar to the concept they describe a few months ago (https://github.com/btucker/agentgit) and then ended up not actually finding it that useful and abandoning it.

I've been working on https://github.com/btucker/selkie which is a complete implementation of the Mermaid parser & renderer in rust as an experiment in what's possible with Claude Code. It's still rough around the edges, but I've been blown away by what's been possible. (I'm now using it as a test repo for https://github.com/btucker/midtown)

Playground here: https://btucker.github.io/selkie/

One of the cool features is it can use kitty to output diagrams direct to the terminal (if kitty is supported like in ghostty).

I'm planning to blog about the whole process soon.

Last year here in Chicago my wife's bike was stolen overnight. It has an airtag hidden in a bell on the handlebars. When we woke up and noticed it was missing, we traced it to a park not too far away. We ran over there and called the Chicago PD who showed up in <10min. We told them a description of the bike and showed where FindMy said it was. They went and retrieved it. Surprisingly happy ending & I was impressed the Chicago PD were so helpful!

I haven't dug too deep, but it appears to be using a bubblewrap sandbox inside a vm on the Mac using Apple's Virtualization.framework from what I can tell. It then uses unix sockets to proxy network via socat.

ETA: used Claude Code to reverse engineer it:

   Insight ─────────────────────────────────────

  Claude.app VM Architecture:
  1. Uses Apple's Virtualization.framework (only on ARM64/Apple Silicon, macOS 13+)
  2. Communication is via VirtioSocket (not stdio pipes directly to host)
  3. The VM runs a full Linux system with EFI/GRUB boot

  ─────────────────────────────────────────────────

        ┌─────────────────────────────────────────────────────────────────────────────────┐
        │  macOS Host                                                                     │
        │                                                                                 │
        │  Claude Desktop App (Electron + Swift native bindings)                          │
        │      │                                                                          │
        │      ├─ @anthropic-ai/claude-swift (swift_addon.node)                           │
        │      │   └─ Links: Virtualization.framework (ARM64 only, macOS 13+)            │
        │      │                                                                          │
        │      ↓ Creates/Starts VM via VZVirtualMachine                                   │
        │                                                                                 │
        │  ┌──────────────────────────────────────────────────────────────────────────┐  │
        │  │  Linux VM (claudevm.bundle)                                              │  │
        │  │                                                                          │  │
        │  │  ┌────────────────────────────────────────────────────────────────────┐  │  │
        │  │  │  Bubblewrap Sandbox (bwrap)                                        │  │  │
        │  │  │  - Network namespace isolation (--unshare-net)                     │  │  │
        │  │  │  - PID namespace isolation (--unshare-pid)                         │  │  │
        │  │  │  - Seccomp filtering (unix-block.bpf)                              │  │  │
        │  │  │                                                                    │  │  │
        │  │  │  ┌──────────────────────────────────────────────────────────────┐  │  │  │
        │  │  │  │  /usr/local/bin/claude                                       │  │  │  │
        │  │  │  │  (Claude Code SDK - 213MB ARM64 ELF binary)                  │  │  │  │
        │  │  │  │                                                              │  │  │  │
        │  │  │  │  --input-format stream-json                                  │  │  │  │
        │  │  │  │  --output-format stream-json                                 │  │  │  │
        │  │  │  │  --model claude-opus-4-5-20251101                            │  │  │  │
        │  │  │  └──────────────────────────────────────────────────────────────┘  │  │  │
        │  │  │       ↑↓ stdio (JSON-RPC)                                          │  │  │
        │  │  │                                                                    │  │  │
        │  │  │  socat proxies:                                                    │  │  │
        │  │  │  - TCP:3128 → /tmp/claude-http-*.sock (HTTP proxy)                │  │  │
        │  │  │  - TCP:1080 → /tmp/claude-socks-*.sock (SOCKS proxy)              │  │  │
        │  │  └────────────────────────────────────────────────────────────────────┘  │  │
        │  │                                                                          │  │
        │  └──────────────────────────────────────────────────────────────────────────┘  │
        │           ↕ VirtioSocket (RPC)                                                 │
        │      ClaudeVMDaemonRPCClient.swift                                             │
        │           ↕                                                                    │
        │      Node.js IPC layer                                                         │
        └─────────────────────────────────────────────────────────────────────────────────┘

VM Specifications (from inside)

ComponentDetailsKernelLinux 6.8.0-90-generic aarch64 (Ubuntu PREEMPT_DYNAMIC)OSUbuntu 22.04.5 LTS (Jammy Jellyfish)HostnameclaudeCPU4 cores, Apple Silicon (virtualized), 48 BogoMIPSRAM3.8 GB total (~620MB used at idle)SwapNone

Storage Layout

DeviceSizeTypeMount PointPurpose/dev/nvme0n1p19.6 GBext4/Root filesystem (rootfs.img)/dev/nvme0n1p1598 MBvfat/boot/efiEFI boot partition/dev/nvme1n19.8 GBext4/sessionsSession data (sessiondata.img)virtiofs-virtiofs/mnt/.virtiofs-root/shared/...Host filesystem access

Filesystem Mounts (User Perspective)

        /sessions/gallant-vigilant-lamport/
        ├── mnt/
        │   ├── claude-cowork/     → Your selected folder (virtiofs + bindfs)
        │   ├── .claude/           → ~/.claude config (bindfs, rw)
        │   ├── .skills/           → Skills/plugins (bindfs, ro)
        │   └── uploads/           → Uploaded files (bindfs)
        └── tmp/                   → Session temp files
        
        Session User
        A dedicated user is created per session with a Docker-style random name:
        User: gallant-vigilant-lamport
        UID:  1001
        Home: /sessions/gallant-vigilant-lamport
        Process Tree
        PID 1: bwrap (bubblewrap sandbox)
        └── bash (shell wrapper)
            ├── socat TCP:3128 → unix socket (HTTP proxy)
            ├── socat TCP:1080 → unix socket (SOCKS proxy)
            └── /usr/local/bin/claude (Claude Code SDK)
                └── bash (tool execution shells)

        Security Layers

        Apple Virtualization.framework - Hardware-level VM isolation
        Bubblewrap (bwrap) - Linux container/sandbox

        --unshare-net - No direct network access
        --unshare-pid - Isolated PID namespace
        --ro-bind / / - Read-only root (with selective rw binds)


        Seccomp - System call filtering (unix-block.bpf)
        Network Isolation - All traffic via proxied unix sockets

        Network Architecture
        ┌─────────────────────────────────────────────────────────────┐
        │  Inside Sandbox                                             │
        │                                                             │
        │  claude process                                             │
        │      │                                                      │
        │      ↓ HTTP/HTTPS requests                                  │
        │  localhost:3128 (HTTP proxy via env vars)                   │
        │      │                                                      │
        │      ↓                                                      │
        │  socat → /tmp/claude-http-*.sock ─────────┐                │
        │                                            │                │
        │  localhost:1080 (SOCKS proxy)              │                │
        │      │                                     │                │
        │      ↓                                     │                │
        │  socat → /tmp/claude-socks-*.sock ────────┤                │
        └───────────────────────────────────────────┼────────────────┘
                                                    │
                                VirtioSocket ←──────┘
                                                    │
        ┌───────────────────────────────────────────┼────────────────┐
        │  Host (macOS)                             │                │
        │                                           ↓                │
        │                              Claude Desktop App            │
        │                                           │                │
        │                                           ↓                │
        │                                    Internet                │
        └─────────────────────────────────────────────────────────────┘
        Key insight: The VM has only a loopback interface (lo). No eth0, no bridge. All external network access is tunneled through unix sockets that cross the VM boundary via VirtioSocket.


  Communication Flow

  From the logs and symbols:

  1. VM Start: Swift calls VZVirtualMachine.start() with EFI boot
  2. Guest Ready: VM guest connects (takes ~6 seconds)
  3. SDK Install: Copies /usr/local/bin/claude into VM
  4. Process Spawn: RPC call to spawn /usr/local/bin/claude with args

  The spawn command shows the actual invocation:
  /usr/local/bin/claude --output-format stream-json --verbose \
    --input-format stream-json --model claude-opus-4-5-20251101 \
    --permission-prompt-tool stdio --mcp-config {...}

I probably should have written it as “OK Engineer--“

I've been starting to think of it like this:

Great Engineer + AI = Great Engineer++ (Where a great engineer isn't just someone who is a great coder, they also are a great communicator & collaborator, and love to learn)

Good Engineer + AI = Good Engineer

OK Engineer + AI = Mediocre Engineer

Also, it was a time when being “online” was an active state. Now we’re “online” passively 24/7.

I love Monkeybrains! I had something in the neighborhood of a 600mbps symmetric connection through them in the late 2010s when I lived in SF. The only issue was when it rained hard the speeds would deteriorate.

Interesting you're getting such slow speeds. Ask them if a tech can stop by and troubleshoot with you.

Then why did you post that?

I understand you're trying to "both sides" an argument. What have you found that has achieved for you in the past? Do you change people's opinions with this?

I'm sure PaywallBuster has reviewed these and confirmed they were one-year spending before making their statement.

And then, The Charlie Rose Paradox: https://www.youtube.com/watch?v=iqW9sexNdZg

A step in the right direction last week for the largest upzoning effort in the city! https://archive.is/QuOcJ

Of course the a vocal minority is fuming about higher density.

Agreed, but I wonder--given investors demands for continued growth--if they're considering going up against NVIDIA.

It seems like you might be trying to use it like a search engine, which is a common mistake people make when first trying LLMs. LLMs are not like Google.

The key is to give it context so it can help you. For example, if you want it to help you with Spark configuration, give it the Spark docs. If you want it to help you write code, give it your codebase.

Tools like cursor and the like make this process very easy. You can also set up a local MCP server so the LLM can get the context and tools it needs on its own.

This makes me think of the early/mid-2000s & https://blosxom.sourceforge.net. Blosxom had this delightful concept of file extensions as "flavours." For example, you could have a ".rss" flavour that would present that hierarchy of your site as an RSS feed if you added ".rss" to the URL. Brilliant!

It's a bit like the forced perspective techniques Disney uses to accomplish the inverse: make small buildings seem bigger.

Explainer video: https://www.youtube.com/watch?v=yqefjmRVLTM

I remember fondly following the Project Aardvark blog posts through the summer of 2005-- it was such an exciting time! It's still online here: https://www.projectaardvark.com

Also, Joel's midterm report: https://www.joelonsoftware.com/2005/07/07/project-aardvark-m...

I appreciate the intent here of making levels more transparent & evenly applied, but in practice this seems to be tying levels/comp to a demographic attribute people have no control over: their age. This makes me feel uncomfortable.

Carnegie Mellon had a rule (mid-2000s) that you could only host .orgs from the static IPs you could register on your dorm Ethernet. I launched openpodcast.org & bibme.org as a result of that. I always thought it was a senseless rule.