Boris Cherny Just Demonstrated the Future of Programming in 30 Minutes

No slides. No script. Just a live development screen and a preview of what coding looks like from here.

Most conference talks tell you what AI coding tools can do. At Code with Claude SF 2026, Boris Cherny and Jarred Sumner (creator of Bun) just showed you.

Thirty minutes. No slides. No rehearsed demos. Just an unedited stream of the development flow they use every day.

It was the most instructive session at the event and if you missed it, here’s what happened and why it matters.

Ai Generated Image

What Was Actually Shown (Chronological)

1. Multiple Sessions Running in Parallel

Boris opened by launching three Claude Code sessions simultaneously inside the Desktop App:

┌─────────────────────────────────────────────┐
│         Claude Code Desktop App             │
│                                             │
│  Sidebar        │  Active Session           │
│  ─────────────  │  ─────────────────────    │
│  ● Session 1    │                           │
│    Feature add  │  [E-commerce dashboard]   │
│                 │                           │
│  ● Session 2    │  Claude writing tests...  │
│    Test gen     │                           │
│                 │                           │
│  ● Session 3    │  Claude reviewing code... │
│    Code review  │                           │
└─────────────────────────────────────────────┘

Each session ran a different task. One was building an e-commerce dashboard feature. Another was generating tests. A third handled code review. All simultaneously. No waiting.

2. Claude Code on the Bun Runtime

Jarred demonstrated pairing Claude Code with Bun his JavaScript runtime to tighten the feedback loop:

# Standard Node workflow
node --loader ts-node/esm src/index.ts   # compile step needed
npx jest                                  # separate test runner

# Bun workflow
bun src/index.ts                          # runs TypeScript natively
bun test                                  # built-in, fast test runner

His claim: when Claude generates code and tests, Bun’s native TypeScript support and fast startup eliminate the friction between “Claude writes it” and “you see it run.” The cycle genuinely feels faster.

3. Hooks × Sub-agents × Routines Combined

This was the technical core of the session. Boris demonstrated three features and made clear they only matter when combined:

┌──────────────────────────────────────────────────────┐
│                  Git Commit Event                    │
└──────────────────────┬───────────────────────────────┘
                       │
                  [Hook fires]
                       │
         ┌─────────────┴──────────────┐
         ▼                            ▼
  Sub-agent A                   Sub-agent B
  (Test Specialist)             (Refactor Specialist)
  Runs full test suite          Suggests clean-up
         │                            │
         └─────────────┬──────────────┘
                       ▼
              Routine: daily-deps.md
              Scheduled dependency audit
              runs overnight, async

• Hooks trigger automatic tests and reviews after every commit
• Sub-agents parallelize specialized tasks one agent for tests, one for refactoring
• Routines register recurring tasks as Markdown recipes that run on a schedule

None of these features is impressive alone. Together, they turn Claude Code into something that keeps working after you’ve closed your laptop.

4. Claude Finds a Bug Without Being Asked

The standout moment: Boris had Claude implement a refund flow, then “verify operation” by opening the UI itself. Claude spotted an edge-case bug a displayed amount breaking when switching between Yen and Dollars in a multi-currency dropdown and fixed it.

No one told Claude to look for that bug. It found it by using the product.

The Keyword: “Code Is Now Written Asynchronously”

At the end of the session, Boris landed on a phrase worth sitting with:

“We have entered the era where code is written asynchronously.”

This isn’t poetic. It’s architectural. Here’s what it means in practice:

Before:
Developer → writes code → writes tests → reviews → ships

After:
Developer → passes requirements to Claude
Claude    → writes code → writes tests → verifies UI → flags issues
Developer → reviews, course-corrects, approves

The developer’s role shifts from writing to approving and designing parallelism. The question changes from “how do I implement this?” to “how many agents should run in parallel, and what do I need to review?”

What This Means for Small Teams

This workflow is arguably more valuable for individuals and teams of 1–5 than for large engineering orgs.

Why? Because review bandwidth is the bottleneck, not implementation speed. A solo developer or small team can run parallel Claude sessions overnight using Routines dependency audits, security scans, test generation and wake up to completed, reviewable work.

A lightweight adaptation:

| Boris's Demo                     | Solo Developer Version                 |
|----------------------------------|----------------------------------------|
| 3 parallel sessions              | 2 parallel sessions                    |
| Hooks: auto-review after commit  | Hooks: lint + test after push          |
| Routines: daily checks           | Routines: weekly dependency updates    |
| Multiple sub-agents              | One sub-agent (test specialist)        |

Start with one session. Add a second when parallel review feels comfortable. Three is a ceiling for professionals running this daily not a starting point.

Three Things to Watch Out For

Don’t rush to migrate to Bun. Jarred’s demo is compelling, but migrating an existing project from Node carries real costs. Claude Code runs fine on Node. Evaluate the runtime independently of the AI tooling.

Don’t run three sessions before you’re ready. Boris’s three-session demo works because he understands Claude Code’s internal behavior deeply. Start with one session. The risk of parallel sessions isn’t speed it’s not being able to review fast enough and missing something important.

His workflow is optimized for an insider. Boris works at Anthropic. Some of his patterns reflect knowledge of the implementation that external users don’t have. Extract the general-purpose techniques; don’t copy the entire setup.

Three Things to Try This Week

1. Watch the session at 1.5x speed it’s 30 minutes, so 20 minutes at pace. Re-watch any operation that made you stop.
2. Reproduce one thing in your own environment the same day one Hook, one sub-agent, one Routine. Don’t aim for the full setup. Get one thing working.
3. Record your own development screen for 15 minutes play it back and count how many times you waited for Claude, how many sessions you ran, where you got stuck. Compare against what Boris’s screen looked like.

The gap between Boris’s flow and most developers’ current Claude Code usage is significant. The only way to close it is to see your own screen the way an observer would.

Watch the Full Session

The live coding session is available here: **Code with Claude SF 2026 Boris Cherny × Jarred Sumner Live Coding**

Watching the author’s screen for 30 minutes will teach you more than reading three best-practice articles.