Boris Cherny's Claude Code workflow, broken down

The boris cherny claude code workflow entered developer conversations in early 2026 for one specific reason: Boris Cherny built the tool. When the person who architected a product documents their own daily use of it, that document carries different weight than any third-party tutorial. Boris published two primary sources in quick succession: an InfoQ interview on 10 January 2026 and a post on his personal site, boristane.com, on 10 February 2026. Together they describe a four-step discipline: plan, approve, generate, verify. This article breaks down that discipline, explains the mechanics behind each stage, and maps what the developer community has built on top of it since those publications.

What makes the Boris Cherny Claude Code workflow a reference point

Most AI coding assistant setup guides come from developers who found something that works for their stack. The boris cherny claude code workflow is structurally different: Boris designed the system. His operational choices reflect product intent, not accidental discovery made by a power user working against the grain.

In the InfoQ interview from 10 January 2026, Boris listed four workflows he runs every day with Claude Code: writing commit messages, opening pull requests, simplifying existing code, and verifying output. That list is short on purpose. It's not a feature tour. It describes what survived months of daily contact with real production code, filtered by someone who could also change the tool when it didn't work.

The February 2026 boristane.com post added the structural rule connecting all four: never allow Claude to write code until a written plan has been reviewed and approved. According to Boris's own documentation, this precondition is what makes an agent-based coding workflow stable over time. It's not a tip layered on top of the product. It's the constraint the rest of the workflow depends on.

The InfoQ article also situated Claude Code as an orchestration layer for scoped tasks rather than an autocomplete system. That framing matters for understanding why the four daily workflows are organized as isolated sub-agents rather than a single long-running session with accumulated context.

Plan first, code second: the review-and-approve gate

The plan gate sits at the heart of the boris cherny claude code workflow. Claude Code proposes a written plan before touching any file. You read it, amend or reject it, and generation starts only after your approval.

This gate targets one specific failure mode: large diffs that implement the wrong scope correctly. A model that writes clean TypeScript can simultaneously refactor files you didn't want touched, extract helpers you didn't request, and rename symbols that break downstream consumers. That code passes a linter. It doesn't match your intent. Making scope legible before it becomes a diff is the entire purpose of the gate.

According to the February 2026 boristane.com documentation, a Claude Code plan at this stage covers three elements: the files to be modified, the specific functions or modules in scope, and identified risk areas (side effects, external dependencies, tests that will need updating). You review this as a structured document before any file changes.

What a Claude Code plan contains

A well-formed plan answers three questions: what changes, what doesn't change, and what could break. The file list is the minimum viable output. The risk annotations carry more weight. If Claude Code surfaces "this touches the authentication middleware," that annotation is the conversation you want before a 400-line diff lands in your review queue. The plan also becomes the reference document for the verification step later in the workflow.

How to push back before generation starts

The plan step is interactive. You can reject it outright with a short reason, ask Claude Code to narrow scope ("exclude the test directory in this pass"), or request an alternative approach before anything is written. Boris's documentation doesn't carve out exceptions for one-liner fixes, which implies the discipline applies uniformly. Pushing back at the plan stage costs under a minute. Pushing back on a merged diff costs substantially more.

Slash commands and sub-agents: the four daily workflows

The InfoQ article from 10 January 2026 documented how Boris organizes his daily use around four slash commands, each launching a sub-agent scoped to one task.

Sub-agents in Claude Code run in isolation. Each receives a bounded context window, executes a single task, and returns output without sharing state across invocations. This isolation is what makes the Claude Code daily setup reproducible: the same slash command on the same codebase produces consistent output regardless of previous sessions.

The four commands map to four distinct handoff moments:

Commits. A sub-agent reads the staged diff and proposes a commit message that follows the conventions visible in your existing git history. No manual summarizing.

Pull requests. A sub-agent reads the branch diff against the base and produces a PR description: scope summary, risk notes, reviewer context. This is the artifact a reviewer needs before looking at code, not after.

Code simplification. A sub-agent receives a file or function and returns a simplified version. Boris applies this to code that has accumulated complexity through incremental changes. The output is a proposal, not an automatic commit.

Verification. Covered in the following section.

