TL;DR: Boris Cherny runs 15 AI clones simultaneously across terminal, web, and mobile using separate git checkouts to avoid conflicts. He uses session teleportation to seamlessly move tasks between devices and platforms based on optimal use cases. This parallel AI workflow lets him conduct an orchestra of code-writing agents while maintaining organization through smart file system architecture.
The Creator of Claude Code Just Dropped His Workflow, and Developers Are Losing Their Collective Minds
If you’ve ever felt productive running two terminal windows at once, I have some news for you: you’re playing checkers while Boris Cherny is playing 4D chess with 15 AI agents running simultaneously across three different devices.
Boris is the creator of Claude Code at Anthropic — yes, the guy who built the tool. And when he casually dropped a Twitter thread explaining his workflow, the developer community collectively spat out their artisanal coffee and started taking notes.
What follows is a complete breakdown of his setup. Prepare to feel both inspired and personally attacked by your own inefficiency.
The Setup: One Man, Fifteen Claudes, Zero Chill
Let’s start with the numbers that broke Twitter:
- 5 Claude instances running in terminal (numbered tabs 1–5, like a proper psychopath)
- 5–10 Claude sessions on claude.ai/code in the browser
- Multiple sessions spawned from his iPhone throughout the day
That’s 15+ parallel AI sessions. Across three platforms. At the same time.
“But wait,” you say, “won’t they conflict? Won’t chaos ensue?”
Oh, sweet summer child.
Boris has built an entire operating system around this chaos. Each Claude session handles different tasks, and he uses system notifications to know when one needs input. Crucial detail from the comments: Boris uses 5 separate git checkouts of the same repo. Each Claude works on its own copy, avoiding merge conflicts entirely. No magic — just smart file system architecture.
It’s like being a conductor of a 15-piece AI orchestra, except the orchestra writes production code.
Boris uses 5 separate git checkouts of the same repo. Each Claude works on its own copy, avoiding merge conflicts entirely. No magic — just smart file system architecture.
This invite link gives you one Week of Claude https://claude.ai/referral/eTWMC0AWNg
(only 2 remaining, as writing
The Platform Strategy
| Platform | Best For |
|---|---|
| Terminal | Active coding, file edits, commands |
| Web | Code review, documentation, visual diffs |
| iOS | Starting tasks on the go, checking progress |
The secret sauce? Teleportation. Not the Star Trek kind — the --teleport flag that lets you move a session between devices seamlessly. Start a task on your phone during your morning coffee, teleport it to your terminal when you sit down, then background it to the web when you need to focus on something else.
> analyze this entire codebase and generate documentation &
claude --teleport <session-id>
This is the developer equivalent of passing a basketball to yourself through a portal.
Model Choice: Bigger Is Actually Faster (Wait, What?)
Here’s where Boris drops some counterintuitive wisdom that will make your optimization instincts weep:
He uses Opus 4.5 with extended thinking for everything.
“But Opus is slower!” screams the inner voice of every developer who has ever benchmarked response times.
Boris’s argument? The math works out differently when you factor in human time:
Sonnet (faster model):
Request: 30 seconds
× 5 iterations (steering, correcting)
= 2.5 minutes + your sanity
Opus (slower model):
Request: 2 minutes
× 1 iteration (gets it right first time)
= 2 minutes + your sanity intact
The key insight: the bottleneck isn’t AI processing time — it’s human time spent steering and correcting. Opus requires less hand-holding, makes better tool use decisions, and generally doesn’t need you to say “no, not like that” seventeen times per task.
It’s like the difference between a junior developer who’s fast but needs constant code review, versus a senior who’s slower but ships production-ready code. Except the senior is an AI and you can run fifteen of them in parallel.
CLAUDE.md: Your Codebase’s Collective Memory
This is where it gets genuinely brilliant.
The Claude Code team maintains a single CLAUDE.md file, checked into git, that the entire team contributes to multiple times per week. Think of it as a living document that captures every "don't do that" lesson Claude learns.
Claude makes mistake →
Developer notices →
Add pattern to CLAUDE.md →
Commit to git →
Claude reads it next session →
Claude never makes that mistake again
It’s like having a new developer who never forgets anything you tell them and shares that knowledge with every other instance of themselves across time and space.
What Goes In CLAUDE.md?
Boris revealed the actual specs: their CLAUDE.md is 2.5k tokens and covers:
- Common bash commands
- Code style conventions
- UI and content design guidelines
- How to do state management, logging, error handling, gating, and debugging
- Pull request template
That's it. Not a novel — a focused reference document.
## Project Structure
- /src contains application code
- /tests mirrors /src structure
## Common Commands
- npm run build: Build the project
- npm run test: Run test suite
- npm run lint: Run linter with auto-fix
## Our Conventions
- We use TypeScript strict mode everywhere
- Prefer const over let, always
- Function names should be verbs
## Things Claude Has Done Wrong Before
- Don't use deprecated APIs (here's the list...)
- Never modify the .claude/ directory directly
- Always run tests before suggesting a commit
The team even uses a GitHub Action to automatically tag @.claude during code reviews, asking it to update the CLAUDE.md based on patterns found in PRs. Every code review becomes a learning opportunity that compounds over time.
As one observer noted: “Every mistake becomes a rule. The longer the team works together, the smarter the agent becomes.”
It’s basically RLHF, but conducted by your entire engineering team through code reviews.
The Two-Phase Workflow: Think First, Ship Later
Boris doesn’t just yolo his way through prompts. He’s developed a disciplined two-phase approach:
Phase 1: Plan Mode (Interactive)
[Shift+Tab][Shift+Tab] — enters Plan mode
You: "I need to add OAuth authentication"
Claude: "Here's my plan:
1. Install passport-oauth2
2. Create OAuth config file
3. Add /auth/login and /auth/callback routes
4. Update user model for OAuth data
5. Create auth middleware
6. Update frontend with login button
7. Add tests"
You: "Looks good, but add refresh tokens too"
Claude: *updates plan*
Phase 2: Execute Mode (Autonomous)
Once the plan is approved, Boris switches to auto-accept mode. Claude then executes the entire plan, often in one shot.
The philosophy is simple: invest time upfront in planning, save way more time in execution. It’s the AI-powered version of the carpenter’s adage: measure twice, cut once. Except here it’s: plan interactively, code autonomously.
A good plan is really important, Boris emphasizes. And he’s right — a well-structured plan means Claude can chain together dozens of file edits without needing human intervention at every step.
Slash Commands: Because Typing Is For People With Time
Boris clarified in the comments: “Skills = slash commands, I use them interchangeably.” Same thing, different names.
Boris has automated every “inner loop” workflow into slash commands that live in .claude/commands/:
<!-- .claude/commands/commit-push-pr.md -->
---
description: Commit changes, push to remote, and create PR
---
!`git status --short`
!`git branch --show-current`
# Recent Commits
!`git log -5 --oneline`
Based on git status above:
1. Stage and commit changes with descriptive message
2. Push to remote
3. Create PR with clear title and description
4. Request review from appropriate team members
The inline bash (those ! commands) pre-computes context so Claude doesn't need to ask. It sees the git status, knows the current branch, understands the recent history — and can make intelligent decisions immediately.
Boris uses /commit-push-pr dozens of times every day. That's dozens of multi-step git workflows reduced to seven keystrokes.
Other commands from his setup:
-
/quick-commit— Stage all and commit with auto-generated message -
/test-and-fix— Run tests, fix failures, repeat until green -
/review-changes— Review uncommitted changes and suggest improvements -
/first-principles— Deconstruct problems to fundamental truths
These are checked into git and shared across the team. Everyone benefits from everyone’s workflow optimizations.
Subagents: Specialized AI Colleagues
Beyond slash commands, Boris uses subagents — specialized AI assistants with their own system prompts, tool access, and separate context windows.
| Agent | Purpose |
|---|---|
code-simplifier |
Simplifies code after Claude is done working |
verify-app |
Thoroughly tests the application works correctly |
code-architect |
Design reviews and architectural decisions |
build-validator |
Ensures project builds correctly for deployment |
oncall-guide |
Helps diagnose and resolve production issues |
Think of them as specialized experts you can call in for specific tasks. The code-simplifier runs after every feature to reduce complexity. The verify-app agent has detailed instructions for testing Claude Code end-to-end.
The key difference from slash commands: subagents have their own context window, so they don’t pollute your main conversation. They’re truly separate workers handling specific jobs.
Hooks: The Ultimate Automation Layer
Claude Code supports hooks — automated actions that run at specific points in the workflow. Boris uses a PostToolUse hook to auto-format code:
{
"hooks": {
"PostToolUse": [{
"matcher": "Edit|Write",
"hooks": [{
"type": "command",
"command": "npx prettier --write \"$CLAUDE_FILE_PATH\""
}]
}]
}
}
Every time Claude edits or writes a file, Prettier automatically formats it. This catches the last 10% of formatting issues, preventing CI failures without any human intervention.
Without hook:
Claude writes code → Push to PR → CI fails on formatting →
Fix formatting → Push again → CI passes
With hook:
Claude writes code → Hook formats → Push to PR → CI passes ✓
It’s the difference between cleaning up after your robot vacuum and having a robot that cleans up after itself.
The Permission System: Security Without Friction
Boris explicitly avoids --dangerously-skip-permissions. Instead, he uses /permissions to pre-allow specific safe commands:
{
"permissions": {
"allowedTools": {
"Bash": {
"allowedCommands": [
"git status",
"git diff",
"git commit",
"npm test",
"npm run build",
"npm run lint"
]
},
"Edit": { "allowed": true },
"Read": { "allowed": true }
}
}
}
This gives you the convenience of auto-approval for operations you know are safe, while still requiring explicit permission for anything unusual. It’s like giving your AI a set of house keys instead of the nuclear launch codes.
MCP Integration: Claude’s Connection to Everything
Claude Code uses MCP (Model Context Protocol) to connect to external tools. Boris’s setup includes:
- Slack — Post updates, notifications, search conversations
- BigQuery — Run analytics queries via
bqCLI - Sentry — Fetch error logs directly
- iOS/Android simulators — for mobile app verification (yes, there are MCPs for that)
{
"mcpServers": {
"slack": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-slack"],
"env": {
"SLACK_BOT_TOKEN": "xoxb-...",
"SLACK_TEAM_ID": "T..."
}
}
}
}
Now Claude can do things like:
> Deploy to staging and notify the team in #deployments
Claude: [Runs deployment]
Claude: [Uses Slack MCP server]
Claude: [Posts to #deployments channel]
✓ Deployment complete, team notified
The .mcp.json file is checked into git. The entire team gets these integrations automatically.
The Ralph Wiggum Method: For When You Need AI That Just Won’t Quit
For very long-running tasks, Boris uses something called the Ralph Wiggum plugin. Named after the Simpsons character who cheerfully persists despite all obstacles, it creates an iterative loop that keeps Claude going until a task is actually complete.
The concept:
Iteration 1:
Claude: [Implements basic API]
Claude: [Tries to exit]
Stop Hook: [Tests failing - block exit]
Stop Hook: [Feed same prompt back]
Iteration 2:
Claude: [Sees test failures]
Claude: [Fixes bugs]
Claude: [Tries to exit]
Stop Hook: [Some tests still failing - block exit]
Iteration 3:
Claude: [Fixes remaining bugs]
Claude: [All tests passing]
Claude: [Outputs <promise>COMPLETE</promise>]
Stop Hook: [Completion promise detected - allow exit]
✓ Done!
For these long-running autonomous sessions, Boris uses either --permission-mode=dontAsk or --dangerously-skip-permissions — but only in sandboxed, isolated environments.
The Golden Rule: Give Claude a Verification Loop
Here’s Boris’s most important tip, and he saved it for last:
Give Claude a way to verify its work. If Claude has that feedback loop, it will 2–3x the quality of the final result.
This is the secret sauce that makes everything else work.
Without verification:
Claude writes code → Pushes to PR →
CI fails → Bugs in production →
Manual debugging required
With verification:
Claude writes code → Tests it →
Sees failures → Fixes them →
Retests → Iterates until passing →
High-quality code
Verification looks different for each domain:
- CLI tools: Run the command, check output
- APIs: Make requests, verify responses
- UI: Use Claude’s Chrome extension to visually test
- Backend: Run test suite, check coverage
- Mobile apps: Use iOS/Android simulator MCPs to test on device iterates until the code works and the UX feels good.
Invest in making verification rock-solid. It’s the single highest-leverage improvement you can make to AI-assisted development.
The Full Stack: Everything Together
Here’s Boris’s complete setup in one view:
- 15+ Parallel Sessions — Terminal, web, iOS
- Opus 4.5 + Extended Thinking — Best model, faster overall
- Team CLAUDE.md — Shared knowledge base, version controlled
- GitHub Action — Auto-update CLAUDE.md from PRs
- Plan Mode → Auto-Accept — Two-phase workflow
- Slash Commands — Automate repeated workflows
- Subagents — Specialized AI assistants
- PostToolUse Hook — Auto-format code
- Smart Permissions — Pre-allow safe commands
- MCP Integration — Connect to Slack, BigQuery, Sentry
- Ralph Wiggum — Iterative loops for long tasks
- Verification — Most important: feedback loops everywhere
What This Means for the Rest of Us
The reaction to Boris’s thread has been… intense.
“If you’re not reading the Claude Code best practices straight from its creator, you’re behind as a programmer,” wrote one industry observer.
“This is potentially their ChatGPT moment,” declared another.
The excitement stems from a paradox: Boris’s workflow is surprisingly simple, yet it allows a single human to operate with the output capacity of a small engineering department.
In the last thirty days, Boris landed 259 PRs — 497 commits, 40k lines added, 38k lines removed. Every single line was written by Claude Code + Opus 4.5.
That’s not a workflow. That’s a force multiplier.
Getting Started (Without Burning Down Your House)
You don’t need to implement everything at once. Start small:
- Create a CLAUDE.md — Document your project’s conventions
- Set up one slash command — Automate something you do daily
- Add verification — Give Claude a way to test its work
- Configure permissions — Pre-allow safe commands
- Add a hook — Auto-format code on save
Then iterate. Add more slash commands as patterns emerge. Create subagents for specialized tasks. Expand your MCP integrations.
The goal isn’t to match Boris’s setup — it’s to build your own compound learning machine that gets better every day.
The Failure Rate Nobody Talks About
When asked what percentage of sessions he abandons, Boris replied: “Maybe like 10–20%?”
Even the creator of Claude Code doesn’t have a 100% success rate. Some sessions just don’t work out. That’s normal. The productivity gains come from the 80% that do.
Final Thoughts
What Boris has demonstrated isn’t just a productivity hack. It’s a glimpse into a different model of software development entirely.
For years, “AI coding” meant autocomplete — a faster way to type. What Boris shows is that AI can now function as an operating system for labor itself.
“Read this if you’re already an engineer and want more power,” summarized one commenter.
The tools to multiply human output by 5x are here. They require only a willingness to stop thinking of AI as an assistant and start treating it as a workforce.
The programmers who make that mental leap first won’t just be more productive. They’ll be playing an entirely different game.
And everyone else will still be typing.
Originally based on Boris Cherny’s Twitter thread. Boris is the creator and head of Claude Code at Anthropic.
Top comments (0)