The Making of Claude Code

Written by: Claude Sonnet AI.

Curator/Editor: Học Trò.

---

Another way to read: https://www.anthropic.com/features/making-of-claude-code

*Four suggestions per prompt, a VS Code extension, and about a hundred outside users — that was the whole of it in the spring of 2022. What follows is the story of how that small thing became, in the words of the person who eventually ran the project, something that by the winter of 2025 was writing every line of his code.*

 Origins

Anthropic's founders had already decided, against real internal argument, that the company would ship a product at all. A safety-focused AI lab building and selling something was not an obvious move in 2021, and some of the people in the room worried about it openly. The thing they actually built once they'd made that call was almost quaint by today's standards: a chat-based coding assistant, packaged as a VS Code extension, that answered a prompt with four different suggested edits and let the developer pick one. Ben Mann, one of Anthropic's co-founders, still describes it in exactly those plain terms — a chat window, four options, take your pick.

Underneath that modest interface, a much more ambitious research bet was already running. Shauna Kravec, who now leads reinforcement learning at Anthropic, had been thinking since the very start of 2022 about something considerably harder than autocomplete: models that could do software engineering *autonomously*, without a person steering every step. She and her collaborators built the company's original reinforcement-learning codebase and worked out how to train agents at all — because, as she puts it, they suspected that the road to transformative AI ran directly through automating large chunks of software engineering work. Dawn Drain, who joined Anthropic in 2021, spent her first three years there chasing a narrower version of the same goal: a model that coded at least as well as she did.

The training itself started almost embarrassingly small. Could the model write one simple function? Then: could it write the function *and* check whether its own output was correct? The early models, by every account, were bad at this — bad enough that progress had to be measured in inches. The harder problem, it turned out, wasn't the model at all; it was the scaffolding around it. Getting a model to actually *act* — to run code, read the result, and keep going — meant solving problems that had nothing to do with language modeling: which sandboxed environment the code should run in, how to keep that environment secure, how to stream input and output without the whole thing hanging on a timeout. Drain and a teammate on the RL side spent real effort in 2022 just getting a persistent shell to behave predictably inside a container. It is, by Kravec's own account, almost exactly the harness-design problem that agent builders were still wrestling with in 2026 — the difficulty didn't go away, it just moved to a higher rung.

That first public-facing assistant found a modest but real audience — something like a hundred outside users by the spring of 2022 — before it was set aside. Ben Mann went on paternity leave, came back to help ship the first version of Anthropic's API, and the coding assistant itself drifted out of focus for a while. It never really stopped mattering, though. On the research side, away from any shipped product, the harder work of teaching models to code agentically simply continued underneath everything else Anthropic was building.

The Spark

By the end of 2022, the research effort had turned toward something looser and more open-ended than a fill-in-the-function exercise: agents that could act with less hand-holding. Through 2023, the pieces started arriving one at a time — rudimentary function calling, some search capability, small useful fragments. The one that mattered most, according to Kravec, was giving the model a bash tool and the ability to search its own surroundings. Those two capabilities, more than any other single addition, are what make agentic coding work at all.

Dawn Drain spent what she now calls an embarrassingly long stretch of time on a problem that sounds almost trivial: teaching Claude to write diffs, because a diff seemed like the most natural way to represent a text edit. That effort, and others like it, eventually crystallized into an internal tool called *clide* — a name a colleague, Eli Tran-Johnson, had actually coined earlier for a predecessor project. Clide was a command-line tool for chatting with Claude about code edits and everyday development tasks. By every internal account it was clunky, slow to start, and full of odd incantations you had to already know to get any use out of it — and, at the very same time, everyone who touched it agreed it was strange and a little bit magical, because it was unmistakably a glimpse of something that didn't exist anywhere else yet. Ben Mann hacked on it in his spare time simply because he loved it. Dawn Drain built a feature that fanned a hundred Claude Haikus out in parallel so a single question about an entire folder — one that could never fit inside a normal context window — could still get answered, and she remembers colleagues constantly asking how she'd found tools this good.

Adam Wolff, who would later become Claude Code's first manager, added one of clide's last features before moving over to the newly formed Labs team: a way for the tool to infer what a developer was trying to do from a partial, half-finished change, with no bash access at all — agentic in only the most limited sense, but agentic all the same. The first time it actually worked, he was, in his own description, dancing around his kitchen, unable to quite believe it.

