How the Creator of Claude Code Actually Uses It: Boris Cherny’s Workflow, Distilled

TL;DR — Boris Cherny created Claude Code at Anthropic, and over the past year he has publicly documented his own workflow in unusual detail: five X threads with 121+ tips, three long-form podcasts, and a one-year retrospective interview. The headline numbers are well known — he hasn’t written a line of code by hand since November 2025, ships 10-30 PRs a day (often from his phone), and Anthropic’s per-engineer output is up roughly 200%. But the numbers aren’t the interesting part. The interesting part is that he has publicly reversed his own advice twice in six months: plan mode, once his single most-repeated tip, he no longer uses at all; and “context engineering” has given way to “context minimalism.” What survived every reversal is one habit he calls the most important thing you can do — give Claude a way to verify its own work, worth 2-3x on output quality. This guide distills his actual practice from primary sources, separates the durable principles from the version-specific tactics, and translates a single engineer’s setup into something an engineering team can realistically adopt.

Who Boris Cherny Is and Why His Workflow Matters

Boris Cherny is the creator and head of Claude Code at Anthropic. Before that he spent five years at Meta as a Principal Engineer and wrote Programming TypeScript for O’Reilly. Claude Code began as a terminal-based side project and became, within a year, a tool that authors roughly 4% of all public GitHub commits — a figure Boris has predicted will reach 20% by the end of 2026.

What makes his workflow worth studying isn’t authority by title. It’s three things:

He documents it publicly and continuously. Since January 2026 he has published detailed threads on his exact setup — five major threads covering everything from terminal configuration to subagent architecture, aggregated by the community at howborisusesclaudecode.com. This is rare. Most practitioners share polished conclusions; Boris shares working configuration.

He revises it in public when he’s wrong. The single most valuable signal in the entire corpus is what he stopped doing. Advice that survived twelve months of model upgrades is a different category of advice than a tip published once and never revisited.

He’s the extreme case, which makes the boundaries visible. Boris works at Anthropic, on Anthropic’s own codebase, with effectively unlimited tokens and access to models before they ship. That’s not your situation. But watching someone operate at the far end of the distribution shows you which constraints are real and which are self-imposed.

The honest caveat up front, because it matters for everything below: copy the principles, not the setup. Some of what works for him works because of where he works.

The Core Loop: What He Actually Does All Day

Boris’s daily practice has converged on a five-step loop he repeats dozens of times a day. It’s not a framework he’s promoting — it’s the literal sequence, reconstructed from his threads and interviews.

Step 1 — Speak the brief. Boris does most of his coding by speaking, not typing. His reasoning is simple: you speak roughly 3x faster than you type, and the result is that your prompts get more detailed almost by accident. In the CLI this is /voice (hold space bar); on macOS, double-tapping fn works anywhere.

What goes into the brief matters more than the input method. The pattern Anthropic’s Cat Wu articulated and Boris echoes: goal, constraints, and acceptance criteria in the first turn. Not “add rate limiting” but “add rate limiting to /api/login; don’t modify the DB schema; use the existing Redis; 5 req/min per IP returning 429; existing tests must pass; add a test for the limit behaviour.” If Claude asks a lot of clarifying questions, that’s usually a signal the brief was incomplete — not that the model needs hand-holding.

Step 2 — Launch in auto mode. Auto mode routes each permission decision to a safety classifier rather than to you. Safe operations get auto-approved; risky ones still surface. Boris pairs this with xhigh effort for most work and max for the hardest tasks, and runs each session in its own git worktree.

Step 3 — Switch away. This is the step most people skip, and it’s where the leverage is. Once a Claude is working, Boris moves to the next one. He runs roughly 5 terminal sessions plus 5-10 web sessions, tracked through agent view (claude agents) — a control plane that groups sessions by needs input, working, and completed.

Step 4 — Claude verifies its own work. Rather than reviewing intermediate steps, Boris ends prompts with /go — a composite skill that has Claude test end-to-end (bash, browser via the Claude Chrome extension, or simulator depending on domain), run /simplify to clean up the code, and open a PR. His own phrasing: “Many of my prompts look like ‘Claude do blah blah /go’.”

Step 5 — Write the mistake down. This is the step that makes the whole loop compound, and it deserves its own section.

The One Habit That Survived Every Reversal

Asked what matters most for long-running work, Boris gives an answer that has stayed constant across every thread and interview: when Claude makes a mistake, don’t correct it — write the correction down permanently.

His exact words from the one-year retrospective:

“Every single time Claude makes a mistake, I don’t tell it to do it differently. I tell it to write it to the CLAUDE.md, or make a skill, or something. If you can do this, then Claude can just run forever.”

