The Claude Code Playbook: How Its Creator Shipped 259 PRs in 30 Days

259 PRs. 497 commits. 40,000 lines of code. Zero IDE sessions. All in 30 days. All by Claude Code.

Those aren’t hypothetical metrics. They’re what Boris Cherny—the engineer who created Claude Code as a side project at Anthropic in September 2024—reported in late December 2025. His viral X thread revealing his exact Claude Code workflow went viral because it delivers something rare in AI discourse: a disciplined system that treats AI coding like production infrastructure, not parlor tricks.

No exotic prompt engineering. No galaxy-brain hacks. Just a workflow that works—and one the rest of us can implement today.

The Numbers Behind the Workflow

Let’s establish the scope. Cherny’s 30-day metrics, shared in late December 2025: 259 PRs landed, 497 commits, 40,000 lines added, 38,000 lines removed. Every single line written by Claude Code paired with Opus 4.5. He confirmed publicly: “In the last thirty days, 100% of my contributions to Claude Code were written by Claude Code.”

The kicker? “The last month was my first month as an engineer that I didn’t open an IDE at all.” This isn’t a PoC. It’s production work on a tool used by a rapidly growing developer community. And Cherny’s background makes the accomplishment even more striking: startups → VC → product at Facebook and Instagram → leading code quality initiatives at Meta → Anthropic. This is someone who knows what production code looks like.

What makes this workflow different from typical AI-assisted development? It’s not about prompting harder. It’s about system design.

Run Parallel, Not Sequential

Cherny runs 10-15 concurrent Claude sessions at once. Not because he’s impatient—because it’s faster and prevents context switching. Here’s the setup:

• 5 terminal instances with numbered tabs (1-5) and system notifications when Claude needs input
• 5-10 web sessions open on claude.ai/code simultaneously
• iOS app sessions started from phone, continued on desktop
• Separate git checkouts per session to avoid conflicts

The parallelism isn’t accidental. It’s a deliberate throughput strategy that mirrors how engineering teams work—multiple people on separate branches, coordinated through version control. Claude Code’s capabilities extend far beyond typical dev work, but this parallel approach unlocks its true productivity ceiling.

Model choice matters here. Cherny uses Opus 4.5 with extended thinking exclusively. His reasoning: “Opus is slower per request, but less steering needed—Claude gets it right the first time.” The upfront latency cost pays dividends in reduced iteration cycles.

Plan First, Execute Once

Every PR starts the same way: Plan Mode. Activate it with Shift+Tab twice, then iterate on the approach until it’s solid. Then switch to auto-accept edits mode for implementation. Cherny reports the execution is “usually 1-shot” from a good plan.

This two-phase approach—interactive planning followed by unattended execution—inverts the typical AI workflow. Most developers prompt, check the output, prompt again, check again. Cherny front-loads the thinking into plan iteration, then lets Claude execute without babysitting. The result: fewer wasted cycles, cleaner commits, less context pollution.

Plan Mode isn’t new to Claude Code. What’s new is treating it as the mandatory first step for every non-trivial change, not an optional nice-to-have.

CLAUDE.md: The Team Brain That Gets Smarter

Here’s where Cherny’s workflow becomes a system instead of a collection of tips. CLAUDE.md is a shared file checked into git, currently ~2,500 tokens, maintained by the whole team. It contains:

• Common bash commands for the repo
• Code style conventions
• Architectural patterns
• Mistakes to avoid (the most valuable section)

The team updates it multiple times weekly. During code reviews, they tag @.claude on PRs to trigger updates to the file. Every mistake becomes a rule. Every edge case becomes documented context. The file grows organically, encoding institutional knowledge that would otherwise live in Slack threads and tribal knowledge.

The genius here: CLAUDE.md is checked into git. It versions alongside the code. It’s reviewable. It’s diffable. It’s a living artifact that improves with the codebase, not a static prompt library that rots.

Slash Commands and Subagents: Automate the Inner Loop

