/agent

wiki / raw / boris-cherny-gergely-orosz-building-claude-code-2026

Building Claude Code with Boris Cherny

updated 2026-08-27

Original source: https://newsletter.pragmaticengineer.com/p/building-claude-code-with-boris-cherny SHA256: 569f43e4a99caf5189751a266d8106c49afe6d0b3eb61c93e332240a7aba67cf

Building Claude Code with Boris Cherny

By Gergely Orosz with Boris Cherny (March 4, 2026). The Pragmatic Engineer Podcast & Deepdive.

An in-depth technical discussion with Boris Cherny (creator and Head of Claude Code at Anthropic, former Principal Engineer at Meta, author of Programming TypeScript) on architecture, parallel agent workflows, deterministic review automation, and agentic search.

Core Extraction Summary

1. Named Frameworks & Patterns (Author’s Exact Words)

  • “5 Parallel Claude Instances”: Running 5 concurrent Claude Code terminal sessions across 5 isolated git checkouts or worktrees.
  • “Plan mode -> One-shot implementation”: Starting sessions in Plan mode, iterating to establish a rigid plan, then switching to auto-accept where Claude one-shots the implementation.
  • “Agentic Search via Glob and Grep”: Claude Code’s retrieval mechanism that outperformed vector databases and recursive RAG by letting the model drive simple filesystem tools.
  • “Automate yourself out of code review” (3-4 occurrences rule): Boris’s Meta pattern of logging repeated code review comments in a spreadsheet and writing a linter rule once a pattern hits 3-4 occurrences.
  • “Prototypes replace PRDs”: Replacing static product requirement documents with rapid functional prototypes built via agents.
  • “Compounding Engineering / CLAUDE.md memory ratchet”: Committing learnings, negative constraints, and architectural invariants to CLAUDE.md whenever an agent makes a mistake.
  • “Medieval Scribe Analogy”: Framing software engineers as modern scribes whose role expands from writing text to designing systems as coding becomes democratized.

2. Decision Rules

  • When executing complex features, start in Plan mode and refine until solid before writing code, because once a comprehensive plan exists, the model one-shots the implementation reliably.
  • When searching large codebases in agent harnesses, use model-directed glob and grep rather than vector RAG or pre-computed embeddings, because vector search suffers from stale indexes and permission boundaries.
  • When an agent makes an incorrect change, immediately commit the constraint to CLAUDE.md, because this ensures the entire engineering team benefits from the correction.
  • When developing features, invest in domain-specific verification tools (e.g. browser extensions for UI, test suites for backend), because closing the verification loop improves output quality by 2–3x.

3. Anti-Patterns & Failure Mechanisms

  • “Incomplete Code Migrations”: Leaving a codebase with multiple competing frameworks (e.g. half Python 2, half Python 3, or mixed REST/GraphQL), which degrades reasoning for both humans and LLMs.
  • “Vector RAG for Codebase Search”: Relying on semantic embeddings that fail on exact symbol references and return outdated file chunks.
  • “Static Mocks & PRDs”: Spending weeks on non-executable design specs instead of testing interactive prototypes.

4. Quantitative Claims & Qualifiers

  • Boris ships 20–30 PRs per day by running 5 parallel Claude Code instances.
  • Causal analysis at Meta proved that high codebase quality has a measurable, double-digit-percent positive impact on developer productivity.
  • Claude Cowork was built from scratch in approximately 10 days.

5. What the Source Does NOT Claim

  • Does NOT claim that engineers no longer need deep systems understanding; explicitly emphasizes that fixing dev infrastructure and understanding type systems remain the highest-leverage engineering tasks.

10 Key Observations from Boris Cherny

  1. Boris ships 20-30 PRs a day by running 5 parallel Claude instances: Works across 5 terminal tabs (each a separate checkout), starting Claude in plan mode, refining the plan, then auto-accepting edits.
  2. Code quality boosts productivity by double-digit percentages: Meta causal analysis proved clean codebases boost output. Partially-migrated codebases confuse models and humans alike.
  3. Claude Code’s “agentic search” is just glob and grep: Plain model-driven glob and grep beat vector databases and recursive model indexing in empirical tests.
  4. Automating out of code review: Logging repeated PR comments and writing lint rules once an issue occurred 3-4 times.
  5. Universal title (“Member of Technical Staff”): Flattens organizational silos so engineers do product, design, and infrastructure.
  6. Claude Cowork built in 10 days: Rapid response to latent demand from non-engineers, focusing engineering effort on sandboxing and OS-level safety.
  7. Prototypes replace PRDs: Dozens of working prototypes built before shipping features instead of static Figma mocks.
  8. The year of the generalist: Transition from single-threaded deep focus to managing parallel agents with rapid context-switching.
  9. Fix infrastructure before product: High-leverage dev infra investments (migrations, type-checkers) unblock all downstream engineering.
  10. Medieval Scribe analogy: Coding democratization expands the reach and demand for software engineers rather than eliminating them.