The distinction is small in the moment and enormous over time. A conversational correction fixes this run. A written rule fixes every future run. One is a patch; the other is a fix. Teams that only correct in chat find their error rate resets to zero-knowledge every session. Teams that write it down find the error rate trends downward permanently.

How the Claude Code team operationalises this. They maintain a single shared CLAUDE.md checked into git, contributed to by the whole team multiple times a week. Their rule: “Anytime we see Claude do something incorrectly we add it to the CLAUDE.md, so Claude knows not to do it next time.”

They go further. During code review, engineers tag @claude directly in PR comments to have the learning added as part of the PR itself:

nit: use a string literal, not ts enum
@claude add to CLAUDE.md to never use enums, always prefer literal unions

Claude then updates the CLAUDE.md and commits the rule. Boris calls this their version of “compounding engineering” — a term borrowed from Dan Shipper. It’s the same principle applied to skills: if you do something more than once a day, turn it into a skill or slash command, commit it to git, and reuse it across projects.

The related habit: rewind instead of correcting. Thariq Shihipar from the Claude Code team articulated the context-window version of the same idea. When Claude goes down a wrong path, don’t type “that didn’t work, try X.” That keeps the failed attempt in context, polluting the window. Instead use /rewind (or double-tap Esc), then re-prompt with what you learned. The arithmetic: correcting means context = file reads + failed attempt + correction + fix. Rewinding means context = file reads + one informed prompt + fix.

The Two Reversals: What Stopped Being True

The most useful thing in Boris’s public corpus isn’t a tip — it’s the two occasions where he publicly abandoned advice he’d previously given. Both reversals happened within six months, and both were caused by the same thing: the models got better.

Reversal 1: Plan mode → auto mode

In January 2026, plan mode was Boris’s most-repeated recommendation. Shift+Tab twice, iterate on the plan until it’s solid, then switch to auto-accept. His framing at the time: “A good plan is really important to avoid issues down the line.” The community built an entire methodology around it — the “80% plan mode rule.”

By June 2026, in the one-year retrospective with Cat Wu, he had dropped it entirely:

“What it used to be is plan mode. I don’t use that anymore. I use auto mode instead of plan mode. The newer models don’t actually need a planning step. It was really important for Opus 4 through 4.5, but starting with 4.6, and definitely with 4.7, it just doesn’t need it.”

Older models needed an explicit plan to stay on track. Newer ones plan implicitly, which turned the planning step into overhead — an artifact to review before any work could start. Note the nuance: some people still use plan mode for the written artifact (useful for team review or documentation), and that’s a legitimate reason. Boris just doesn’t need it for correctness anymore.

Reversal 2: Context engineering → context minimalism

The second reversal is more conceptual and arguably more important. The progression Boris describes: Sonnet 3.5 was the era of prompt engineering. Opus 4 was the era of context engineering. Today’s models need neither.

“You give it the minimal possible system prompt, the minimal possible tools, and then you let the model figure it out. You just have to give the model some way to pull in the context.”

Cat Wu’s version is sharper: “Tell the model only what it needs to know and let it figure out the rest. When you give the model too much context, it’s like you’re micromanaging it — and sometimes the model knows a better way to get to the same outcome.”

Minimal is not the same as vague. The distinction matters. You still give a complete brief — goal, constraints, acceptance criteria. What you stop doing is front-loading giant system prompts, exhaustive tool lists, and 1,000-line CLAUDE.md files. Give a lean brief plus a way to fetch context (files, search, MCP), then get out of the way.

Why the reversals matter more than the tips

Best practices in agentic engineering have a half-life measured in months. Any team that establishes a “Claude Code standard” and stops revisiting it will, within two model generations, be running workarounds for limitations that no longer exist. The plan-mode methodology that was correct in January was overhead by June.

This has a practical implication for how you write internal guidance: date your practices, tie them to model versions, and schedule a re-audit each quarter. “We use plan mode” is a fragile standard. “We plan when the model needs planning, and we check whether it still does each quarter” is a durable one.

The Parallelism Stack

The defining shift in Boris’s workflow over 2026 is that he stopped running one Claude and started running dozens. Each capability that landed during the year removed a specific bottleneck that had been preventing more parallelism.

Layer 1: Worktrees (isolation). Boris runs each session in its own git worktree, so parallel agents never clobber each other’s edits. The Claude Code team calls this “the single biggest productivity unlock” and it’s now natively supported — claude --worktree, a checkbox in the Desktop app, and isolation: worktree in custom agent frontmatter. Non-git shops (Mercurial, Perforce, SVN) can wire the same behaviour via WorktreeCreate hooks.