Slash commands live in .claude/commands/ and replace repetitive prompting with one-word shortcuts. Cherny’s most-used command: /commit-push-pr, invoked “dozens of times every day.” These commands can inject dynamic context using shell preprocessing (!`command` syntax) to gather information before Claude even sees the prompt.

But commands are just macros. Subagents are where the architecture gets interesting.

Cherny uses two subagents with dedicated context windows:

• code-simplifier: Runs after implementation to reduce complexity
• verify-app: Executes end-to-end testing with detailed instructions

Subagents keep the main thread clean. Instead of polluting your primary context with “now simplify this” or “run the test suite,” you delegate to a fresh agent optimized for that specific task. The pattern mirrors microservices: bounded contexts, clear interfaces, separation of concerns.

Community tools like Subtask extend this pattern with git worktrees, enabling parallel subagents to work on isolated branches simultaneously.

Verification: The Single Highest-Leverage Practice

Cherny calls this “the most important thing” in his workflow. “Give Claude a way to verify its work—it will 2-3x the quality of the final result.”

That’s not a marginal improvement. That’s a force multiplier. Here’s how verification manifests in practice:

• Command-line tests: npm test, typecheck, lint before every commit
• Chrome extension testing: For every change to claude.ai/code, Claude opens Chrome, tests the UI, and iterates until it works
• API verification: curl requests to validate behavior
• Pre-commit hooks: Block commits that fail CI checks

The workflow looks like this: Claude makes changes → runs verification → sees failures → fixes them → repeats until green. The human never steps in to manually verify. The loop is fully automated.

A detailed breakdown from the DEV Community highlights Cherny’s use of PostToolUse hooks—custom automation that runs after every tool invocation. His formatting hook auto-formats code after edits, handling “the last 10%” of formatting to prevent trivial CI errors.

This is the delta between “Claude wrote some code” and “Claude shipped production-ready code.” Verification converts AI assistance from draft generator to autonomous contributor.

Permissions, MCP, and Production Safety

Cherny’s permission strategy: never use --dangerously-skip-permissions in production contexts. Instead, he uses /permissions to selectively pre-allow common bash commands. For long-running tasks in sandboxed environments, --permission-mode=dontAsk is acceptable. But the default posture is cautious.

Model Context Protocol (MCP) extends Claude’s reach without compromising safety. Cherny’s team uses MCP servers to connect Claude to Slack, BigQuery queries, and Sentry logs. The configuration lives in .mcp.json, checked into git and shared across the team. This gives Claude access to production context—error logs, user analytics, internal discussions—without manual copy-paste workflows.

The pattern mirrors how agentic AI tools require careful permission management: grant access incrementally, verify behavior, expand gradually. Never blanket-approve. Never skip safety rails in prod.

What This Means for the Rest of Us

The takeaway isn’t “use Claude Code exactly like Cherny does.” It’s “structure beats prompting.” His workflow works because it’s a system—not a collection of clever tricks.

The highest-leverage components:

• CLAUDE.md: Start today. One file, checked into git, updated during code reviews. Every mistake becomes a rule.
• Verification loops: Give Claude a way to test its own work. Automated testing, pre-commit hooks, browser automation—pick the methods that fit your stack.
• Plan Mode first: Iterate on approach before implementation. Front-load the thinking.
• Parallelism: Multiple sessions on separate branches. Coordinate through git, not through human context switching.

The cost question looms. Opus 4.5 isn’t cheap. But Cherny’s framing is correct: total cost matters, not per-request cost. If verification loops reduce rework by 50%, the marginal API cost is irrelevant. If parallel sessions enable shipping 2x faster, you’re not comparing model pricing—you’re comparing developer velocity.

And this workflow will only get more powerful. Swarming—orchestrated multi-agent execution—is a pattern the community expects Anthropic to formalize. The parallel patterns in Cherny’s playbook are likely a preview of what’s coming: not one Claude instance working linearly, but coordinated agents working in parallel, each with specialized context and verification loops.

Cherny put it plainly: “Software engineering is changing, and we are entering a new period in coding history. And we’re still just getting started.”

Start with CLAUDE.md and verification loops. They’re the highest-leverage, lowest-effort changes. The rest of the workflow compounds from there.