Ben Mann started that Labs team in January 2024 because he'd spotted a gap in the market that nobody was filling: real agentic coding, not another autocomplete plugin. When Boris Cherny joined Labs that September, his instinct was to start small — he proposed building a linter. Mann pushed back hard, telling him no, this was the moment to go after the big thing instead. Cherny had already had his own conversion experience with clide by then. Ugly as it was, full of arcane commands, it had felt like a message from the future. He had once written out a full pull request by hand, only to have it rejected by Adam Wolff with a suggestion that he just use clide instead — and when he pasted the underlying issue into the tool and it wrote back a clean five- or ten-line fix on its own, the shock of it stayed with him. He and Ben Mann had, in effect, already watched all the individual pieces work. What was missing was someone willing to put them together into one thing.

Cherny's actual starting assignment was as loose as "automate coding," which meant his very first task was learning to use Anthropic's own API — he hadn't touched it before. Out of that exploration came a rough demo he called Claude CLI: a program that, among other things, could figure out what music he was listening to simply by taking a screenshot of Apple Music and reading it. It took him about two days to build, a task that Claude Code itself would later finish in something like two minutes. He posted it to an internal Slack channel and got two or three likes. Igor Kofman, another member of the Labs team, remembers being certain immediately that this was the right direction, even if almost no one else quite understood what they were looking at yet — including, by Cherny's own admission, Cherny himself. The day after he posted it, he walked in and found a colleague, Robert Boyce, already using it to write his own code, the now-familiar red-and-green diff lines flickering on his screen. It was, in Cherny's words, the craziest thing — obviously, undeniably useful.

From that point he could not leave it alone. He started working every weekend; friends kept asking why he'd disappeared. Igor Kofman went through a parallel realization of his own. He had originally come to Anthropic hoping to put AI's power in the hands of people who weren't engineers at all, on the theory that coding itself was already a solved problem someone else would handle. About three months in, he reversed that judgment completely — coding, he decided, wasn't a side problem to skip past. It sat on the critical path to everything else Anthropic wanted to build.

The Team

The people who assembled around Cherny's demo came from almost nowhere near a shared background, which turned out to matter. Adam Wolff had studied film, not computer science; he traces his own turn toward technology to reading the first issue of *Wired* magazine in 1993 and deciding, on the spot, that he had to move to the Bay Area and be part of whatever this was. He worked first as a game designer, then became a programmer, and eventually helped build React, the web framework that would go on to shape how a generation of engineers thought about user interfaces — an experience, as it happens, that gave him an unusually direct feel for what happens when a small technical idea starts being used by people who never cared about the idea in the first place. Cherny had to ask him more than once to become Claude Code's first manager; Wolff wanted to stay an individual contributor and only relented after a certain amount of nagging and, by his own account, a few beers.

Igor Kofman's path to the team started decades earlier and thousands of miles away. He learned to program in BASIC around age seven, in Ukraine, on a computer likely imported from the West and loaded from cassette tape — probably, he thinks, a Commodore 64. His first real program was a game to teach his five-year-old brother arithmetic: get "two plus two" right, and it rewarded you with music. Fiona Fung, who leads the Claude Code and Cowork organization today, has her own origin story in a teaching language called Turing, built at the University of Toronto, where she made her first game — an experience she still describes less as engineering than as art, a way of telling a story.

Cat Wu joined Anthropic in the summer of 2024 and, like Adam Wolff before her, effectively recruited herself. She started using Cherny's rough Claude CLI demo to build reinforcement-learning environments and was startled by how much faster it let her work; she began sending him long, detailed paragraphs of feedback, and just as quickly he'd come back having already shipped a fix or a feature for half of what she'd asked for. She became, by her own estimate, one of the tool's most active users anywhere inside the company — active enough that Cherny eventually just asked her to join. Meaghan Choi arrived from a different direction entirely: her first contact with the project was around December 2024, and her first reaction to seeing Claude CLI in its native, undesigned state was that it could clearly become something real with a small amount of design attention — a genuinely unusual proposition, since designing for a command-line interface is not a common assignment in the industry. She asked to run a two-week design spike to find out. Sid Bidasaria, who joined the Labs team in August 2024, had never built a developer tool of any kind before in a career built on not staying in one lane — Cherny's CLI project was simply the interesting thing happening at the moment he arrived, so he jumped on it.

Building