The AI pair programming approach here is deliberately narrow. Boris doesn't document using Claude Code for test generation, documentation authoring, or architecture exploration in these primary sources. The narrowness is likely intentional: fewer reliable workflows outperform many inconsistent ones over a sustained development cycle.

The verification loop: Claude checking Claude's own output

The verification workflow closes the loop that the planning gate opens. After generation, a dedicated sub-agent compares output against the original written plan. Community breakdowns of Boris's setup, including a 13-lesson analysis on vibecodinglearn.com, describe this as the ruthless verification loop.

The mechanism is specific. The verifier's prompt references the plan document produced at the start of the workflow, not a reformulation of the original request. This distinction removes a common failure mode: prompting a model to check "whether the code does what I asked" invites rationalization. Prompting it to check "whether this output matches this specific document" gives it a concrete artifact to evaluate against.

This is where the living documentation concept in Boris's workflow becomes operational. The plan written before generation is the shared state between the generation sub-agent and the verification sub-agent. Both work from the same source of truth. When the verifier finds a divergence (a file modified outside plan scope, a function that changed signature without annotation), it flags a concrete discrepancy, not an inferred intent mismatch.

The automated code review loop this creates doesn't replace human review. It pre-filters the category of errors most likely to waste reviewer time: scope drift, missing implementations, and side effects absent from the plan. Human review then focuses on logic, performance, and architecture.

What the community built on top of it in 2026

After the January and February 2026 publications, the boris cherny claude code workflow spread quickly through developer communities. The most structured community output is the GitHub repository github.com/llcoolblaze/claude-boris, now at version 2.0, which packages a complete configuration replicating Boris's documented approach: CLAUDE.md structure, slash command definitions, sub-agent scoping rules, and the plan-first gate integrated into project-level settings.

Version 2.0 added items labeled explicitly as community extensions, not present in Boris's original publications. These include parallel sub-agent orchestration for repositories with independent modules and a structured template for the living documentation artifact the verification loop references.

The vibecodinglearn.com breakdown extracted 13 actionable lessons from Boris's published material. Three appear consistently across independent implementations regardless of tooling: the plan gate, the single-task sub-agent discipline, and the verifier-references-plan rule. Developers using different editors, languages, and CI systems have reproduced the core workflow without Claude Code's native slash command system, by implementing equivalent scope-limiting steps manually.

What remains in power-user territory as of 2026: parallel multi-agent orchestration across the independent subsystems of a large monorepo. The four-command daily loop is broadly reproducible. Running multiple sub-agents simultaneously against separate modules requires rate limit management and output aggregation decisions that most individual developers haven't yet standardized. Reddit threads analyzing this workflow since January 2026 consistently distinguish the discipline (transferable, adopted broadly) from the specific tooling choices (Claude Code, particular CLAUDE.md structure). The former is what Boris's publications actually document.

FAQ

Does the workflow require a Claude Pro or Max subscription?

The plan gate and four slash commands work on any Claude Code tier. Parallel sub-agent orchestration at scale benefits from higher rate limits on paid plans. For the core four-workflow loop Boris documents, no specific subscription tier is required.

Does plan-first slow down small one-liner fixes?

For a single-line change, the plan step is lightweight: Claude Code proposes "modify line 47 in config.ts, no other files affected." Reviewing that takes under ten seconds. Boris's documentation doesn't create exceptions for small changes, suggesting the discipline applies uniformly rather than only to large refactors.

How does Boris handle context window limits between sub-agents?

Each sub-agent starts with a fresh context window. State transfers through the written plan document, not through shared memory. For large codebases, this means plans must identify only the relevant files rather than loading entire directory trees into each agent's context.

Is the claude-boris GitHub repository officially maintained by Boris Cherny?

No. The github.com/llcoolblaze/claude-boris repository is a community project. It documents and extends Boris's publicly described workflow but isn't affiliated with Anthropic or maintained by Boris Cherny directly. The additions in version 2.0 are community contributions, not updates from the original source.

Key takeaways

The boris cherny claude code workflow reduces to four steps: write a plan, approve it as a human, generate code, verify output against the plan. The four daily slash commands cover the highest-friction handoffs in a standard development cycle. Community forks active in 2026 confirm the discipline transfers across tooling because the constraint is procedural, not configuration-specific. The sub-agent isolation model, not any particular CLAUDE.md file, is what makes the workflow reproducible 🔄.