HackerTrans
TopNewTrendsCommentsPastAskShowJobs

btucker

no profile record

comments

btucker
·पिछला माह·discuss
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
btucker
·2 माह पहले·discuss
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.
btucker
·3 माह पहले·discuss
This has increasingly been my take. If we accept that AI is an amplifier of impact, then it follows it will amplify disparities.
btucker
·3 माह पहले·discuss
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.
btucker
·3 माह पहले·discuss
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.
btucker
·4 माह पहले·discuss
It's not necessarily an AI-generated infographics issue, it's that these aren't good infographics. The graphic part is adding minimal value.
btucker
·4 माह पहले·discuss
I am convinced they’ve done research that says they would sell a meaningfully smaller number of units if they added this feature. Sigh…
btucker
·5 माह पहले·discuss
Anthropic made it an open standard: https://agentskills.io/home
btucker
·5 माह पहले·discuss
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.
btucker
·5 माह पहले·discuss
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.
btucker
·5 माह पहले·discuss
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.
btucker
·5 माह पहले·discuss
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!
btucker
·6 माह पहले·discuss
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 {...}
btucker
·9 माह पहले·discuss
https://archive.is/RVTHE