Layer 2: Auto mode (no babysitting). Permission prompts were the bottleneck that kept humans tethered to a session. Auto mode routes each action to a classifier. Boris’s argument for why this is safer than manual review is worth quoting: “When you accept 99% of requests, your eyes glaze over. Auto mode is more safe than reading every single permission prompt because it means you’re only paying attention to the most important thing.”

The team hardened it by collecting thousands of full agent transcripts, having auto mode classify each action, then bringing in red-teamers to attempt prompt injection. Those attacks became evals.

Layer 3: /goal and /loop (self-termination). /goal sets a completion condition — “all tests in test/auth pass and the lint step is clean” — and intercepts each stop attempt until the condition is true. /loop re-runs a prompt on an interval locally (up to 3 days); /schedule moves it to the cloud so it survives a closed laptop. Boris’s actual running loops include /loop 5m /babysit (auto-address code review, auto-rebase, shepherd PRs) and /loop 1h /pr-pruner.

Layer 4: Agent view (control plane). Launched May 2026, claude agents gives you one list of every session grouped by needs input, working, and completed. Boris’s framing: “The best way to level up from 1 agent to many agents. No more cycling between terminal tabs.” Thariq described it as “tmux built for Claude Code.”

Layer 5: Dynamic workflows (fan-out). For jobs too large for one pass, saying “use a workflow” has Claude write a custom orchestration harness — hundreds of parallel subagents in a documented pattern: implementer → two verifiers → fixer, per task, with the orchestrator returning only when every branch completes. The canonical use cases are migrations, large refactors, and catalogue-and-categorise sweeps. Cat Wu’s example: cataloguing hundreds of A/B test flags to find stale ones, processed in parallel in under ten minutes.

Where the bottleneck went. With all five layers in place, the constraint is no longer model quality, typing speed, or permission friction. It’s how many parallel streams of work one human can meaningfully review. That’s the real ceiling, and it’s a human one.

Verification: The Tip That Never Changed

Across every thread, podcast, and interview, one piece of advice appears unchanged: give Claude a way to verify its own work. Boris has called it “probably the most important thing to get great results out of Claude Code,” worth 2-3x on the quality of the final result.

His analogy is the clearest explanation of why:

“Think of it like any other engineer: if you ask someone to build a website but they aren’t allowed to use a browser, will the result look good? Probably not. But if you give them a browser, they will write code and iterate until it looks good.”

Verification is domain-specific, and that’s the work. There is no generic solution:

• Backend — make sure Claude knows how to start your server or service to test end-to-end
• Frontend — the Claude Chrome extension. Asked directly whether it beats Playwright or a Chromium MCP for E2E, Boris: “Yes. It’s more powerful and more token-efficient.”
• Mobile — iOS/Android simulator MCP
• Desktop apps — computer use
• Data — the bq CLI, or any database with a CLI, MCP, or API

Scripted tests or Claude-driven tests? Boris: “We do both! Depends if it’s a one-off or something you want to run on future PRs.” One-off check → let Claude drive it. Something you want on every PR → have it write a real test.

Why verification matters more as autonomy increases. This is the connection people miss. Verification isn’t just a quality tactic — it’s the precondition for everything in the parallelism stack. If you’re going to launch an agent and walk away for an hour, the only thing that makes the result trustworthy is that the agent checked its own work. Boris on long-running work: “For long running work, verification is important because that way when you come back to a task, you know the code works.”

The /go skill is this principle packaged: test end-to-end, run /simplify, open a PR. And the Opus 4.8 release notes made the same point from the model side — the improvement Boris highlighted wasn’t the benchmark jump but that the model “tells you when it’s unsure and catches its own bugs instead of declaring victory early.” A model that overclaims at step 4 wastes the next 40 steps.

What This Means for Individual Developers

Three shifts in how the work feels, based on what Boris and the Claude Code team describe.

From guidance to delegation. Cat Wu’s framing: “The model performs best if you treat it like an engineer you’re delegating to, not a pair programmer you’re guiding line by line.” The old loop — describe a step, watch output, correct, describe the next step — has high interrupt frequency and keeps you permanently in the loop. The new loop is: write a crisp brief, launch, come back when it’s done or when it asks a real question.

From writing code to finding unknowns. Thariq’s July 2026 field guide introduces the most useful conceptual frame in the corpus: your job is now managing the gap between the map (what you tell Claude) and the territory (the actual codebase and constraints). He breaks unknowns into four types — known knowns (what’s in your prompt), known unknowns (questions you know to ask), unknown knowns (“I’ll know it when I see it”), and unknown unknowns (what you never considered).

