Inside Claude Code: How an Accidental Terminal App Became the Dominant AI Coding Tool

Boris Cherny didn’t set out to build the most consequential developer tool of the AI era. He was just trying to understand Anthropic’s API and built a little terminal chat app to test it. That accidental prototype became Claude Code, now responsible for 4% of all public commits worldwide and used by organizations from the smallest YC startups to NASA’s Mars Perseverance team.

The Accidental Origin Story

Anthropic’s bet has always been that the path to safe AGI runs through coding: teach the model to code, then to use tools, then to use computers. When Boris joined the Anthropic Labs team (which would produce Claude Code, MCP, and the desktop app), nobody asked him to build a CLI. The team vaguely knew they wanted a coding product, but the specific form was his job to figure out.

He started by building the simplest possible thing: a terminal chat app to learn the API. No UI, no design system, just text in, text out. When tool use shipped, he plugged in Bash as the first tool, literally copying the example from Anthropic’s docs and porting it from Python to TypeScript. Then he asked the model what music he was listening to. It wrote AppleScript to query his Mac’s music player.

“That was my first ever ‘feel the AGI’ moment. The model just wants to use tools. That’s all it wants.”

This was Sonnet 3.5. The model couldn’t really code yet. But it could do things Boris hadn’t anticipated.

Two days after the first prototype, he started giving it to his team for dogfooding. The next morning, another engineer named Robert already had Claude Code on his computer and was using it to code. Boris told him it wasn’t ready, just a prototype. But it was already useful.

When they did the launch review to release Claude Code externally (around November/December 2024), Dario Amodei looked at the internal usage chart, which was going vertical, and asked: “Are you forcing engineers to use it? Why are you mandating them?” Boris replied that he’d just posted about it and people had been telling each other.

Building for the Model Six Months from Now

The core philosophy at Anthropic, deeply embedded in the Claude Code team’s DNA: don’t build for today’s model, build for the model six months from now.

When Claude Code launched, the model wrote maybe 10% of Boris’s code. He didn’t really use it for coding; it wasn’t good enough. He used it for automating git, running Bash commands, operating Kubernetes. The first real coding use case was writing unit tests, because it was lower risk and the model was still pretty bad at it.

But the bet paid off. The models improved, and Claude Code was already positioned to harness the new capabilities.

This philosophy has a corollary Boris calls “The Bitter Lesson,” after Rich Sutton’s famous essay (they have a framed copy on the wall where the Claude Code team sits). The more general approach always beats the more specific one. In product terms: you could build scaffolding around the model to improve performance 10-20% in some dimension, or you could just wait a few months and the next model does it natively. They call all the non-model code “scaffolding,” and they treat it as inherently temporary.

“There is no part of Claude Code that was around six months ago. It’s just constantly rewritten.”

They unship tools every couple weeks, add new tools every couple weeks. About 80% of the codebase is less than a couple months old.

CLAUDE.md: Less Is More

Boris’s personal CLAUDE.md file has exactly two lines:

1. Whenever you put up a PR, enable automerge.
2. Whenever you put up a PR, post it in our internal team Slack channel.

Everything else lives in the project-level CLAUDE.md that the whole team contributes to, often multiple times a week. When Boris sees a preventable mistake in someone’s PR, he tags Claude on the PR and says “add this to the CLAUDE.md.”

His advice for people whose CLAUDE.md has grown too long: delete it and start fresh. The model’s capabilities change with every release, so a lot of old instructions become unnecessary. Add back instructions only when the model goes off track, one at a time. With each new model, you’ll find you need to add less and less.

The Latent Demand Principle

Boris calls latent demand “the single biggest idea in product.” The principle: people will only do things they already do. You can’t get people to adopt entirely new behaviors. If people are already trying to do something, make it easier. But don’t try to make them do a different thing.

Every major Claude Code feature emerged this way:

CLAUDE.md came from observing that users were already writing markdown files for themselves and having the model read them. Boris just formalized the pattern.

Plan mode was born on a Sunday night at 10 PM. Boris was reading GitHub issues and the internal Slack feedback channel. He noticed people were prompting Claude to “come up with an idea, plan this out, but don’t write any code yet.” He built plan mode in 30 minutes and shipped it that night. It went out Monday morning.

“There’s no big secret to plan mode. All it does is add one sentence to the prompt: ‘please don’t code.’ That’s all it is.”

Verbose mode went through its own latent demand cycle. Boris tried hiding bash output, summarizing it for users. Anthropic employees revolted within a day. Later, they hid file reads and searches (showing “read 1 file” instead of full content), dogfooded it for a month, shipped it. GitHub users didn’t like it. They added verbose mode as an option in /config. Users still weren’t happy. They kept iterating.

Plan Mode Has a Limited Lifespan

Boris uses plan mode for roughly 80% of his sessions. His workflow: start in plan mode in one terminal tab, move to the second tab, start another plan, when he runs out of tabs, open the desktop app’s code tab and start more plans there. Once a plan is solid, he tells Claude to execute, and with Opus 4.5/4.6, it stays on track almost every time.

But he predicts plan mode’s days are numbered. Claude Code can now enter plan mode by itself, and the team is working on making that automatic entry feel as good as when a human would have done it. The trajectory: six months ago, you had to babysit before and after the plan. Now, you only babysit before the plan. Next, you won’t need to babysit at all.

