Overview
Boris Cherny — creator and Head of Claude Code at Anthropic, former Principal Engineer at Meta, and author of Programming TypeScript (O'Reilly) — sits down with Gergely Orosz to trace the full arc of Claude Code: from weekend side-project to one of the fastest-growing developer tools in history. The conversation covers Boris's daily workflow of shipping 20–30 PRs a day with zero hand-written code, the architecture behind Claude Code (spoiler: no RAG — just glob and grep), how code review works when AI writes everything, the birth of Claude Cowork and Agent Teams, and a striking printing-press analogy for the transformation software engineering is undergoing right now.
1 Boris's Origin Story
Boris's path into programming was entirely practical. At around 13, he discovered HTML while selling Pokémon cards on eBay — finding that a <blink> tag could bump his prices from 49¢ to 99¢. Around the same time, he programmed math solvers on a TI-83 calculator, eventually dropping from BASIC to assembly to make them faster. When every student in his class got an A after he shared the solver via serial cable, the teacher caught on.
He studied economics in college but dropped out to do startups. His first venture was a cannabis review site that "actually kind of blew up." He pivoted into chemical testing, then joined Y Combinator's Agile Diagnosis — a medical decision-tree startup for hospitals. There he rode his motorcycle to UCSF to shadow doctors and discovered the root cause of flat DAUs: doctors typed with one finger because they wore latex gloves.
2 Lessons from Meta
Boris spent seven years at Meta (five as a Principal Engineer), working across Instagram, Facebook, WhatsApp, and Messenger. He became one of the most prolific code authors and code reviewers in the company — largely because being based in Japan meant no meetings, giving him uninterrupted coding time.
The Code Quality Machine
- Instagram's broken dev stack — Click-to-definition didn't work, the Python type checker didn't work, and the whole thing was "this hack-together Django with a fork of CPython." Engineers adapted by using Meta's global index and searching for
foo(instead of using IDE navigation. - Facebook's Flow/Hack stack — Boris describes it as "probably the best web dev stack in the world" — fully optimized, with working type checkers and IDE support. The contrast between Facebook and Instagram's developer experience was stark.
- Code quality at scale — He led code quality initiatives across multiple products, building automated systems to catch recurring patterns. His methodology: track every code review comment in a spreadsheet, and when any issue appears 3-4 times, write a lint rule to automate it away.
3 Joining Anthropic
Boris describes two "felt-like-AGI moments" that pulled him toward Anthropic. The first was using Claude 3 Opus for the first time — the model wrote code that didn't just compile but was good. It felt qualitatively different from anything before.
He was hired by Ben Mann (one of Anthropic's co-founders) and joined the Labs team. Famously, his first pull request at Anthropic was rejected — not because the code was bad, but because he wrote it by hand. The culture was already "let the model write it."
Boris also revealed a personal motivation: he's a sci-fi reader who understands how badly AI could go if mismanaged. After seeing safety challenges from the inside, what was initially "an important concern" became "the most important thing" for him.
4 The Origins of Claude Code
Claude Code started as a simple terminal chatbot — "because that's what I thought AI was," Boris says. The turning point came when tool use was introduced. Boris gave the model a single tool: bash.
His first test: "What music am I listening to?" The model wrote an AppleScript to query his music player and one-shotted it with Sonnet 3.5. This was Boris's second AGI moment.
The Bitter Lesson Corollary
Boris articulates a key philosophical insight about building AI products:
At the time, everyone else was treating the model as a module to slot into a program — stub out a function, make it AI-powered. Claude Code's approach was fundamentally different: give the model autonomy and tools, then get out of the way.
The Internal Debate
When Claude Code spread inside Anthropic, the internal adoption chart "was just vertical." Dario Aghavard asked if Boris was forcing people to use it. The answer was no — people voted with their feet. The decision to release externally was driven by safety research: to study how agents behave in the wild and learn from real-world usage patterns, making the model safer as a result.
The first three months, Boris was the sole developer. Claude Code now writes approximately 80% of all code at Anthropic.
5 Boris's Daily Workflow
Boris ships 20–30 pull requests every day. With Opus 4.5, he stopped using an IDE entirely — he uninstalled it a month later when he noticed he hadn't opened it once.
The Setup
- Five terminal tabs, each with a separate checkout of the repository (five parallel workspaces)
- Plan mode first — almost every task starts with
Shift+Tabtwice to enter plan mode. Boris iterates on the plan before letting it execute. - Desktop app overflow — when terminal tabs run out, he uses the Claude desktop app, which has built-in Git worktree support for automatic environment isolation.
- iOS app coding — roughly a third to half of his code is written from his phone. "If you told me 6 months ago I'd be coding on a phone, that's crazy."
The Quality Bar
During a coding vacation in Europe (December), Boris wrote 10–20 PRs per day. Opus 4.5 wrote 100% of every single one — he didn't edit a single line manually. Over the entire month, the model introduced maybe two bugs. By his estimate, hand-writing that code would have produced ~20 bugs.
6 Parallel Agents
Boris describes two modes of using Claude Code:
- Learn/Exploratory mode — for new codebases. Use
/configto set "explanatory" output style. Follow along with the model. Highly recommended for onboarding. - Productive mode — for familiar codebases. Start in plan mode, iterate on the plan, then let it execute. Round-robin between 5+ parallel agents.
The workflow: start Claude in plan mode in tab 1, give it a prompt. While it's thinking, switch to tab 2 and start another plan. Then tab 3, tab 4. When tab 1 finishes, come back, review the plan, iterate, then let it implement.
With Opus 4.5, once the plan is right, Claude "will one-shot the implementation almost every time." With 4.6, it's even more reliable. The most important thing is getting the plan right — the back-and-forth to refine the plan matters more than anything else.
7 Code Reviews When AI Writes Everything
The Multi-Layer Verification Stack
- Claude self-tests — when writing code, Claude often decides to run tests locally or write new tests. When modifying Claude Code itself, it launches itself in a subprocess to verify it still works. This behavior "just started spontaneously with Opus 4.5 — we didn't code it in."
- Claude-P (Agent SDK in CI) — every pull request at Anthropic is code-reviewed by Claude Code running in CI. This catches "maybe 80% of bugs." Claude automatically addresses some; others it leaves for a human.
- Human code review — always a second pass by an engineer. "There always has to be a person in the loop approving the change."
- Type checkers, linters, builds — deterministic verification alongside non-deterministic AI review.
Deterministic + Non-Deterministic
To deal with LLM non-determinism, the team uses best-of-N approaches: launching parallel agents to review, then parallel deduping agents to filter false positives. The open-source code review skill in the Claude Code repo implements this pattern.
Boris's updated lint workflow: instead of the old spreadsheet-then-lint-rule process, he now tags @Claude directly on a coworker's PR and says "please write a lint rule for this." Claude writes and submits the lint rule on the spot.
8 Architecture: No RAG, Just Glob and Grep
The Core Architecture
Claude Code is "very simple" according to Boris:
- Core agent loop — a query loop with a few tools that are constantly being added, removed, and experimented with.
- Terminal/editor interface — the UX layer.
- Security layer — "actually a ton of different pieces" around safety and human-in-the-loop.
The RAG Story
Early on, Boris tried RAG with a local TypeScript vector database using cloud embedding models. It "worked pretty good" but had critical problems:
- Code drift — local functions weren't indexed yet, so RAG wouldn't find them.
- Permission complexity — who can access the index? How do you prevent a rogue IT person from accessing someone else's embeddings?
- Enterprise security — for an enterprise product, these questions are deal-breakers.
They tried many alternatives: recursive model-based indexing, various search approaches. The winner?
This was partially inspired by Boris's Instagram experience, where engineers used Meta's global index to search for foo( instead of relying on broken IDE navigation. The same pattern works for the model.
Iteration Velocity
Even the spinner in Claude Code has gone through "like a hundred iterations." Out of those, maybe 10-20 made it to production. "Almost all the code we write we throw away because it's just so easy to write this code and try stuff."
9 Permissions and Sandboxing
The Swiss Cheese Model
Safety and permissions follow a multi-layered approach. For prompt injection, Claude Code uses three layers:
- Model alignment — Opus 4.6 is trained to resist prompt injection at the model layer.
- Runtime classifiers — if a request seems prompt-injected, it's blocked and the model retries.
- Sub-agent summarization — for tools like web fetch, results are summarized by a sub-agent before reaching the main agent, reducing injection surface.
Command Permissions
Few Unix commands are truly safe to pre-allow. Even find has flags that execute arbitrary code. Even set can be exploited. Claude Code is "fairly conservative by default" but lets users configure allow lists.
The permission prompt system (run once / run for session / allow globally) dates back to the very first internal release in September 2024. Boris and Ben Mann brainstormed it as a solution when internal safety teams pushed back: "You can't just let the model run bash commands."
10 Engineering Culture at Anthropic
One Title: Member of Technical Staff
Everyone at Anthropic shares the same title. The rationale: when your title says "software engineer," people won't ask you product questions. When everyone is "member of technical staff," the default assumption is everyone does everything. This encourages cross-functional collaboration.
Boris sees this as "a glimpse of the future" — all disciplines are moving toward this generalist model, accelerated by AI making it easier for engineers to do product work and vice versa.
Everyone Codes
On the Claude Code team, everyone codes — engineers, the engineering manager, designers, data scientists, and even the finance person. It started when a data scientist was spotted using Claude Code for SQL queries with ASCII visualizations. Within a week, the entire row of data scientists had Claude Code running.
No PRDs
Anthropic doesn't write Product Requirements Documents. Instead: "Better just send a PR." The product team is extremely technical (Kat, the product lead, was a former engineering manager), and with Claude Code making prototyping instant, written specs have been replaced by working code.
11 The Prototyping Revolution
Boris built 15–20 interactive, working prototypes for the to-do list feature in Claude Code — in a day and a half. Gergely notes this would have taken 1-2 weeks in traditional engineering, and teams would have built three, not twenty.
Agent Teams (Swarms) Were Prototyped for Months
Daisy, Suzanne, Karen, and other team members prototyped "probably hundreds of versions" of what became Agent Teams before getting a UX that felt right. "There's just no way we could have shipped this if we started with static mocks in Figma or a PRD."
The New Economics of Building
The condensed file-read view went through ~30 prototypes. After internal dogfooding for a month, more tweaks based on external feedback. Boris personally went back and forth with users on GitHub issues to iterate until the default felt right — while still allowing configuration for those who wanted expanded output.
Plugins: Built by Swarms Over a Weekend
Daisy had an early version of swarms. She told it: "Your job is to build plugins. Come up with a spec, create an Asana board, split into tasks, and build it." She set up a container, enabled dangerous mode, and let it run for the entire weekend. It spawned a couple hundred agents, created 100 tasks, and implemented what became the shipped version of plugins.
12 Claude Cowork
Built for Non-Engineers
Claude Cowork was born from observing latent demand: non-engineers were already using Claude Code for things like monitoring tomato plants (webcam + daily check-ins), recovering wedding photos from corrupted hard drives, running SQL queries, and financial forecasting. When you see people "jumping through hoops to use a product not designed for them, that's a really good sign it's time to build one for them."
Built in ~10 Days
A small team, fully building with Claude Code. From the product side, it's a tab in the Claude desktop app (alongside Code and Chat). Underneath, it runs the same Claude Agent SDK that powers Claude Code.
Where the Complexity Lives
- Safety guardrails — classifiers on the back end, VM sandboxing, OS-level protections against accidental file deletion. "If someone launches the app and deletes a bunch of family photos, that's really not good."
- Permission system adaptation — inherited from Claude Code but redesigned for non-technical users.
- Chrome extension integration — Cowork is "really, really good when you pair it with a Chrome extension." Boris uses it weekly for project management: Cowork opens a spreadsheet in one Chrome tab, Slack in another, finds unfilled status rows, and messages the relevant engineers on Slack.
Growth trajectory: "much steeper than Claude Code was at the beginning" — an instant hit, unlike Claude Code which had a slow initial take-off before the May inflection with Opus 4 / Sonnet 4.
13 Agent Teams and Uncorrelated Context Windows
The Key Concept: Uncorrelated Context Windows
Boris introduces a core concept driving Agent Teams:
- Correlated — second task in the same context window as the first; it knows about all prior context.
- Uncorrelated — sub-agent gets a fresh context window with only the specific prompt from the parent. It doesn't see the parent's full context.
Throwing more tokens at a problem using uncorrelated windows gives better results than doing so in a single correlated window. Boris calls this "a form of test-time compute."
Opus 4.6 as the Unlock
The team experimented with swarms since ~October, but "it really just clicked with Opus 4.6." The model figured out how to effectively delegate and coordinate. Internal evaluations showed significant improvements on complex tasks that exceeded what a single agent could build.
Agent Teams is released as a research preview because it uses a lot of tokens. The main agent decides delegation rules contextually — "there's no regimented way."
14 The Printing Press Analogy
Boris develops an extended analogy between AI and the printing press that serves as the episode's philosophical anchor:
- Before: Less than 1% of Europe's population was literate. A small class of scribes — trained for years, employed by kings who were often themselves illiterate — had a monopoly on writing.
- After: The cost of printed material dropped ~100x in 30-50 years. Volume increased ~10,000x in 50-100 years. Global literacy eventually reached 70%, though that took 200-300 years and required industrialization.
- The parallel: Software engineers are today's scribes. Business owners are today's "kings" — they know what they want built but can't write code. AI is the printing press, making the craft accessible to everyone.
Gergely's sharpening of the metaphor: there are CEOs who come with whiteboard drawings saying "this should be easy" — they're the illiterate kings who need scribes. AI removes that middleman.
Intellectual Humility as a Survival Skill
Boris is candid about the emotional challenge: models improve so fast that ideas that failed last month may work now, and vice versa. "I constantly have to remind myself" to re-evaluate assumptions. Junior engineers sometimes find better approaches than he does because they don't carry outdated priors.
15 Skills That Still Matter for Engineers
What's Less Valuable
- Strong opinions about code style, languages, and frameworks — "I can't wait to get past these endless debates. The model can use whatever language and rewrite it if you don't like it."
What's More Valuable
- Being methodical and hypothesis-driven — matters for product design (what to build next) and day-to-day engineering (debugging). The model helps, but humans still need this skill.
- Curiosity and cross-disciplinary breadth — the next billion-dollar product "might just be one person whose brain can think across engineering, product, business, design, and finance."
- Adaptability — Gergely's addition. Boris was great at deep focus before; now he's great at context-switching across parallel agents. Being open to completely changing your working style with each new model release.
- Short attention span / context switching — Boris calls this "the year of ADHD." The work has become jumping between Claude instances, managing agents. "It's not about deep work. It's about how good am I at context switching."
Standout Engineer Archetypes
- Amazing prototypers — take something from 0 to 0.5, find the technology unlock.
- Product-market-fit finders — 0.5 to 1, or 0 to 1.
- Multi-disciplinary hybrids — product + engineering, design + engineering, infrastructure + product. Boris sees more of these emerging.
16 Book Recommendations
- Accelerando by Charles Stross — "Essentially the product roadmap for the next 50 years." Covers AI takeoff and singularity, ending with "group lobster consciousnesses orbiting Jupiter." Boris says it captures the quickening pace of the current moment better than anything else.
- Cixin Liu's short stories — the Three-Body Problem author has excellent short story collections beyond the main trilogy.
- Functional Programming in Scala — Boris's technical recommendation. "Even if language choice doesn't matter as much anymore, there's an art to functional programming that teaches you how to code better." He's done all the exercises three times. "It just knocks this idea of functional types into your head."
🎯 Key Takeaways
🔑 Key Takeaways
- Don't box the model — give it tools and autonomy. Claude Code's architecture philosophy: let the model be its own thing, not a component in a larger system. This is a corollary of the Bitter Lesson.
- Glob and grep beat RAG — Claude Code abandoned vector databases in favor of "agentic search" (glob + grep). Simpler, more reliable, no permissions headaches, no stale index problems.
- Plan mode is the highest-leverage workflow — once the plan is right, Opus 4.5+ one-shots the implementation. The back-and-forth to refine the plan is where the value lives.
- AI code review catches 80% of bugs — Claude-P runs on every PR at Anthropic, but a human always does the second pass. Best-of-N with parallel reviewing agents further increases reliability.
- The model spontaneously self-tests — with Opus 4.5, Claude Code started launching itself in subprocesses to verify it still works. No one coded this behavior.
- Prototyping has replaced planning documents — 15-20 working prototypes in 1.5 days instead of a 2-week PRD cycle. "Better just send a PR."
- Uncorrelated context windows are a form of test-time compute — Agent Teams work because fresh sub-agent contexts outperform extending a single correlated window.
- Safety requires Swiss cheese layers — model alignment, runtime classifiers, sub-agent summarization, permission prompts, sandboxing. No single mechanism is sufficient.
- We're living through a printing press moment — scribes became writers when the market for literature expanded. Software engineers won't disappear; the market for software will explode.
- The year of the generalist — cross-disciplinary thinking is the new superpower. The next big product may come from one person who thinks across engineering, product, design, and business.
- Intellectual humility is non-negotiable — ideas that failed last month may work now. Junior engineers sometimes find better approaches because they carry fewer outdated priors.
- Context switching replaces deep focus — Boris calls it "the year of ADHD." Managing 5+ parallel agents is the new coding workflow.
🔗 Resources & Links
- How Claude Code is Built — Pragmatic Engineer deep dive
- How Anthropic Built Artifacts — Pragmatic Engineer deep dive
- How Codex is Built — Pragmatic Engineer deep dive
- Real-World Engineering Challenges: Building Cursor — Pragmatic Engineer deep dive
- Boris Cherny's website
- The Pragmatic Engineer Podcast — transcript and references