His observation: “The best agentic coders have relatively few unknowns.” And the practical technique — ask Claude to find them for you: “Can you do a blindspot pass to help me figure out my relevant unknown unknowns and help me prompt you better.”

From author to reviewer, with a real risk attached. If you’re not writing the code, you need a deliberate mechanism to still understand it. Thariq’s practice: after a long session, ask Claude to quiz you on the changes, and only merge after passing. “Give me an HTML report on the changes to read and understand with context, intuition, and what was done — and a quiz at the bottom on the changes that I must pass.” Reading diffs alone produces shallow understanding; this is a countermeasure worth adopting.

What This Means for Engineering Teams

Translating one person’s workflow into something a team can run requires a few deliberate choices.

1. Make verification a first-class investment. It’s the one tip that survived every model generation and it’s worth 2-3x on output quality. Build domain-specific verification into your tooling: how does an agent start your service, exercise your UI, check your data? This is infrastructure work, not prompt work.

2. Treat CLAUDE.md as a shared, living artifact. Checked into git, contributed to by the whole team, updated during code review via @claude tags. Not a document someone writes once during onboarding. And keep it lean — the context-minimalism shift applies here too. A 1,000-line CLAUDE.md is a liability, not an asset.

3. Ban the conversational correction as a team norm. Every fix goes into a rule or a skill. Corrections that live only in a chat transcript are lost work. This is the highest-leverage cultural change available and it costs nothing.

4. Standardise worktrees before you scale parallelism. Parallel agents without isolation produce merge chaos. Worktrees are the prerequisite, not the polish. Get this in place before encouraging engineers to run five sessions.

5. Budget review capacity, not just tokens. If one engineer opens 30 PRs a day, human review becomes the binding constraint immediately. Anthropic built agent-based code review specifically because “code output per engineer is up 200% this year, and reviews were the bottleneck.” If you’re going to enable the productivity, plan for the review load it creates.

6. Re-audit your practices every quarter. Boris reversed two central recommendations in six months. Date your internal guidance, tie it to model versions, and schedule the review. Frozen standards become technical debt faster in this domain than any other.

7. Hire for judgment, not typing speed. Boris predicts the title “software engineer” starts giving way to “builder,” and notes that on the Claude Code team everyone codes — PMs, designers, data scientists — with 50%+ overlap between engineering, product, and design. The durable skills are direction, verification, and taste.

The caveat that belongs on all seven. Boris works at Anthropic, on Anthropic’s own codebase, with effectively unlimited tokens and pre-release model access. His advice to startups — “Don’t try to cost-cut at the beginning. Start by giving engineers as many tokens as possible” — is easier to follow when your employer makes the tokens. Copy the principles. Adapt the setup to your actual constraints.

Frequently Asked Questions

Who is Boris Cherny?

Boris Cherny is the creator and head of Claude Code at Anthropic. He previously spent five years as a Principal Engineer at Meta and is the author of Programming TypeScript (O’Reilly). He has publicly documented his Claude Code workflow through multiple X threads, appearances on Lenny’s Podcast, The Pragmatic Engineer, and Sequoia’s Training Data podcast, and a one-year retrospective interview with Cat Wu.

What is Boris Cherny’s most important Claude Code tip?

Give Claude a way to verify its own work. He has called this “probably the most important thing to get great results out of Claude Code,” estimating it’s worth 2-3x on the quality of the final result. Verification is domain-specific: bash commands and test suites for backend, the Claude Chrome extension for frontend, simulator MCPs for mobile, computer use for desktop apps.

Does Boris Cherny still use plan mode?

No. Plan mode was his most-repeated tip in January 2026, but by June 2026 he had stopped using it entirely, saying: “The newer models don’t actually need a planning step. It was really important for Opus 4 through 4.5, but starting with 4.6, and definitely with 4.7, it just doesn’t need it.” He uses auto mode instead. Some engineers still use plan mode for the written artifact it produces, which remains a legitimate reason.

What is context minimalism?

Context minimalism is the practice of giving a model the minimal viable system prompt and tool set, plus a way to fetch what it needs, rather than front-loading extensive context. Boris describes the progression: Sonnet 3.5 was the prompt-engineering era, Opus 4 was the context-engineering era, and current models need neither. Cat Wu’s framing: “When you give the model too much context, it’s like you’re micromanaging it.” Minimal is not vague — you still provide goal, constraints, and acceptance criteria.

How many Claude Code sessions does Boris run at once?