“No more need for plan mode in a month.”

This is the same exponential tracing. Each model generation absorbs what used to require product scaffolding.

Hyper-Specialists vs. Hyper-Generalists

When Boris looks at the most effective engineers on the Claude Code team, the distribution is bimodal:

Hyper-specialists: People like Jared Sumar (who went on a crusade killing memory leaks) and the Bun team, who understand JavaScript runtime systems and dev tools deeper than anyone else.

Hyper-generalists: Engineers who span product and engineering, or product and design, or product and user research, or product and business. Boris specifically looks for people who “do weird stuff,” which used to be a warning sign (“can they build something useful?”) but is now the strongest signal.

Example: an engineer named Daisy transferred onto the team after putting up a PR for Claude Code. Instead of just adding a feature, she first built a tool that lets Claude Code test an arbitrary tool and verify it works, then had Claude write its own tool instead of implementing it herself. That kind of lateral thinking is what Boris hires for.

His interview technique: ask “What’s an example of when you were wrong?” He’s looking for people who can recognize mistakes in hindsight, claim credit for the mistake, and articulate what they learned. He estimates half his own ideas are bad.

Agents Talking to Agents (and Humans)

The Claude Code team uses Claude agents extensively for automation beyond coding. Agents automate code review, security review, issue labeling, and shepherding things to production.

A revealing anecdote: when Boris asks Claude to build something, it looks at the codebase, finds which engineer touched the relevant code via git blame, then messages that engineer on Slack with a clarifying question. When it gets an answer, it continues.

The plugins feature was entirely built by a swarm of agents over a weekend. An engineer gave Claude a spec and told it to use an Asana board. Claude created tickets on Asana, spawned sub-agents, and those agents picked up tasks independently. The plugins shipped largely in the form the swarm produced.

Boris reveals that the majority of Claude agents running today are probably prompted by Claude itself, in the form of sub-agents. A sub-agent is just a recursive Claude Code instance, prompted by what the team calls “mama Claude.”

The 1000x Productivity Claim

Steve Yegge posted that an Anthropic engineer currently averages 1,000x more productivity than a Google engineer at Google’s peak. Boris puts this in context: since Claude Code launched, productivity per engineer at Anthropic has grown 150%, measured by pull requests (cross-checked against commits and commit lifetime). The team doubled in size, but per-engineer productivity grew 70%.

For perspective: in Boris’s previous role at Meta, where he was responsible for code quality across Facebook, Instagram, and WhatsApp, a 2% productivity gain represented a year of work by hundreds of people.

Boris personally lands about 20 PRs per day, with 100% of his code written by Claude Code since Opus 4.5. He uninstalled his IDE. Across Anthropic, AI-written code ranges from 70-90% depending on the team, with many individuals at 100%.

Co-work: Claude Code for Everyone

Co-work (Claude Code in the desktop app for non-technical users) was also pure latent demand. Internally, every designer, the entire finance team, and the entire data science team had jumped through hoops to install a terminal tool so they could use Claude Code for non-coding tasks. Externally, people were using it to monitor tomato plants, recover wedding photos from corrupted hard drives, and manage finances.

Felix, an early Electron contributor, and his team built co-work in about 10 days, 100% written by Claude Code. Under the hood, it’s the same agent. The key differences for non-technical users: code runs in a virtual machine, there are deletion protections, and more permission prompting and guardrails.

Why Anthropic, Why Now

Boris was living in rural Japan, reading Hacker News every morning, when AI started dominating the headlines. He tried the early products, and as a builder, the feeling took his breath away. This was the Claude 2 era.

Two things won him over about Anthropic: first, it operates as a research lab where the product is secondary to building a safe model. Being close to the model’s development, rather than the product being the most important thing, resonated after years of product building. Second, the mission. As an avid sci-fi reader, he knows how badly things can go. At Anthropic, overheard conversations in the lunchroom are about AI safety.

“If you think back six months ago and what predictions people were making… Dario predicted that 90% of the code at Anthropic would be written by Claude. This is true.”

A Few Observations

This conversation is a masterclass in accidental product development. Several threads worth sitting with:

• The terminal paradox: Boris thought the CLI was a temporary starting point. A year later, it’s still the primary interface, and he’s been wrong about its lifespan at every prediction. The lesson isn’t about terminals; it’s about how the simplest possible interface often has more staying power than anyone expects.

• Latent demand as a product philosophy: Not “what should users do?” but “what are users already trying to do?” Every major Claude Code feature (CLAUDE.md, plan mode, verbose mode, co-work) was observed in user behavior before it was built. Zero features came from a product roadmap.

• The scaffolding trap: Any product code you write around an AI model is temporary. Build it knowing you’ll delete it. The Claude Code team rewrites everything every few months, and the team literally has “The Bitter Lesson” framed on their wall as a reminder.

• The bimodal team structure: In an AI-augmented world, the most effective people are either deep domain specialists or wide-ranging generalists who do weird things. The middle ground of “solid generalist engineer with strong opinions” may be losing its premium.

• The exponential is the product roadmap: Three of Anthropic’s founders co-authored the scaling laws paper. The entire Claude Code strategy is just tracing where the exponential leads, building for the model that doesn’t exist yet, and being willing to delete everything when the new model makes it obsolete.