The Pragmatic Engineer
Episode: Building Claude Code with Boris Cherny
Host: Gergely Orosz
Guest: Boris Cherny, Creator and Engineering Lead behind Claude Code, Anthropic
Date: March 4, 2026
Episode Overview
This deep-dive episode explores the evolution of software engineering in the era of AI, focusing on Claude Code—a fast-growing developer tool built at Anthropic. Host Gergely Orosz interviews Boris Cherny, probing his journey from Meta to Anthropic, the genesis and explosive adoption of Claude Code, and the paradigm shift in code creation, product development, and team collaboration driven by powerful AI coding agents. The conversation also dives into the philosophical and practical impacts of AI on the future of engineering work.
Key Discussion Points & Insights
1. Boris Cherny’s Origin Story (01:08–10:17)
- Early curiosity: Learned to code via eBay HTML tweaks to sell Pokémon cards (“Blink tag got me more money”—[01:20]).
- Calculator programming: Hacked TI calculators to cheat at math, which led him organically into programming via practical problem-solving ([01:45]).
- Startup journey: Dropped out of economics, helped found various startups (including a “weed review” site), then joined Y Combinator’s Agile Diagnosis, learning the value of product market fit through pivoting and on-the-ground customer research ([03:57]).
“Coding is a means to build things and to make useful things.” —Boris [02:51]
2. Lessons from Startups & Meta/Facebook (10:17–18:46)
- Meta experience: Rapid career growth; worked on Facebook Groups, then Instagram, improving dev infra amidst fragmented stacks ([10:38]).
- Massive code migrations: Led company-wide migrations, code quality initiatives, and “Better Engineering”—Zuckerberg’s program to tackle tech debt, showing code quality’s measurable impact on velocity ([17:06]).
“Code quality actually contributes like, you know, double digit percent to productivity. It turns out even at the biggest scale.” —Boris [17:20]
3. Anthropic & The “No Handwritten Code” Moment (18:46–22:10)
- Cultural shock: Boris’s first pull request at Anthropic was rejected—not for code issues, but because he wrote it by hand instead of using internal AI tools ([19:44]).
“I thought that’s how you write code… but Adam was like, actually, you should use this Clyde thing for it instead.” —Boris [19:46]
- Field AGI moment: Realization of how powerful code-generating models already were in 2024 ([20:24]).
“It just one shotted it… this was my first field AGI moment at Anthropic.” —Boris [20:44]
4. The Genesis and Release of Claude Code (22:10–29:52)
- From side-project to flagship: Built initially to understand Anthropic’s API; “just a bash script hitting the API.” Ended up unlocking agentic capabilities with tools ([22:22]).
- Internal debate: Anthropic almost kept Claude Code as an internal productivity edge, but released it for safety research and “to see how users talk about it, what are the risks in the wild” ([26:25], [26:43]).
“The model just wants to use tools. That’s what I realized.”—Boris [25:23]
- Adoption curve: Internal adoption went “vertical,” now “every technical employee at Anthropic uses Claude Code. It writes something like 80% of the code… it writes all my code, for sure”—Boris [29:13]
5. Development Workflow with AI Agents (30:09–39:26)
- Transition to AI code generation: Switched to Quad Code + Opus 4.5 overnight (“The switch was instant… I uninstalled my IDE”—[30:25]).
- Parallel workflows: Runs multiple Claude Code agents in separate terminals/desktops/iOS apps; leverages plan mode for rapid PR authoring ([32:43], [35:29]).
- AI PR Review: 20–30 pull requests a day is now normal, with PRs varying from minor to major rewrites. AI does migrations; humans focus on higher-level decisions ([38:15]).
“Nowadays I ship, you know, 20–30 PRs every day, but every PR is just completely different.”—Boris [38:33]
6. Code Review in the AI Era (39:26–45:24)
- Automating best practices: Linting and code review rules automated via spreadsheet tracking and AI-generated linters ([40:08]).
- Agent-in-the-loop: Claude reviews all PRs in CI, catching “maybe 80% of bugs,” always backed up by a human reviewer for critical code ([41:36], [42:22]).
- Safety layers: Multiple systems—type checkers, static analysis, deterministic linting—ensure code integrity ([44:12]).
“Best of n… all you say is, Claude, start three agents to do this, and that’s it.” —Boris [44:16]
7. Architecture, Security, & Safety of Claude Code (46:18–53:23)
- Simple yet robust: Modular agent core, dynamic tool selection, heavy focus on sandboxing and “Swiss cheese” multi-layered safety ([46:33], [47:14]).
- Prompt injection defense: Handled at alignment, classifier (runtime), and architectural layers. Summarization sub-agent mitigates attacks ([47:14]).
- RAG isn’t king: Originally tried retrieval models/embeddings, but “agentic search” (glob & grep) proved more effective with modern models ([49:04], [51:07]).
“Agentic search… it’s a fancy word for glob and grep.”—Boris [51:07]
8. Product Culture: Generalists, No Titles, No Specs (54:07–63:12)
- No titles (except ‘Member of Technical Staff’): Flattens hierarchy and encourages cross-functional work ([54:31]).
- Prototyping over paperwork: No PRDs, minimal tickets—preference is to ship and iterate rapidly ([58:51], [59:30]).
“The culture is we don’t really write stuff, we just… show.”—Boris [59:30]
- Everyone codes: Designers, PMs, data scientists, even finance use Claude Code for their tasks ([56:29]).
- Hundreds of prototypes: Major features (agent teams, UI flows) refined via rapid prototyping, lots of user feedback ([60:31], [61:36]).
9. Cowork & Swarm Features – Democratizing AI Agents (64:17–77:21)
- Cowork launch: Sparked by observing non-engineers adopting Claude Code for “weird” use cases; built in 10 days by a small team, focused on safety and guardrails for broader audiences ([64:45]).
- Underlying tech: Electron + TypeScript app, extension support, sandboxing, and safety guardrails ([70:23], [67:42]).
- Agent Teams (Swarms): Opus 4.6 enables sophisticated multi-agent orchestration, massively boosting capability for complex tasks ([74:07]).
“Anything where you see a single Claude struggling, the swarms can help.” —Boris [77:10]
10. The Printing Press Analogy & The Future of Engineering (77:21–89:34)
- A transformative moment: Compares AI coding agents to the arrival of the printing press—a new technology empowering everyone, not just an elite ([85:02]).
“There was a group of scribes… and then the printing press came out. What happened? The cost of printed material went down 100x… this effect of making it so this thing that was locked away in ivory tower, now it’s accessible to everyone.” —Boris [85:26]
- Loss & evolution of coding as craft: Coding shifts from gatekept discipline to accessible means for all—“It’s becoming a thing that everyone is able to do.”—Boris [82:15]
- The skillset shift:
- Less valuable: Strong opinions on code style, languages.
- More valuable: Hypothesis-driven thinking, curiosity, context-switching, and adaptability. “Year of the Generalist” ([91:25], [93:51]).
11. Personal Recommendations (94:28)
- Books:
- Cixin Liu (esp. Three Body Problem, short stories)
- Accelerando by Charles Stross
- Functional Programming in Scala (for learning “thinking in types”)
“Accelerando… product roadmap for the next 50 years. It really matches the feeling right now.”—Boris [94:28]
Notable Quotes & Memorable Moments
- “Coding is a means to build things and to make useful things.” —Boris [02:51]
- “I thought that’s how you write code… but Adam was like, actually, you should use this Clyde thing for it instead.” —Boris [19:46]
- “The model just wants to use tools. That’s what I realized.” —Boris [25:23]
- “I uninstalled my IDE… I just didn’t need it anymore.” —Boris [30:09]
- “Nowadays I ship, you know, 20–30 PRs every day, but every PR is just completely different.” —Boris [38:33]
- “Best of n… all you say is, Claude, start three agents to do this, and that’s it.” —Boris [44:16]
- “The culture is we don’t really write stuff, we just… show.” —Boris [59:30]
- “It’s becoming a thing that everyone is able to do.” —Boris [82:15]
- “This is the year of the generalist.” —Boris [91:25]
- “Accelerando… It starts with takeoff starting to happen and AI singularity, and then it ends up with this kind of group lobster consciousnesses orbiting Jupiter. It really matches the feeling right now.” —Boris [94:28]
Timestamps for Key Segments
| Segment | Timestamp | |-----------------------------------------------|-------------| | Early coding and startups | 01:08–06:48 | | Facebook/Meta years and code quality | 10:17–18:46 | | Anthropic join, “no handwritten code” | 18:46–22:10 | | Claude Code origin & release philosophy | 22:10–29:52 | | AI-native coding workflows, multi-agent work | 30:09–39:26 | | AI & human code review | 39:26–45:24 | | Product process: No PRDs, maximal prototyping | 54:07–63:12 | | Cowork, swarms/teams, and nonengineer users | 64:17–77:21 | | Printing press analogy, future skills | 85:02–93:51 | | Book recommendations | 94:28 |
Tone & Style
Conversational, technical yet approachable, and infused with both curiosity and humility. Boris continually stresses iterative learning, adaptability, and pragmatism—mirroring the real-world messiness (and excitement) of building with AI today.
For Listeners
This episode is a must-listen for engineers, tech leads, and anyone curious about the front lines of AI-driven software development, organizational change, and what it means to be an engineer as the coding “printing press” goes mainstream.
Full transcript at: pragmaticengineer.com