Y CombinatorBoris Cherny: How Tool Use Turned a CLI Into Claude Code
By betting on bash tools and a minimal terminal loop; CLAUDE.md emerged from organic user demand, and subagents now parallelize repo exploration.
CHAPTERS
- 0:00 – 2:38
Why Claude Code was built for “the model six months from now”
Boris explains Anthropic’s guiding product strategy: don’t optimize for today’s model capabilities, but for what models will reliably do in the near future. He describes Claude Code as a constant rewrite driven by user feedback and shifting model frontiers, and frames this as advice for any founder building on LLMs.
- •Build for where the model is weak today but will improve soon
- •Claude Code has been repeatedly rewritten; little remains from six months prior
- •User feedback loops (ship → observe → revise) are central
- •Product decisions are shaped by rapid model progress and uncertainty
- 2:38 – 5:38
From accidental CLI prototype to a real product idea
The initial “Claude Code” started as a simple terminal chat client so Boris could learn the Anthropic API quickly without building a UI. Tool use became the turning point, revealing that the model’s core impulse is to act through tools—an early “AGI-feeling” moment that pushed the prototype toward agentic coding.
- •The CLI began as a quick API playground, not a planned product
- •Anthropic’s broader roadmap: coding → tools → computers
- •Early experiment: giving Claude a bash tool and seeing what it could do
- •Tool use (e.g., AppleScript to detect music) convinced Boris it was real
- 5:38 – 7:09
Why the terminal stuck: simplicity, dogfooding, and viral internal adoption
Claude Code’s terminal form factor survived longer than expected because it was immediately usable and spread organically inside Anthropic. Boris recounts how quickly teammates started using the prototype for real work and how internal usage spiked without mandates.
- •Terminal chosen because it was the cheapest interface to build
- •Engineers began using it immediately despite “prototype” status
- •Internal adoption grew virally; leadership questioned if it was mandated
- •Surprise: terminal was supposed to be a starting point, not the end state
- 7:09 – 7:40
Early real-world use cases: Git, bash automation, Kubernetes, and unit tests
Before the models were good at writing substantial code, Claude Code was most valuable for operational tasks and low-risk code generation. Boris describes how users found practical footholds—especially automating Git workflows and generating unit tests—while model coding skills matured.
- •Model initially couldn’t write much code; value came from automation
- •Common early uses: Git commands, bash scripting, Kubernetes operations
- •Unit tests were an early coding use case because they’re lower risk
- •Users learned how to “hold it right” through experimentation
- 7:40 – 11:28
CLAUDE.md emerges from latent demand—and why Boris keeps his tiny
Teams began creating personal markdown “rules” files and having the agent read them, which evolved into the CLAUDE.md pattern. Boris argues against over-engineering: his personal file is just two lines, while most guidance lives in a shared repo-level CLAUDE.md maintained continuously.
- •CLAUDE.md came from users’ organic behavior (latent demand)
- •Boris’s personal CLAUDE.md: auto-merge PRs + post to stamps channel
- •Team-level CLAUDE.md is shared, checked in, and frequently updated
- •Advice: if your CLAUDE.md is huge, delete and rebuild incrementally
- 11:28 – 14:31
How verbose should an agentic terminal be? The UX trade-offs and configs
The team continuously tunes what Claude Code shows vs. summarizes, learning that different users need different levels of transparency. Attempts to hide bash output and tool details triggered strong reactions, leading to a configurable “verbose mode” and more iteration driven by GitHub feedback.
- •Users often demand raw outputs for trust and debugging
- •Summarizing file reads/searches became possible as models got more reliable
- •External feedback differed from internal dogfooding; preferences vary widely
- •Result: add a configurable verbose mode and keep iterating rapidly
- 14:31 – 18:53
Staying effective as models improve: beginner mindset, humility, and first principles
Boris argues that the biggest advantage now is the ability to discard outdated assumptions as capabilities shift. He shares how even he gets surprised by newer teammates using Claude Code more ambitiously, and offers hiring signals that predict adaptability.
- •Senior-engineer “strong opinions” can become liabilities in fast shifts
- •Key skill: scientific thinking and first-principles reasoning
- •Hiring prompt: ask candidates for examples of being wrong and learning
- •Personal example: Claude Code analyzed a heap dump and found a leak faster
- 18:53 – 21:51
Hyper-specialists vs hyper-generalists—and what great AI-native engineers do
Boris observes a bimodal distribution of top performance: deep specialists and broad generalists both thrive. He highlights “weird” cross-disciplinary behavior—like building meta-tools so Claude can test tools—plus widespread automation via Anthropic’s agent SDK across the development lifecycle.
- •Two archetypes: extreme specialists (runtime/devtools experts) and hyper generalists
- •Generalists increasingly span product, infra, design, research, and business
- •Example: engineer had Claude create tooling to test tools, then used it to build features
- •Agent SDK automates code review, security review, issue labeling, and release workflows
- 21:51 – 23:23
Claude Teams, agent topologies, and building with swarms
The conversation shifts to multi-agent collaboration: independent context windows, parallelism, and coordination patterns (“topologies”). Boris explains how Teams fits into this and describes a plugins feature built largely by a swarm running over a weekend with minimal human intervention.
- •Uncorrelated context windows + coordination act like test-time compute
- •Teams aims at collaboration and scaling what agents can build
- •Case study: plugins built by a swarm over a weekend with little intervention
- •Workflow: spec + Asana board + spawned agents that pick tasks and report back
- 23:23 – 28:37
Subagents, ‘Mama Claude,’ and the fading need for explicit plan mode
Boris describes subagents as recursive Claude Code instances typically prompted by a parent agent. As models improve, Claude increasingly decides when to plan on its own; “plan mode” may shrink to a simple instruction (‘please don’t code’) and eventually become unnecessary as autonomy and reliability rise.
- •Subagents are recursively launched by a parent (“Mama Claude”)
- •Parallel subagents help with research and debugging across logs/code paths
- •Plan mode is essentially one extra instruction: don’t write code yet
- •Trajectory: less babysitting after planning, eventually less prompting at all
- 28:37 – 32:10
Founders’ principles for the future: latent demand, watching real usage, and building for models
Boris shares durable product guidance in a rapidly changing landscape: pursue latent demand and observe users directly. He extends this to dev tools: build for what the model wants to do (tool use) and balance human and agent needs, while avoiding rigid assumptions about UI and workflows.
- •Latent demand: make an existing behavior dramatically easier
- •Boris watches coworkers use Claude Code to learn real workflows
- •Dev tool advice: enable the model’s natural desire to use tools, not boxed APIs
- •Balance product needs of both humans and agents as primary “users”
- 32:10 – 34:45
TypeScript parallels: designing around how people actually code
Reflecting on his TypeScript background, Boris explains how TS succeeded by adapting to real JavaScript practices rather than forcing people into academic ideals. He draws parallels to Claude Code: practicality, flexible integration (Unix-like piping), and product usefulness outweigh purity.
- •TypeScript made ‘weird’ but practical type-system choices to fit JS reality
- •Success came from observing behavior, not enforcing a new coding style
- •Claude Code similarly evolved from what Boris and users needed in practice
- •Practical tooling wins over academic elegance in widespread adoption
- 34:45 – 37:36
Designing a delightful terminal UX: constraints, iterations, and rapid prototyping
Boris details why terminal UX is hard—limited space, colors, fonts, and interaction patterns—and why they avoided features like mouse support due to trade-offs like virtualized scrolling. Claude Code enabled unusually fast UX iteration, letting the team prototype dozens of variants (like spinners) quickly to find what feels great.
- •Terminal constraints: fixed grid, limited colors, minimal interaction primitives
- •Mouse support was prototyped but rejected due to scrolling/UX trade-offs
- •Team had to invent modern terminal UX principles; little prior guidance
- •Claude Code made rapid UX prototyping feasible (many iterations in hours)
- 37:36 – 40:00
Scaffolding vs waiting: The Bitter Lesson, constant rewrites, and short code half-life
Boris lays out a key tension: build scaffolding around the model for short-term gains or wait for model improvements that erase the advantage. He notes that Claude Code frequently removes and replaces tools, with much of the codebase being only months old, and treats scaffolding as intentional tech debt.
- •Core heuristic: don’t bet against general models (The Bitter Lesson)
- •Scaffolding can yield 10–20% gains but gets obsoleted by the next model
- •Claude Code adds/unships tools frequently; major parts rewritten within months
- •Founders should expect fast code churn and plan for it operationally
- 40:00 – 41:35
Productivity and the future of coding: 90–100% AI-written code, new roles, and safety risks
Boris shares internal productivity metrics and predicts coding will become broadly “solved,” shifting software roles toward specification, user work, and generalist building. He also flags the upper-bound risks: recursive self-improvement thresholds and catastrophic misuse, framing Anthropic’s mission-driven safety focus as essential.
- •Anthropic productivity per engineer increased sharply (PR-based measures)
- •Boris claims 100% of his code is now produced via Claude Code + Opus
- •Prediction: ‘software engineer’ title may fade; everyone becomes a builder
- •Safety concerns: ASL-4, recursive improvement, and misuse (bio/zero-days)
- 41:35 – 50:10
Why Boris joined Anthropic—and how Cowork extends Claude Code beyond developers
Boris recounts being captivated by early AI capability and choosing Anthropic for its research-lab orientation and safety mission. He explains Cowork’s origin in non-technical latent demand and describes it as a GUI wrapper around the same agent, with added guardrails like VM isolation and stronger permissions.
- •Joined after seeing early AI progress and meeting mission-aligned leadership
- •Anthropic operates like a research lab: model quality and safety come first
- •Cowork arose because designers/finance/data science used Claude Code for non-coding tasks
- •Cowork is Claude Code under the hood, with VM sandboxing and safer defaults
