When Boris Cherny first gave an AI model a Bash tool and asked it what music he was listening to, he wasn't trying to build the most consequential developer tool of 2025. He was just trying to understand Anthropic's API. The model responded by writing AppleScript to query his Mac's music player — and in that moment, something clicked.
"I didn't think the model could do that. And that was my first, I think, ever feel-the-AGI moment, where it's just like, 'Oh my God, the model, it just wants to use tools.' That's all it wants."
What followed was a three-month sprint of sleepless nights, a product born from accident and intuition, and an unlikely form factor — a terminal — that would go on to reshape how software gets built. In a wide-ranging conversation on the YC Lightcone podcast, Cherny, the creator of Claude Code, pulled back the curtain on the origins, philosophy, and future of the tool that Garry Tan described as "rocket boosters" for coding.
The Accidental Terminal
Claude Code didn't begin with a grand vision. There was no product spec, no mandate from leadership, no pressure to compete with the IDE-based coding assistants like Cursor and Windsurf that were gaining traction in 2024. Cherny was part of Anthropic's Labs Team — the same team that produced MCP and the desktop app — and his assignment was simply to explore what a coding product might look like.
"No one asked me to build a CLI. We kind of knew maybe it was time to build some kind of coding product 'cause it seemed like the model was ready, but no one had yet really built a product that harnessed this capability."
The terminal was chosen for the most prosaic of reasons: it was the cheapest thing to build. No UI required. Just a chat interface where Cherny could experiment with the API and, later, with tool use. He literally took the example from Anthropic's documentation, ported it from Python to TypeScript, and started playing.
Two days after the first prototype, Cherny gave it to his team for dogfooding. The next morning, he walked in to find an engineer named Robert already using it to write code.
"I was like, 'What? What are you doing? Like, this thing isn't ready. It's just a prototype.'"
But it was already useful. When they later presented the internal adoption chart to Anthropic CEO Dario Amodei before an external launch review, Dario asked if engineers were being forced to use it — the adoption curve was that steep. They weren't. People were just telling each other about it.
Building for the Model of Tomorrow
The most counterintuitive principle driving Claude Code's development is also its most powerful: don't build for the model of today.
"At Anthropic, the way that we thought about it is we don't build for the model of today. We build for the model six months from now. And that's actually, like, still my advice to founders that are building on LLMs."
When Claude Code launched internally, the model wasn't very good at coding. Cherny himself used it mostly for automating Git commands and batch operations. The first real coding use case was writing unit tests — "a little bit lower risk," as Cherny put it, since the model was still "pretty bad at it." Even in February 2025, the model was writing maybe 10% of his code.
But the bet paid off. Each new model generation brought a leap in capability, and because the team had built infrastructure that could harness those improvements, Claude Code got dramatically better without fundamental redesigns.
This philosophy extends to a concept Cherny calls "scaffolding" — the code and features built around the model to extend its capabilities. The team frames it as a constant trade-off: you can invest engineering work now to improve performance by 10-20% in a given domain, or you can wait a couple of months and the next model will likely do it natively.
"Assume that whatever the scaffolding is, it's just tech debt."
The Claude Code team keeps a framed copy of Rich Sutton's "The Bitter Lesson" on their office wall — the famous essay arguing that general methods leveraging computation always eventually beat specialized approaches. "Never bet against the model," Cherny summarized.
This is why there is no part of Claude Code that existed six months ago. The codebase has been written and rewritten and rewritten again. Tools are added and removed every couple of weeks. The shelf life of code in this new era, Cherny suggested, is measured in months.
Latent Demand: The Single Biggest Idea in Product
If there's one concept Cherny returns to obsessively, it's latent demand — the idea that successful products make existing behaviors easier rather than trying to create new ones.
"People will only do a thing that they already do. You can't get people to do a new thing. If people are trying to do a thing and you make it easier, that's a good idea. But if people are doing a thing and you try to make them do a different thing, they're not gonna do that."
Every major Claude Code feature traces back to this principle. The CLAUDE.md file — now a staple of how developers configure their Claude Code experience — originated from users spontaneously writing markdown files with instructions and having the model read them. Plan mode came from observing users who were already typing things like "come up with an idea, plan this out, but don't write any code yet" in their prompts.
Plan mode's origin story is characteristically scrappy: Cherny was browsing GitHub issues on a Sunday night at 10 PM, noticed the pattern, wrote the feature in 30 minutes, and shipped it Monday morning. All it does, technically, is add one sentence to the prompt: "Please don't code."
"There's no big secret to it. All it does is it adds one sentence to the prompt that's like, 'Please don't code.' That's all it is. You can actually just say that."
Even Codework — Anthropic's more accessible product for non-technical users — emerged from latent demand. The team observed designers, finance teams, and data scientists at Anthropic jumping through hoops to install a terminal tool so they could use Claude Code for non-coding tasks. People were monitoring tomato plants, recovering wedding photos from corrupted hard drives, doing financial analysis. The wrapper was built in roughly 10 days, 100% by Claude Code itself.
The Death of Plan Mode (and Maybe Software Engineering)
Perhaps the most startling moment in the conversation came when Harj Taggar asked whether the model might eventually be good enough to figure things out without explicit plan mode prompting — "in six months, maybe?"
"Maybe in a month."
Cherny believes plan mode has a "limited lifespan." Claude Code can already enter plan mode on its own, and the team is working to make it trigger at exactly the point a human would have wanted it. The trajectory is clear: six months ago, you had to babysit before and after planning. Today, you only need to guide the planning phase. Tomorrow, perhaps not even that.
The implications extend far beyond a single feature. Cherny has personally uninstalled his IDE. He doesn't edit a single line of code by hand — it's 100% Claude Code with Opus 4.5, landing roughly 20 pull requests per day. Across Anthropic, the range is 70-90% AI-written code depending on the team, with many individuals and teams at 100%.
The productivity numbers are staggering. Since Claude Code's adoption, productivity per engineer at Anthropic has grown 150%, measured by pull requests and cross-checked against commits and commit lifetimes. Cherny puts this in perspective from his previous role leading code quality at Meta:
"One of the things that the team worked on was improving productivity. And back then, seeing a gain of something like 2% in productivity, that was like a year of work by hundreds of people. And so this like 100%, this is just like unheard of."
Looking ahead, Cherny predicts that coding will be "generally solved for everyone" and that the title of software engineer may evolve — perhaps to "builder" or "product manager" — as the role expands beyond writing code to encompass specs, user research, and design. At Anthropic, this is already reality: PMs code, designers code, the finance team codes. Everyone codes.
The Art of Terminal Design
One of the conversation's most delightful threads was about the surprisingly difficult craft of designing for the terminal. Claude Code's interface, built with React Terminal, has gone through extraordinary iteration — the spinner alone has seen perhaps 50 to 100 versions, with 80% never shipping.
"Designing for the terminal honestly has been hard. It's like 80 by 100 characters or whatever. You have like 256 colors, you have one font size, you don't have like mouse interactions. There's all this stuff you can't do."
Garry Tan compared it to a BBS door game — a reference to the text-based online games of the 1980s and 90s. Cherny took it as a compliment: "It should feel like you're discovering something."
The team has had to reinvent UX principles for the terminal from scratch, since no one really writes about this stuff anymore. They prototyped mouse interactions but found the trade-offs (virtualized scrolling, weird terminal escape code behaviors dating back to the 1960s) made it feel wrong. They experimented with hiding file reads and searches to reduce noise, shipped it after a month of dogfooding, then iterated further when GitHub users pushed back — adding a verbose mode and continuing to refine based on feedback.
Hiring for the Age of Agents
Cherny's hiring philosophy reflects his broader worldview about humility and first-principles thinking. The most effective engineers on his team fall into two categories: extreme specialists (like Jared Sumner of Bun fame, who went on a "crusade killing all the memory leaks") and hyper-generalists who span product, infrastructure, design, and user research.
"I think actually the biggest skill is people that can think scientifically and can just think from first principles."
He screens for humility with a deceptively simple interview question: "What's an example of when you were wrong?" He's looking for people who can recognize mistakes in hindsight, claim credit for them, and articulate what they learned.
One anecdote captures the kind of creative thinking he values. An engineer named Daisy, who transferred onto the team, was tasked with adding a feature to Claude Code. Instead of implementing it directly, she first built a tool that lets Claude Code test arbitrary tools and verify they work — then had Claude write its own tool rather than implementing it herself.
"I think it's this kind of out-of-the-box thinking that is just so interesting 'cause not a lot of people get it yet."
Agents Talking to Agents
The frontier of Claude Code's development is multi-agent collaboration. The team recently built its entire plugins feature using a swarm of agents over a weekend — an engineer gave Claude a spec and told it to use an Asana board. Claude created tickets, spawned agents, and the agents picked up tasks and executed them with minimal human intervention.
Cherny revealed that the majority of Claude Code agents today are likely prompted not by humans but by other agents — sub-agents spawned by what the team affectionately calls "Mama Claude." These sub-agents are simply recursive instances of Claude Code with fresh context windows, and the team is exploring various topologies for how they communicate and collaborate.
In Cherny's own workflow, Claude agents already message engineers on Slack to ask clarifying questions, check Git blame to find who touched relevant code, and occasionally even try to tweet (though Cherny deletes those — "it's a little cheesy").
Why Anthropic, Why Safety
Cherny came to Anthropic from Meta, where he oversaw code quality across Facebook, Instagram, and WhatsApp. He was living in rural Japan, reading Hacker News every morning, when AI started dominating the headlines. Using early AI products gave him a feeling he'd never experienced as a builder.
But it was the safety mission that sealed the deal. A voracious sci-fi reader, Cherny is acutely aware of how wrong advanced AI could go.
"If you overhear conversations in the lunchroom or in the hallway, people are talking about AI safety. This is really the thing that everyone cares about more than anything."
He spoke candidly about Anthropic's ASL (AI Safety Level) framework — the models are currently at ASL-3, and ASL-4 represents recursively self-improving systems. The upper bound of what could happen this year, he acknowledged, "is a lot scarier" than the lower bound of coding being solved for everyone.
The Exponential Continues
Four percent of all public code commits are now made by Claude Code. Seventy percent of startups are choosing Claude as their model. NASA used it to plot the course for the Perseverance Mars rover. The team printed posters to celebrate that one.
But for all the staggering statistics, Cherny keeps returning to a posture of humility and wonder. Half his ideas are bad, he says. He's wrong about the terminal's lifespan every time someone asks. The product that was supposed to be a starting point became the thing itself.
"I just wanted to build a cool thing, and it ended up being really useful. And that was so surprising and so exciting."
As the conversation wound down, Garry Tan thanked Cherny for building something that had stolen his sleep but restored his sense of being a creator. Cherny's parting words were perfectly on-brand for someone obsessed with latent demand and user feedback:
"Send bugs. Want to hear them immediately."
In a world racing toward increasingly powerful AI, Claude Code stands as a testament to a simple but profound insight: the best products don't try to predict the future — they build infrastructure flexible enough to ride the exponential, stay radically close to users, and never, ever bet against the model.