How the Creator of Claude Code Actually Uses Claude Code

Boris Cherny, the creator of Claude Code, publicly shared his development workflow - and it hit over 5,000 likes in just two hours. When the person who built the tool reveals how they actually use it, people pay attention.

What surprised me most was the simplicity. No elaborate customization, no secret configurations. The core of his approach is combining Claude Code’s built-in features in disciplined, deliberate ways.

If you’ve read Andrej Karpathy’s recent breakdown of the abstraction layers developers need to understand in AI code agents, Boris’s guide is the practical companion piece.

Parallel Processing - Run 15 Claude Sessions at Once

Boris runs five Claude instances simultaneously in the terminal, plus another five to ten on claude.ai/code through the browser. He even starts sessions from his phone in the morning and checks on them later.

His setup:

• Number terminal tabs 1 through 5, using system notifications to know when input is needed.
• Switch between local and web sessions with the & command.
• Use --teleport to jump between sessions.
• Each terminal tab has its own git checkout, so every session runs an independent plan on an independent branch.

This is not multitasking for its own sake. Each session handles a discrete, well-scoped task. The parallelism comes from having clear plans, not from context-switching.

An interesting note from the comments: Boris uses separate git checkouts per terminal tab rather than git worktrees. He finds the simpler model easier to reason about when juggling many sessions.

Opus 4.5 with Thinking - Bigger Is Actually Faster

Boris uses the largest available model for every task. This is counterintuitive - Opus is slower per token and more expensive. But his reasoning is practical: the bigger model requires fewer corrections, uses tools more accurately, and produces better first-pass results.

The net effect is that total task completion time is shorter with Opus than with smaller models, because you spend less time fixing mistakes and re-prompting.

• Best coding performance of any model he has tested.
• Fewer interventions needed during execution.
• Overall wall-clock time decreases despite higher per-token latency.

CLAUDE.md - Team Context Engineering

The entire team checks a single CLAUDE.md file into Git. Every time Claude makes a mistake, someone adds a note to this file so the same error does not happen again.

This is compounding engineering in practice:

• Multiple team members contribute updates weekly.
• During code review, the team uses @.claude tags to request CLAUDE.md additions.
• Each team maintains its own CLAUDE.md.
• The file becomes a growing body of institutional knowledge that every Claude session inherits.

The concept is straightforward, but the discipline of maintaining it consistently is what makes it powerful.

Plan Mode - Good Planning Is 90% of Success

Boris starts most sessions in Plan Mode (shift+tab twice). If the goal is a pull request, he discusses the plan with Claude until he is satisfied, then switches to auto-accept mode and lets Claude execute the entire plan without interruption.

The workflow:

1. Invest time upfront in the planning phase.
2. Iterate on the plan until it covers edge cases and potential issues.
3. Once the plan is locked, switch to automated execution.
4. Minimize back-and-forth corrections during implementation.

This pattern eliminates the most common failure mode: starting to code before the approach is clear. Planning is cheap. Rework is expensive.

Slash Commands and Subagents - Automate Repetitive Work

Any workflow Boris uses more than a few times a day becomes a slash command, saved in .claude/commands/. Commands like /commit-push-pr become available to Claude itself, not just the developer.

• Eliminate repetitive prompting entirely.
• Use inline bash to pre-compute context, making commands faster.
• Subagents like code-simplifier and verify-app handle common validation workflows.
• PostToolUse hooks auto-format code after every edit.

Boris also understands Skills as a form of slash commands - reusable, shareable workflow definitions that standardize how Claude approaches specific tasks.

Permission Management and Tool Integration

Instead of using --dangerously-skip-permissions, Boris uses /permissions to pre-approve safe commands. The team shares MCP server configurations so Claude can directly access Slack, BigQuery, Sentry, and other tools.

• Share permission settings via .claude/settings.json.
• Share tool integrations via .mcp.json.
• Minimize unnecessary permission prompts without sacrificing security.

This is the pragmatic middle ground between full lockdown and unrestricted access. The team agrees on what is safe, codifies it, and moves on.

Verification Loops - The 2-3x Quality Multiplier

The single most important practice in Boris’s workflow: give Claude a way to verify its own work.

On claude.ai/code, he has Claude test every change through a Chrome extension that interacts with the actual application. The verification loop includes:

• Background agents that check work after completion.
• Agent Stop hooks that run deterministic validation.
• The ralph-wiggum plugin for additional verification.
• Sandbox environments with adjusted permission modes to avoid blocking.
• Real UX testing in browsers and simulators.

This is not optional polish. Boris considers verification loops the difference between 1x and 2-3x output quality.

The Pattern Behind the Practices

Strip away the specific tools and configurations, and four principles emerge:

• Parallelize aggressively. Run many sessions, each with a clear scope and its own branch.
• Plan before you build. Plan Mode is the highest-leverage feature in Claude Code.
• Share context as a team. CLAUDE.md turns individual lessons into collective knowledge.
• Close the verification loop. Let Claude check its own work before you review it.

The most striking thing about Boris’s setup is not any single technique - it is how few moving parts there are. The creator of the tool does not rely on exotic configurations. He relies on fundamentals, applied consistently.