Building Claude Code with Boris Cherny

Summary

• Claude Code now writes ~80% of the code at Anthropic, and adoption inside the company is effectively 100% of technical staff — plus roughly half the sales team and the entire finance team. Cherny ships 20–30 PRs a day with “100% of every single one” written by Opus 4.5 and Claude Code; over a month of that pace it introduced “maybe two bugs. Whereas if I’d written that by hand, that would have been like 20.”
• Opus 4.5 was the capability threshold, not a gradual slope: “the switch was instant” — Cherny uninstalled his IDE. During a month-long stretch, he didn’t hand-edit a line. The corollary for anyone underwriting AI-coding moats: model improvements can reset the playbook. “The ideas that worked with the old model might not work with the new model” — and it’s now rational to retry failed ideas every few months.
• Verification is the emerging bottleneck and the durable human role: every PR at Anthropic is reviewed by Claude in CI, which “catches maybe like 80% of bugs,” but a human still approves everything shipped to production because “our main customer base is enterprises.” Determinism is engineered back in via linters, type checkers, and best-of-N with parallel deduping agents.
• Product architecture thesis — don’t put the model in a box: Claude Code’s design bet is to avoid boxing the model. RAG (a local vector DB) was thrown away because “Agent-X search just outperformed everything” — “a fancy word for glob and grep.” The bet that keeps paying is “let the model do its thing.”
• Cowork is growing faster out of the gate than Claude Code did — built in ~10 days on the same agent SDK, targeting the non-engineers already using Claude Code (tomato-plant monitoring, wedding-photo recovery). Claude Code itself “wasn’t an overnight hit”; its inflection came in May with Opus 4 / Sonnet 4. New agent teams (swarms) are opt-in partly because they “use a ton of tokens” — a reason to make them opt-in.
• The macro frame is the printing press: printed-material cost fell ~100x in 30–50 years, volume rose ~10,000x, and scribes “ceased to become scribes, but now there’s a category of writers and authors… the market for literature just expanded a ton.” Cherny’s call for who wins: multi-disciplinary generalists — “this will be the year of the generalist” — and “the year of ADHD,” since the work is now managing parallel Claudes, not deep single-threaded coding.

Deep dive

1. Coding as a means, never an identity — from blink tags to assembly

• Cherny’s origin is relentlessly practical: at ~13 he learned HTML because eBay listings allowed it and the blink tag let him sell Pokémon cards “for like 99 cents instead of 49 cents.” Then TI-83 programs to ace math tests — first hardcoded answers, then solvers, then dropping from BASIC to assembly in eighth or ninth grade to make them run faster, and a serial cable so the whole class got A’s.
• The through-line he states explicitly: “I never thought that coding would be a career at all… Coding is a means to build things and to make useful things.” He studied economics and dropped out to do startups; his first paycheck from freelance web work at 16 went entirely on an electric guitar.

2. Ride the motorcycle to the user — the Agile Diagnosis lesson

• At YC-era medical startup Agile Diagnosis (~2011–12), DAUs were flat, so Cherny rode his motorcycle to UCSF and shadowed doctors — discovering they had 5 minutes between patients, and booting a legacy IE6 machine plus login consumed all of it. An Android rewrite still failed: doctors trailed by residents “don’t want to be seen on their phones.” The social context, not the software, was the blocker.
• His generalized takeaway: “You can’t have one big idea because the idea is probably going to be wrong. So you form hypotheses… and you see what’s right.” Finding product-market fit “is always surprising” — a habit that resurfaces throughout the Claude Code story.

3. Meta: code quality is worth double-digit productivity — and helped drive RTO

• Seven years and four promotions: Facebook Groups tech lead, then Instagram from rural Nara, Japan (his wife’s job; ~12-hour offset). The stack contrast was stark: Facebook was “the single best web serving stack in the world” — Hack, HHVM, GraphQL, Relay, React — while Instagram was “Python where the type checker didn’t work,” so he went to Dev Infra to fix it.
• He ended up leading code quality for all of Meta under “Better Engineering,” Zuck’s mandate that every engineer spend 20% of time on tech debt — tens of thousands of migrations a year at Facebook scale. Causal-inference work found code quality contributes something like double-digit percent to engineering productivity, and correlations from the same analysis “partially drove” Meta’s return-to-office decision.
• Why it matters now, in his words: a partially migrated codebase hurts engineers, new hires, and models alike — “as a model, you might just pick the wrong thing… always make sure that when you start a migration, you finish the migration.”

4. First PR at Anthropic: rejected for being handwritten