By October 2024, Cherny was pushing the project as hard as one person reasonably could, repeatedly telling his manager, Raphael Lee, that he needed more engineers. Eventually almost the entirety of Anthropic's Labs team was absorbed into what would become Claude Code, with the rest of Labs splitting off into a separate MCP team; growth mostly came from internal transfers and a small number of carefully chosen outside hires rather than a wave of fast recruiting. Adam Wolff and Cherny pulled in genuinely different directions on how quickly to scale the team — Cherny pushing for more hands, Wolff holding the brakes as much as he could — because Wolff had learned the hard way, watching React grow at Facebook, that scale makes everything about process and culture and shared vision harder, even while it obviously adds firepower. He also saw the small team itself as an early, live experiment in exactly the kind of productivity shift Claude Code would later cause everywhere else: even with only a handful of engineers, the group was shipping features and fixing bugs at a pace he'd never witnessed before.

In hindsight, Cherny has come to see that constraint as one of the most important reasons the project worked at all. A small team couldn't afford to overengineer anything, had to be resourceful by necessity, and — critically — had no choice but to lean on Claude itself to move fast enough to keep up. Through most of 2024 it really was just Cherny, Sid Bidasaria, and Ben Mann in occasional spare moments, until a green light arrived in December and six or seven more people jumped in from Labs and elsewhere for a final, concentrated two-week sprint. A surprising amount of what users would eventually recognize as core Claude Code — the bug-reporting flow, the login flow — was built inside those two weeks. That sprint, Bidasaria remembers, was the moment the project stopped feeling like an experiment and started feeling like a real product.

Once it existed in something like finished form, the team ran it with almost none of the process weight a product this consequential might normally carry: no PR restrictions, no formal review gate, fixes shipped the moment they were ready. Cherny had built solid auto-update infrastructure and genuinely good usage metrics early on, so a user complaint could turn into a shipped fix within minutes rather than a future release cycle. Feedback poured in once real people were using it, and Cherny and Bidasaria answered comments as they arrived, often turning around a same-day or even same-hour pull request, because a command-line tool with no server-side web architecture to navigate could genuinely move that fast — it was, in Bidasaria's phrase, just a client application, and a simple one at that.

Ben Mann has a theory about why this pace of iteration wasn't just possible but necessary. Building on top of a model that is itself improving on a predictable cadence means you have to ship something that only half-works today, so that it's ready to catch the *next* model's improvement and suddenly work most of the time — and then the model after that pushes it further still. It takes an unusual tolerance for being visibly, repeatedly wrong in public, because that's the actual cost of staying positioned for the model that hasn't shipped yet. You have to build for right now while never quite taking your eyes off what's coming.

Launch

The early-access period before the public launch was not a triumphant one. Cat Wu describes the reception as lukewarm at best — people found the underlying idea compelling, but the tool itself was still riddled with bugs. Anthropic launched it externally anyway, in February 2025, under a new name: Claude Code, replacing the internal "Claude CLI" label at the suggestion of Alex Isken in Product Marketing, chosen for nothing more complicated than how clean and simple it sounded. Small, memorable details arrived right at the end. Late one night before launch, Igor Kofman had the idea of giving the tool an ASCII-art logo and worked with Claude itself to build out the lettering that became its now-recognizable all-caps wordmark — a tiny, deliberate moment of delight built into the login screen. Meaghan Choi's own favorite addition was smaller still: bringing the little mascot character nicknamed "Clawd" — originally created by Sam McAllister for the launch of Claude 3.5 Sonnet — into the terminal itself, the kind of playful detail a shipped product rarely has room for.

Outside adoption arrived through people who happened to be exactly primed for it. Austin Ray, a lifelong command-line user working in AI developer experience at the fintech company Ramp, saw a post about the new research preview and tried it; within five minutes he'd decided it was going to change everything, and he spent the following weeks walking desk to desk at Ramp, telling colleagues to install it, boot up a terminal, and just describe whatever they were already working on. He, Cherny, and Cat Wu fell into a weekly feedback rhythm that became, in effect, an ongoing collaboration between one determined outside user and the people actually building the tool. Kyle Easterly, a consultant who'd first learned to program as a child using a DOS batch-file manual on a motorhome trip with his grandparents, was in the middle of building software for a small Alaska nonprofit — the Statewide Independent Living Council, which runs disability-transition workshops for high schoolers — when Claude Code launched, and he simply switched tools mid-project. Jarred Sumner, the founder of the JavaScript runtime Bun, threw a genuinely hard problem at it early on — implementing websocket compression from a technical specification — and was impressed enough by the result that he restructured how his own team prioritized work around using it; when a debate arose later inside his company about banning the tool outright, he made sure that didn't happen.

