Three likes: where Claude Code began, and every prototype still in a drawer

On July 6, Anthropic published "The Making of Claude Code," an oral history in which the engineers, researchers, and early users who built it take turns telling how the tool grew up. The page itself is built as a terminal — you can choose to "read it in the terminal." The kind of in-joke you'd expect from people who make developer tools. I love it.

My daily work happens inside this tool. This website, AQ, the support system, the voter model — all of it was built in that black window. So reading this oral history felt like reading my own tool's family tree. What I remembered afterward wasn't the success story; it was three counterintuitive details.

1. The bet came three years before the product

Anthropic started building coding models back in 2021, and by early 2022 the RL team was already laying the training groundwork for automated software engineering. Their judgment at the time was blunt: the road to transformative AI runs through automating large chunks of software engineering.

Around the same time they built an internal tool called clide — you could edit code with Claude from the command line. Everyone who was there tells the same story: magical, painful to use, way ahead of its time. One engineering team used it to fan out hundreds of small models in parallel to read an entire folder, and onlookers asked what kind of black magic this was. But it stayed an internal toy. It never became a product.

Not because no one saw the value. Because the model wasn't there yet.

2. Three likes

In September 2024, Boris Cherny joined the Labs team. He originally wanted to build a linter — just a small bite. His manager Ben Mann blocked it: no, you're going to build the big thing.

So he spent about two days hacking together a demo called Claude CLI and posted it to the company Slack.

It got three likes.

Even he admits he didn't fully understand what the demo was at the time. But the next morning, he saw those red-and-green diffs scrolling across a colleague's screen — that colleague was already using it to write real code. It got the green light in December; six or seven people, a two-week sprint, and most of the core features you see today were built. It launched as a research preview in February 2025, renamed Claude Code.

A year later, it's one of the fastest-growing developer tools. Look back at that Slack post: three likes.

A lukewarm internal reception was never a death sentence for a prototype. clide was painful to use, nobody understood Claude CLI — but the form was right; the applause was just late. If you have something in hand and showing it around earns you three likes, that number itself carries no information. What carries information is whether someone quietly starts using it the next day.

3. Deliberately build the product before it works

The most valuable passage in the oral history is Ben Mann on the timing gap in productization: you build the thing while the model can only get it right 20–30% of the time, so that when the next generation of models arrives, it gets it right 80% — and by then you're already standing in the market. The generation after that, 90-something. This work demands a high pain tolerance, because you'll be wrong constantly.

Claude Code's takeoff confirms that rhythm: the real ignition wasn't any single release — it was the Claude 4 generation of models crossing the capability threshold, plus subscription pricing. Model innovation multiplied by business-model innovation, both landing at once. The designers themselves say that before then there wasn't much UX work to do, because the model couldn't yet support what they wanted to build.

The most counterintuitive footnote comes from a researcher who spent years on coding models: Claude Code doesn't actually owe clide much — once model capability crosses the threshold, the right product form grows on its own.

The numbers quantify it: Boris says that at launch in February 2025, roughly 10% of his own code was written by Claude Code; by May, 30–40%; by winter 2025, 100% — not a single line written by hand anymore. Ten months, from assistant to everything.

The drawer

Why this piece got to me — because I sit downstream on this causal chain.

In 2013 I wrote a design doc for a quiz game. It sat in a drawer for thirteen years. In 2026, I finished it and shipped it single-handedly — on the very road the people in this oral history started paving in 2022. And not just the game: this blog's publishing pipeline, the support bot, the ad automation, the synthetic voter model — the entire production line of a one-person company runs inside that terminal.

So to me this story isn't an inspirational essay; it's an annual report from upstream in my supply chain. The year they bet on "automating software engineering," I had no idea the thing in my drawer would one day come alive because of it.

At the end of the oral history, someone is asked about the future of software engineering. The answer, roughly: after a decade-plus of building developer tools, I wouldn't pretend to know what next month will look like.

My version is less humble: I don't know next month either, but the direction is clear —building has gotten cheap. Cheap enough that a three-like prototype is worth pursuing; cheap enough that a thirteen-year drawer is worth opening. That thing in your drawer may be at its perfect "only gets it 30% right" moment, right now.

Original:The Making of Claude Code(Anthropic, 2026-07-06) — pick the "Read in Terminal" mode; the form is the content.