• Cherny chose Anthropic for the safety mission (“I’m a big sci-fi reader… I just know how bad this thing can go”). His first pull request, written by hand “because I thought that’s how you write code,” was rejected by ramp-up buddy Adam, who pointed him at Claude Code’s janky Python predecessor — 40-second startup, non-agentic, but “if you prompt it very carefully and hold the tool just right, it can write code for you.”
• After half a day of flag-wrangling, “it just one-shotted” a working PR — his first “feel the AI” moment, around August–September 2024: “I was used to tab completions… I had no idea that it could just make a working pull request for me.”

5. “The model just wants to use tools” — the genesis and the bitter-lesson corollary

• Claude Code started as a bash chatbot Cherny built solo to learn the public Anthropic API — “because that’s what I thought AI was.” When tool use shipped, he gave it a single bash tool and asked what music he was listening to; it wrote an AppleScript to query his player and one-shotted it with likely Sonnet 3.5. “This is actually my second felt-AGI moment… the model just wants to use tools.”
• The design philosophy that fell out of this is the episode’s most quotable engineering claim: everyone else was treating the model as a stubbed-out module inside a larger program. Wrong frame. “The model is its own thing. You give it tools… but you don’t make it a component of this larger system.” He calls it a corollary of the bitter lesson: “let the model do its thing. Don’t try to put it in a box.”

6. Released to study safety in the wild — and the chart went vertical

• The internal debate over whether to release at all resolved on safety grounds: alignment and mechanistic interpretability study the model layer, evals put it “in a petri dish,” but shipping lets you see how it behaves in the wild — “in hindsight, it was totally the right decision.”
• At the launch review with Mike Krieger and Dario, the internal adoption chart “was just vertical,” prompting Dario to ask, “Are you forcing people to use it?” Cherny: “No. We offer this tool. People vote with their feet.” Today it’s ~100% of technical employees daily, non-technical usage “getting quite close to 100%,” half of sales — and ~80% of all code written at Anthropic.
• Cherny’s framing of product’s role at a research lab: “Product is this kind of thing tacked onto the side. Product exists so that we can serve research better and so that we can make the model safer.”

7. Opus 4.5 flipped the switch: IDE uninstalled, 20 PRs a day, zero hand-edits

• “The switch was instant when we started using Opus 4.5… I just didn’t have to open my IDE anymore. I just uninstalled my IDE” — and only realized a month later he’d stopped using it. On a December “coding vacation” nomading through Europe, he shipped 10–20 PRs every day, none hand-edited, with roughly two bugs all month versus an estimated 20 had he written it himself.
• The host’s confession — the model writes code as good as he would in familiar stacks and better in unfamiliar ones — gets topped: “I’ll be honest, it writes better code than I do.” And unlike his Instagram days (top-two-or-three by code volume, much of it migrations), today’s 20–30 PRs are all substantively different work — “Claude just does those [migrations] and I don’t need to be part of that.”

8. The workflow: five parallel Claudes in plan mode, a third of code from a phone

• The stated setup — with the caveat that Claude Code is deliberately hackable because “there’s no two engineers that have the same workflow”: five terminal tabs, five parallel repo checkouts, usually round-robining Claude sessions; overflow goes to the desktop app with native Git worktree support.
• The key discipline: iterate on the plan, not the code. “With 4.6… once there’s a good plan, it just one-shots the implementation almost every time.” So the loop is prompt tab one, move to tab two while it chugs, return on notification.
• The surprise hit is mobile: he starts agents from the iOS app every morning, environments configured via session-start hooks. “If you told me 6 months ago I’d be writing maybe a third, half of my code on a phone, that’s crazy. But that’s what I’m doing today.”

9. Code review: Claude catches ~80% of bugs, a human still signs off

• His pre-AI method was proto-automation — every review comment logged in a spreadsheet, and any issue with 3–4 tallies became a lint rule. Now the loop is: “when a coworker puts up a pull request and I’m like, this is lintable, I’ll just @-Claude, please write a lint rule for this” — via the GitHub app, used “every single day.”
• The pipeline today: Claude runs tests locally, and — unprompted, an Opus 4.5 emergent behavior — launches itself in a subprocess to verify itself end-to-end (“hey, do I still work?”). Then Claude via the agent SDK in CI reviews every pull request at Anthropic, catching “maybe 80% of bugs”; a human engineer always does the second pass before production.
• On the host’s pushback about LLM non-determinism as reviewer: deterministic layers (type checkers, linters, builds) stay, and Claude is made more deterministic via best-of-N — the open-sourced code-review skill “launches parallel agents to do stuff, then parallel deduping agents to check for false positives.” Implementing best-of-N is literally “Claude, start three agents to do this.” Where would he skip human review? Personal side projects: “you can just YOLO straight to main” — early internal Claude Code committed straight to main — but enterprise customers mean humans stay in the loop “at least for now.”