Not everyone found it useful right away. Tristan Hume, who works on performance engineering at Anthropic, spent his days on deep, poorly documented accelerator-kernel problems that required exactly the kind of open-ended investigation early Claude Code wasn't yet good at — for that specific, narrow slice of work, the tool simply wasn't there yet. Meaghan Choi has come to see the arrival of the Claude 4 family of models, months after launch, as the real turning point for design: before that release there wasn't much room to design anything, because the underlying model wasn't capable enough to support the product the team actually wanted to build. Once it was, that changed almost overnight. Cherny points to two forces converging at once to explain the sudden takeoff that followed — a genuine model breakthrough, paired with a new subscription business model that made the tool sustainable at scale. Dawn Drain, characteristically, offers the more deflationary read: she doesn't think Claude Code owes as much to clide's specific design choices as people assume: once a model crosses a real capability threshold, the right shape of product for it tends to become obvious on its own. Kyle Easterly frames the same shift personally — back in 2022 he couldn't yet picture what Claude Code would become, but the moment he saw it produce one working app end to end, he could extrapolate the rest for himself. Even inside the team, the scale of what followed came as a genuine surprise; Sid Bidasaria says plainly that he never expected the product to become anywhere near this large, and that the fact of it still surprises him.

---

The New World

Cherny tracks his own transition in code-writing terms that double as a rough timeline for the whole industry around him. In February 2025, Claude Code was responsible for maybe ten percent of the code he personally shipped. By May that had risen to thirty or forty percent, and he remembers sitting in a back room at Anthropic's Code with Claude developer conference, coding while the Sonnet 4 model launched onstage, and thinking that the model had genuinely arrived — more agentic, simply better at the job, in a way that was obvious the moment you touched it. By the following winter, he was writing zero lines of code by hand; all of it came from Claude Code. That arc lines up almost exactly with the tool's own commercial trajectory: general availability in May 2025, a billion dollars in annualized run-rate revenue by that November — six months after launch — and, weeks later, in December 2025, Anthropic's acquisition of Jarred Sumner's company, Bun, to bring the JavaScript runtime Claude Code itself depended on directly in-house. The two stories are more connected than they look: Sumner's team had already used Claude Code, under his own direction, to rewrite Bun's entire codebase from the low-level systems language Zig into Rust — a project that would once have taken well over a year of engineering time and instead ran, largely on its own, over eleven days.

Kyle Easterly has a framework for the two kinds of developer he sees adapting differently to this shift: the ones who love the craft of writing code for its own sake, tending it like a private garden, and the ones — his own camp — whose real satisfaction comes from someone out in the world actually using and liking the thing that got built, regardless of who or what typed it. Shauna Kravec describes running a personal "swarm" of a dozen different Claude instances at once, reading documents, updating internal systems, pulling context from Slack — and says that, ironically, being a research lead who'd barely written code by hand in years, she's now writing *more* of it than she used to, simply because it's become so much easier to start. Igor Kofman thinks the next shift in abstraction is already visible on the horizon: not managing a pile of individual Claude instances directly, but managing whatever manages them. Not everyone has adjusted painlessly — Tristan Hume watched colleagues gain enormous leverage running Claude on background tasks and realized he had no comparable setup himself, and it cost him roughly a week of ordinary work just to build a new development environment that could keep up. Cherny's own account of an ordinary working day by this point involves his wife and dog on the couch nearby while he logs 88 commits before the day is over.

The most telling shift may be the quietest one. Cat Wu remembers that at launch, essentially every user read every single permission request Claude Code made before approving it — each file touched, each command run, examined individually. By 2026, Anthropic's own research on how the tool is actually used bears out what she's watched happen since: across roughly 400,000 sessions studied between October 2025 and April 2026, the proportion of work spent simply fixing broken code fell from a third of all sessions to under a fifth, while time spent having Claude operate other software directly rose from fourteen percent to twenty-one, and the estimated value of an average session rose by more than a quarter over those seven months alone. A large share of users today, Wu says, simply auto-accept most requests without inspecting each one — not out of carelessness, but because, in her reading, Claude has by now genuinely earned that trust.

The Future

Adam Wolff has lived through one version of this trajectory already. React, he points out, began as a fairly narrow computer-science argument — that functional programming was a better way to represent interface state than the message-passing approaches that came before it. By the time it had a million daily users, it had stopped being that argument at all; it had become a logo, a brand, a feeling, and the specific insight the median user actually valued may not even trace cleanly back to the original idea. He expects Claude Code to go the same way — whatever any individual user thinks it fundamentally *is*, whether that's the terminal, a particular model's personality, or one favorite prompting trick, none of those specific answers will matter much once the product has grown past the point where any one of them can define it.