Roughly 5 terminal sessions in separate git worktrees, plus 5-10 additional sessions on claude.ai/code, plus subagents spawned within those sessions. He manages them through agent view (claude agents), a control plane that groups sessions by needs-input, working, and completed status.

What is the “write it down” principle?

Boris’s rule that when Claude makes a mistake, you should never simply correct it conversationally — instead have it written into CLAUDE.md or turned into a skill. His words: “Every single time Claude makes a mistake, I don’t tell it to do it differently. I tell it to write it to the CLAUDE.md, or make a skill. If you can do this, then Claude can just run forever.” A correction fixes one run; a written rule fixes every future run.

What is compounding engineering?

A term Boris borrows from Dan Shipper for the practice of turning every learning into a permanent artifact. On the Claude Code team it works like this: during PR review, engineers tag @claude in a comment asking it to add the learning to CLAUDE.md, and Claude commits the rule as part of the same PR. The team’s error rate trends down over time rather than resetting each session.

How does Boris Cherny handle parallel agents without conflicts?

Git worktrees. Each Claude Code session runs in its own worktree, so parallel agents never clobber each other’s edits. This is now natively supported via claude --worktree, a checkbox in the Desktop app, and isolation: worktree in custom agent frontmatter. The Claude Code team calls worktrees “the single biggest productivity unlock.” Non-git version control can use WorktreeCreate hooks.

Is auto mode safe to use?

Boris argues it’s safer than manually reviewing every permission prompt: “When you accept 99% of requests, your eyes glaze over. Auto mode is more safe than reading every single permission prompt because it means you’re only paying attention to the most important thing.” The team hardened it by collecting thousands of agent transcripts, having auto mode classify each action, and bringing in red-teamers whose successful attacks became evals.

Can engineering teams realistically copy Boris Cherny’s workflow?

The principles transfer; the setup doesn’t always. Boris works at Anthropic, on Anthropic’s own codebase, with effectively unlimited tokens and pre-release model access. His advice to “give engineers as many tokens as possible” is easier when your employer makes the tokens. The durable, transferable practices are: invest in domain-specific verification, treat CLAUDE.md as a shared living artifact, write corrections down rather than saying them, standardise worktrees before scaling parallelism, and budget for the review load that increased output creates.

Final Take

The most useful thing about Boris Cherny’s public workflow isn’t any individual tip. It’s that he keeps a public record of what stopped working — and the list is longer than most practitioners would be comfortable publishing. Plan mode, once his headline recommendation, is gone. Context engineering, an entire discipline that grew up around Opus 4, has been replaced by its opposite. Both changes happened within six months, and both were caused by the models getting better rather than by anyone being wrong at the time.

That’s the lesson worth internalising. In a field this fast-moving, a documented practice is a snapshot, not a standard. The teams that will do best are the ones that write down what they’re doing, tie it to the model generation it was written for, and schedule a genuine re-audit each quarter — rather than the ones that build an elaborate internal methodology and then defend it.

What has survived every reversal is small and unglamorous: give the agent a way to check its own work, and write every correction down so it never has to be made twice. Those two habits are worth more than any configuration. They’re also the two that most teams skip, because verification infrastructure is real engineering work and updating a shared CLAUDE.md is nobody’s favourite Tuesday.

The rest — worktrees, auto mode, /goal, agent view, dynamic workflows — is a stack of bottleneck removals, and each layer only matters once the layer below it is solved. There’s no point running fifty parallel agents if none of them can tell whether their own work is correct.

Published July 2026 · The AI & Tech Society · digitalstrategy-ai.com

Sources: Boris Cherny’s public X threads from January 2, January 31, February 11, February 20, February 27, March 7-9, March 29, April 16, May 28, and June 9, 2026, as aggregated by the community at howborisusesclaudecode.com (a fan-made collection, not affiliated with Anthropic); Lenny’s Podcast episode “Head of Claude Code: What happens after coding is solved” (February 19, 2026); The Pragmatic Engineer, “Building Claude Code with Boris Cherny” (March 4, 2026); Sequoia Training Data at AI Ascent 2026 (May 5, 2026); “Reflecting on a year of Claude Code” with Boris Cherny and Cat Wu (June 8, 2026); Thariq Shihipar and Sid Bidasaria’s dynamic workflows guide (June 2026) and “A Field Guide to Fable: Finding Your Unknowns” (July 3, 2026); Cat Wu’s threads on Opus 4.7 and dynamic workflows; Anthropic’s official Claude Code documentation. Productivity figures (200% per-engineer output, 4% of GitHub commits, 10-30 PRs/day) are as stated by Boris and Anthropic and have not been independently audited. Verified July 2026.