Most developers use Claude like a smart search engine. Ask a question, get an answer, move on.
Boris Cherny, Staff Engineer at Anthropic and the person who built Claude Code, ships 20 to 30 pull requests a day. Same tool. Completely different mental model.
A Reddit breakdown by u/Exact_Pen_8973 dissected his workflow in detail. Here’s what actually changes the output.
The Real Difference
The typical developer workflow is sequential: write code, test it, fix bugs, repeat. One task, one context, one thread. You wait for Claude to finish before starting the next thing. And while you wait, you sit there context-switching into Slack, a doc, or another tab, bleeding focus the whole time.
Boris runs five Claude Code instances in parallel, each in its own terminal tab with its own git checkout of the same repo. One builds a feature. One runs tests. One debugs. iTerm2 notifications tell him when an agent needs human steering. He’s the traffic controller, not the driver. The mental shift is significant: instead of following a single thread of execution, you’re managing a system of parallel workstreams and stepping in only when judgment is required.
He calls this setup “surprisingly vanilla.” The output is anything but.
The 5 Techniques Worth Stealing
1. CLAUDE.md is your permanent memory
Claude resets context every session. A CLAUDE.md file in your project root fixes that. Boris runs a 2,500-token version: codebase conventions, PR templates, architectural rules, and a running log of every mistake Claude has made. The key habit is immediacy. When Claude gets something wrong, the fix goes into CLAUDE.md before moving on. He also tags @.claude on teammates’ PRs so knowledge capture happens automatically during code review. The whole team learns from every error, not just the person who was in the room when it happened.
2. 🔀 5 parallel instances, not 1
Stop working sequentially. Open five terminal tabs, give each Claude instance its own git checkout and its own task. Tab 1 builds, Tab 2 tests, Tab 3 debugs. The bottleneck isn’t AI speed. It’s context switching. Parallel execution removes it. Each instance stays focused because it has no awareness of what the others are doing. You’re the only one holding the full picture, which is exactly how it should be.
3. Plan Mode before a single line of code
Use Plan Mode to generate a design doc first. Then ask Claude directly: “If you were a senior engineer, what are the flaws in this plan?” This prompt reliably surfaces edge cases, missing error handling, and assumptions that would have caused rework three hours later. Fix the plan until it’s airtight, then switch to auto-accept edits. Boris reports it usually 1-shots the implementation from there. The time spent in planning pays back immediately in the execution phase because the agent has clear enough instructions to run without constant correction.
4. ✅ Automated verification loops
“Done” doesn’t mean the code is written. Done means tests pass. Boris built a verify-app subagent that runs end-to-end tests automatically after every change. If it fails, the agent auto-fixes and reruns. It repeats until everything is green. Claude never self-reports a task as complete without proof. This is a small architectural decision with a big downstream effect: it removes the ambiguity around “is this actually working” and makes the definition of done concrete and automated.
5. Slash commands for anything you type twice
If you type the same prompt more than once a day, it becomes a slash command checked into .claude/commands/. Examples from Boris’s setup: /commit-push-pr, /code-simplifier. The whole team inherits the workflow automatically. No duplicated effort, no tribal knowledge rotting in someone’s personal notes. Over time, this directory becomes a living library of your team’s best prompts, versioned and reviewable just like the rest of the codebase.
What This Looks Like Day-to-Day
- Build, test, and debug run simultaneously, not back to back
- CLAUDE.md turns individual mistakes into team-wide improvements the moment they happen
- Plan Mode catches architectural problems before a single line is written, not after
- Verification loops eliminate the “works on my machine” problem entirely
- Slash commands compress repeated prompts into one keystroke shared across the whole team
The Actual Shift
You’re not the person writing the code anymore. You’re the person deciding what gets built, in what order, and how it gets verified. That’s a fundamentally different job description, and it requires a fundamentally different setup.
Boris doesn’t have better tools. He has a fundamentally different relationship with the tool. The infrastructure he built around Claude, the parallel instances, the persistent memory file, the automated verification, the shared command library, is what makes the throughput possible. The AI is capable. The workflow is what unlocks it.
And once you see it that way, going back to one terminal tab with one sequential conversation feels genuinely painful.
The full breakdown, including PostToolUse hooks for CI formatting fixes and the exact bash commands, is available at the original source linked below.
Frequently Asked Questions
Q: How does parallel execution work if most development tasks depend on each other?
The parallel tabs aren’t all working on the same feature sequentially, they’re independent work streams. Tab 1 might be building Feature A, Tab 2 testing Feature B’s previous iteration, and Tab 3 debugging a different issue entirely. The key is that your codebase and test suite are structured so these don’t block each other. If you have tightly coupled dependencies, the parallel approach won’t help, but most projects have enough independent areas (UI, API, tests, docs) to keep multiple agents productive at once.
Q: What’s the actual advantage of an automated verification loop over just running tests normally?
The difference is the closed loop. Instead of Claude writing code, you running tests manually, then pasting errors back to Claude, the verification agent runs tests, sees the failures, and iterates automatically until they pass. You’re cutting out the human copy-paste friction. It’s not about better testing, it’s about removing the back-and-forth so Claude can self-correct without you steering every failure.
Q: When priorities shift mid-task, do you rewrite CLAUDE.md rules on the fly or stick with what you started with?
Update it if the shift is fundamental to how Claude should approach the work, but be selective, frequent rewrites create cognitive load. A good rule of thumb: if the new priority contradicts a rule you wrote, update it. If it’s just a scope change, you can usually handle that in the task prompt itself without touching CLAUDE.md. The file is meant to be stable guidance, not a task-by-task instruction manual.
Q: Do you need expensive tools or subscriptions to set this up?
CLAUDE.md files and git workflows are completely free. The main cost is Claude Code itself (via subscription), but the actual workflow, parallel execution, plan mode, automated verification, you can implement with free or cheaper LLM APIs too. It’s the mental model that matters, not the tool price.
Stop using Claude like a chatbot. Here are 7 ways the creator of Claude Code actually uses it.
by u/Exact_Pen_8973 in PromptEngineering