Austin Ray has tried to build against that drift deliberately at Ramp, cultivating a public internal culture where people share what worked and what didn't rather than letting hard-won tricks stay locked in one person's head — compounding tribal knowledge, in his phrase, is the actual advantage. Fiona Fung, after more than a decade working on developer tools, is candid about the limits of her own foresight: she doesn't pretend to know what next month looks like, and thinks the only sound posture left is staying curious and paying close attention to what actual users, inside and outside the company, are already doing with it. Tristan Hume tested the outer edge of what today's tool can do by having Claude build an entire alternative to Jupyter Notebooks from scratch, unsupervised, testing its own UI in a browser as it went — and it worked, in the narrow sense that the resulting software ran. He didn't end up liking using it, though, and has concluded he's waiting for a future version with enough taste to know, unprompted, what he actually needs.

Kyle Easterly's example of what becomes newly possible is a small one on purpose: an Alaska nonprofit that could never have afforded custom software before, now able to take handwritten fuel-delivery logs from the North Slope and turn them into a proper tablet application — the kind of project no grant budget would ever have covered, made real anyway. Shauna Kravec's closing case is the largest one on offer: she argues that the genuinely transformative promises people make about AI — accelerating research, treating cancer, reaching the moon — cannot come from a model that only answers questions when asked. They require a model capable of open-ended, autonomous action in the world, which is exactly the capability the whole arc from clide to Claude Code has been chasing from the start. Her own background is in theoretical physics, a field where progress is measured in decades and bottlenecked by things as expensive and slow to build as particle colliders; measured against that baseline, she expects the next two years to compress what would once have taken far longer into three-month intervals, and admits she isn't sure anyone — herself included — is fully ready for how disorienting that pace will feel from the inside.

Igor Kofman's own life traces almost the entire arc in miniature. His mother debugged scientific programs punched onto cards; his father learned to code only after someone donated a Commodore to a youth center in Kyiv, and father and son worked through a coding manual together at home. By the winter of 2025, Kofman no longer writes any code by hand himself. Boris Cherny reaches for a similar span when he wants to place Claude Code inside something larger than its own five-year history: an IBM 029 card-punch machine, not unlike the one his own grandfather once used in the Soviet Union, sitting at one end of a line that runs through one of the very first text editors — a program still installed, quietly, on every Mac sold today — and keeps evolving, one generation folding into the next, with Claude Code simply the point that line has reached so far, not the point where it stops.

It is worth holding that image next to where this story started: a VS Code extension offering four suggestions per prompt, built by a company that had just finished arguing internally about whether to ship a product at all. Nothing about that first version predicted what it would become. What changed wasn't a single idea — it was several years of unglamorous harness work, a handful of people who couldn't stop tinkering with an ugly internal tool on their own time, and a model that, at some specific and largely unheralded moment, finally got good enough that the right shape of product simply revealed itself.

A note on sources

The interviews quoted and paraphrased throughout — Ben Mann, Shauna Kravec, Dawn Drain, Boris Cherny, Adam Wolff, Raphael Lee, Igor Kofman, Cat Wu, Meaghan Choi, Sid Bidasaria, Fiona Fung, Austin Ray, Kyle Easterly, Jarred Sumner, and Tristan Hume — were recorded by Anthropic between February and May 2026 and published as [*The Making of Claude Code*]

(https://www.anthropic.com/features/making-of-claude-code), which remains the primary source for this account. Supplementary detail on Boris Cherny's pre-Anthropic career, his childhood introduction to programming on a TI-83 calculator, and the mechanics of dynamic workflows and the Bun rewrite came from a recorded fireside conversation, *Boris Cherny: Building Claude Code*, and from the *Developing Dev* podcast episode on his career history, both held in this collection. The original research-preview launch demo is documented in *Introducing Claude Code*, also in this collection. Figures on Claude Code's commercial trajectory and the Bun acquisition come from Anthropic's own announcement, [*Anthropic acquires Bun as Claude Code hits $1B*]

(https://www.anthropic.com/news/anthropic-acquires-bun-as-claude-code-reaches-usd1b-milestone) (December 3, 2025); the usage-pattern statistics in "The New World" come from Anthropic's research report [*How Claude Code is used in practice*](https://www.anthropic.com/research/claude-code-expertise).