10. Simple architecture, Swiss-cheese safety — prompt injection in three layers

• The architecture is deliberately minimal: “there’s a core query loop, a few tools… we delete these tools all the time.” The real complexity is safety, which is never one mechanism: “it’s always a Swiss cheese model… you count the number of nines in that probability and pick the threshold.”
• For prompt injection via web fetch, three layers: alignment training (“Opus 4.6 is the most aligned model we’ve ever released because we’ve taught the model how to be more resistant to prompt injection”), runtime classifiers that block and retry injected-looking requests, and sub-agent summarization of fetched content before it reaches the main agent.
• Permissions are similarly layered — classifiers, static analysis, user allowlists — and conservative by default because Unix arcana bites: even find and set have flags that execute arbitrary code. The permission-prompt design itself dates to the very first September 2024 internal release, brainstormed with co-founder Ben Mann after safety teams pushed back that letting the model run bash was “not a solvable problem”: “if you’re not sure, just ask the human.”

11. RAG got deleted: “Agent-X search is a fancy word for glob and grep”

• Early Claude Code ran a local TypeScript vector DB with cloud embeddings — “pretty good,” but the index drifted from freshly written code and raised nasty permission questions (“how do we make sure that a rogue IT person can’t access someone else’s data”). After trying recursive model indexing and plain glob/grep, “Agent-X search just outperformed everything” — which “is just a fancy word for glob and grep,” an idea partly borrowed from Meta engineers searching foo( in the global index because click-to-definition was broken.
• The meta-lesson on iteration cost: “statistically almost all the code we write we throw away.” Even the spinner went through ~100 iterations with ~80 discarded — “it’s just so easy to write this code and try stuff and see what feels good.”

12. No titles, no PRDs — show, don’t write

• Everyone at Anthropic is “member of technical staff,” which Cherny reads as structural optimism: with “software engineer” under a Slack name, “I’m not going to ask you product questions. But when everyone’s title is member of technical staff, by default you assume everyone does everything.” He thinks it’s “a glimpse of the future… where every discipline is going.”
• PRDs barely exist — “better just send a PR.” The economics flipped: “the cost of building was high, so you had to aim very carefully before you take your shot… Now the cost of building is very low, but also we don’t know where we’re aiming.” Agent teams alone went through “probably hundreds of versions” of prototypes over months; “there’s just no way we could have shipped this if we started with static mocks in Figma.”
• The humility underneath, verbatim: “personally I’m wrong like half the time… most of my ideas are bad. At least half of them are bad. And I don’t know which half until I try it.” The condensed file-read view took ~30 prototypes, a month of internal dogfooding, a dozen bugs, and a dozen tweaks, then public iteration directly with dissenting users on GitHub issues.
• Adoption spread by contagion: one data scientist ran SQL through Claude Code with ASCII charts in the terminal; “the next week the entire row of data scientists had it running.” Today on the team, “the engineers code, our engineering manager codes, designers code, data scientists code, our finance guy codes.”

13. Plugins were built by a weekend swarm

• The starkest demo of where this goes: engineer Daisy took an early Swarms build, a container, and Claude in dangerous mode, and told it: “Your job is to build plugins. Come up with a spec, make an Asana board, split up into tasks.” Over the weekend it spawned a couple hundred agents, created 100 Asana tasks, and implemented them — “that’s pretty much the version of plugins that we shipped.”
• Cherny’s aside on tooling: coordination systems like Asana “used to be for humans, but I think nowadays it’s just as much for models.” He himself uses no ticketing system.

14. Cowork: built in 10 days, and a steeper growth curve than Claude Code

• The signal for building it was latent demand — non-engineers “jumping through hoops to use a product that was not designed for them”: the guy using Claude Code with a webcam to monitor tomato plants (“oh my god, I’m so happy that our plant is budding”), someone recovering wedding photos off a corrupted hard drive, Anthropic’s own finance and sales teams. A few people built it in ~10 days, “fully built with Claude Code,” on Electron/TypeScript — Felix, Cowork’s creator, was an early Electron engineer.
• Where the complexity actually lives: not the UI (it’s a tab in the Claude desktop app, same agent SDK underneath) but safety for non-technical users — a shipped virtual machine, OS-level integrations so nobody accidentally deletes family photos, backend classifiers, and a rethought permission model that pairs with a Chrome extension since non-engineers’ tools live in browsers, not CLIs. Cherny’s own use: Cowork opens his team-status spreadsheet and Slack side by side and pings engineers for updates — “it just one-shots it.”
• The commercial datapoint worth flagging: “Claude Code first came out, it actually wasn’t an overnight hit… the first big inflection was in May when we released Opus 4 and Sonnet 4.” Cowork, by contrast, “is a much steeper growth trajectory than Claude Code was at the beginning. It’s just been an instant hit — I didn’t really expect that.” macOS first, Windows “probably by the time this podcast comes out” — the philosophy being “we always launch a little bit before it’s ready.” Enterprise privacy cuts both ways: “if someone reports a bug, I actually can’t pull up your logs.”

15. Agent teams: uncorrelated context windows as test-time compute

• The concept behind the just-launched agent teams (swarms): uncorrelated context windows — sub-agents start fresh, knowing only their prompt, unlike a second task in the same window. “Throwing more tokens at it, when the windows are uncorrelated, gives you better results. It’s actually a form of test-time compute.”
• Experiments ran since ~September–October, but “with Opus 4.6, it clicked” — internal evals on tasks “more complex than what a single Claude would build” improved sharply, which triggered the release. It’s opt-in research preview deliberately: “it uses a ton of tokens. Not everyone wants this all the time.” No regimented configuration — “a lot of the magic comes out of uncorrelated context windows… I don’t think there’s a one-size-fits-all.”

16. The Karpathy problem: beginner’s mind as a core skill

• On Karpathy’s post about never feeling so far behind as a programmer: “This is something I really struggle with. The model is improving so quickly that the ideas that worked with the old model might not work with the new model… there’s just not a lot of other technologies like this. I just don’t really have a lot of experience to draw on.” His answer is “intellectual humility” and a permanent beginner mindset.
• The practical inversion: gatekeeping (“we tried it and it didn’t work”) used to be valid; now “it’s actually not crazy to just try the same idea every few months because the model improves and it just works.” Case in point: devrel engineer Tariq has Claude Code generating its own launch videos — “not something I would have tried cuz I wouldn’t have thought the model was ready. He just did it and it just kind of worked.”

17. Grief, scribes, and the printing press

• The host names the loss directly — identity, hiring loops, and pay were all built on coding being hard, “and it feels that something really quickly got taken away.” Cherny doesn’t dodge it: he wrote the first O’Reilly TypeScript book, found it translated into Japanese in a tiny-town bookstore (“the coolest moment — and then I realized I don’t remember TypeScript at all”), founded the world’s biggest TypeScript meetup, and still “always thinks in the types first.” “There is this beauty to it. There’s an art to it, for sure. But in the end… it’s a means to an end. It’s not an end to itself.”
• His metaphor for the moment: the printing press in the 1400s. Scribes were <1% of the population, employed by often-illiterate kings; then printed-material cost fell “something like 100x over the next 30-50 years,” quantity rose “like 10,000x over the next 50-100 years,” while literacy hitting ~70% took another 200–300 years because reading is hard to learn. “If people had to predict what would happen when the printing press came out, no one would have predicted that the microphone would become a thing.”
• The hopeful half, verbatim: scribes “ceased to become scribes, but now there’s a category of writers and authors. These people now exist. And the reason they exist is because the market for literature just expanded a ton.” The host extends it: illiterate kings employing scribes maps neatly onto business owners employing engineers to express what they can’t build themselves.

18. Year of the generalist — and a changed mind on safety

• Belief revised in the past year: “one thing I wasn’t sure about is how big a problem is safety, to be totally honest… seeing it from the inside and the new risks that have arisen in the last year, it just makes me much much more worried about it. Now it’s the most important thing.”
• Skills best left behind: “very strong opinions about code style and languages… the model can just use whatever language and if you don’t like it, it can just rewrite it for you.” Still valuable: being methodical and hypothesis-driven — though “I don’t know if you’re still going to need to have it in 6 months” — and curiosity “beyond your swim lane.” His prediction: the next trillion-dollar startup “might just be one person” thinking across engineering, product, business, and design. “This will be the year of the generalist.”
• His most provocative claim, hedged as half-dangerous for society: “it’s like the year of ADHD. The work for me has become jumping between Claudes… it’s not so much about deep work. It’s about how good am I at context switching.” The host’s addition, which Cherny accepts: the real meta-skill is adaptability, because “whatever the next model comes out, it will change again.” Book picks: Cixin Liu’s short stories, Stross’s Accelerando (“essentially the product roadmap for the next 50 years”), and Functional Programming in Scala — do the exercises; he’s done all of them “probably three times over.”