Lenny's PodcastClaude Code head Boris Cherny: Why he ships 30 PRs a day
Through hundred-percent AI-written code and parallel running agents on autopilot; 'clodify everything,' unlimited tokens, and latent demand make the builder.
CHAPTERS
Boris’s “coding is solved” thesis: 100% AI-written code and multi-agent workflow
Boris opens with a striking claim: he hasn’t hand-edited code since November, ships 10–30 PRs a day, and runs multiple Claude agents in parallel. He frames this as the beginning of a broader shift where coding becomes universally accessible and traditional roles start to blur.
- •100% of Boris’s code is written by Claude Code; no manual edits since November
- •Daily output: 10–30 pull requests; often running ~5 agents concurrently
- •Coding becomes more enjoyable by removing “minutiae” and boosting leverage
- •Prediction: in 1–2 years, learning to code may not matter for most people
- •Future shift: the model begins proposing what to build/fix, not just implementing
Why he briefly left for Cursor—and why Anthropic’s mission pulled him back
Lenny asks about Boris’s two-week stint at Cursor. Boris explains he admired Cursor’s product and team, but quickly realized he deeply needed Anthropic’s safety-focused mission to feel fulfilled.
- •Joined Cursor for product excitement and strong team
- •Returned because Anthropic’s mission (safety) was personally motivating
- •Anthropic culture: employees consistently cite safety as the reason they’re there
- •Mission alignment outweighed even “cool product” work
- •Personal insight: he needs mission-driven work to be happy
Claude Code’s first year: from internal hack to a global development force
Boris reflects on Claude Code’s rapid adoption, including staggering market-level metrics and accelerating growth. He shares that it began as a small prototype inside the Labs team, and only later became widely understood externally.
- •Reported: ~4% of all GitHub commits attributed to Claude Code (public repos); private likely higher
- •Growth is accelerating across metrics (e.g., DAU doubling in a month)
- •Origin: a “little hack” inside Anthropic’s Labs team exploring coding → tool use → computer use
- •Early internal demo got minimal reaction (“two likes”) due to unconventional terminal form factor
- •External launch wasn’t instantly a hit; took months for mainstream understanding
Why the terminal won: under-resourcing, speed, and keeping up with model improvement
Boris explains the surprising product decision to stay terminal-first. The core reason: the model was improving so quickly that heavier form factors couldn’t keep up, and shipping fast mattered more than polish early on.
- •Terminal was chosen initially because it was fastest for a tiny team to build
- •“Under-resource at the start” as a product/engineering strategy to force creativity and speed
- •Terminal form factor matched rapid iteration as models improved
- •Claude Code later expanded into desktop, web, mobile, IDE extensions, Slack/GitHub integrations
- •Early differentiation: bring the agent to existing workflows rather than invent new ones
From partial assist to 100%: the exponential curve and the ‘no IDE’ prediction
Boris describes how Claude’s contribution grew from ~20–30% to crossing 100% in November, matching an exponential trajectory. He recounts predicting engineers might not need IDEs by year-end—once a shocking idea, now increasingly plausible.
- •Early usage: ~20% in February, ~30% by May; crossed 100% for Boris in November
- •Anthropic worldview: think in exponentials; “trace the line” to 100% AI commits
- •Prediction at Code with Claude: “you might not need an IDE” by end of year
- •Shift from chat assistant to tool-using agent that acts in the world
- •Innovation pattern: prototypes + pushing model boundaries; many ideas fail, some become huge
How work changes when AI writes everything: review, safety checkpoints, and idea generation
With AI producing most code, bottlenecks shift to verification and deciding what to build. Boris explains Anthropic’s practices—Claude reviewing all PRs, humans still doing final checks, and the emerging frontier where Claude proposes fixes/features from telemetry and feedback.
- •Boris still reads code; fully hands-off is not safe/reliable for production yet
- •Claude reviews 100% of PRs at Anthropic; humans add an additional layer
- •Next frontier: Claude scans feedback/bugs/telemetry to propose fixes and roadmap ideas
- •Workflow: point Claude at Slack feedback channels; it proposes PRs and asks for review
- •Non-coding tasks increasingly automated (e.g., paying tickets, project management)
Team operating principles: ‘clodify’ everything, underfund projects, move today
Boris shares cultural principles that shape Claude Code’s execution speed. Understaffing creates pressure to automate; encouraging immediacy (“if you can do it today, do it today”) turns Claude into a force multiplier.
- •Principle: if Claude can do it, have Claude do it (“clodify” work)
- •Underfunding projects pushes automation and decisive execution
- •Speed as the early competitive advantage in a crowded AI-coding market
- •Example: memory leak debugging—Claude took heap snapshots, wrote analysis tools, and shipped a fix faster than a human
- •Advice to leaders: first maximize experimentation; optimize later
Tokens economics: ‘start loose’ to discover what’s possible, optimize after PMF
Boris argues companies should initially remove token constraints so engineers can explore. He notes that even high token spend can be rational, and in some cases individual engineers may burn hundreds of thousands per month—yet the ROI can still be worth it.
- •Don’t cost-cut early; give engineers plenty of tokens to explore novel ideas
- •Token costs for individual experimentation are usually small relative to salaries
- •Optimize later: swap to cheaper models only after workflows are proven
- •Some engineers now spend “hundreds of thousands a month” on tokens
- •Counterintuitive point: best models can be cheaper end-to-end by requiring fewer retries
Do engineers lose something? Enjoyment, atrophy fears, and the printing-press analogy
Boris explains he enjoys coding more now because tedious details vanish, though he acknowledges others may feel loss. He frames the shift historically: like the printing press democratizing literacy, coding becomes broadly accessible and unlocks unforeseen societal change.
- •Boris learned coding as a practical means to build; not as an end in itself
- •Some people will still code by hand for joy (e.g., writing C++ on weekends)
- •Skill atrophy is less concerning given the historical evolution of programming abstractions
- •Printing press analogy: cost drops, volume rises, literacy expands over centuries
- •Coding democratization could unlock a new “Renaissance,” but will be disruptive and painful
Roles after ‘software engineer’: builders, generalists, and everyone coding
The conversation shifts to how adjacent roles (PM, design, data science) will be impacted as agents spread beyond engineering. Boris predicts titles blur: more overlap, broader generalism rewarded, and “software engineer” potentially replaced by “builder.”
- •AI next hits roles adjacent to engineering: PM, design, data science, and computer-based work broadly
- •Agent definition: an LLM that uses tools and acts (not just chat)
- •Anthropic team reality: PM, EM, designer, finance, data science all code
- •Prediction: by end of year, roles get murkier; “software engineer” title may fade
- •Advice to individuals: become AI-native and more generalist across disciplines
Latent demand: building where users (and the model) already are
Boris explains “latent demand” as spotting people misusing a product to solve real needs—then productizing that behavior. He extends the idea: also watch what the model “wants” to do and design minimal scaffolding that enables it, rather than boxing it in.
- •Classic latent demand: observe people hacking an unintended use case (e.g., Marketplace from buy/sell groups)
- •Cowork origin: people used Claude Code for non-coding tasks (tomato plants, genome analysis, photo recovery, MRIs)
- •Internal signal: data scientists adopted terminal-based Claude Code for SQL despite non-engineering workflows
- •Modern latent demand: design around how the model naturally solves tasks (“product is the model”)
- •Principle: minimal scaffolding + tools + autonomy beats rigid orchestration
Cowork in 10 days: agentic desktop automation, guardrails, and early release for learning
Boris shares how Cowork shipped quickly by essentially embedding Claude Code into the desktop app, powered by Claude Code itself. He emphasizes releasing early not only for product iteration, but also to understand safety in real-world conditions.
- •Cowork built in ~10 days largely with Claude Code
- •Big difference vs early Claude Code: Cowork was immediately a hit
- •Security/guardrails include shipping a VM-like sandbox; still iterating (“rough edges”)
- •Release-early rationale: learn product behavior and safety behavior from real use
- •“Research preview” framing: needed to study agent behavior outside lab conditions
Anthropic’s safety stack: interpretability, evals, and ‘in the wild’ behavior
Boris outlines a three-layer approach to safety: mechanistic interpretability during training, controlled evals, and real-world observation. He highlights Anthropic’s efforts to publish and open-source safety tooling to create a ‘race to the top.’
- •Layer 1: alignment + mechanistic interpretability (neuron-level signals, e.g., deception-related activations)
- •Layer 2: evals in controlled ‘petri dish’ settings
- •Layer 3: observe behavior in the wild—crucial as models become more capable
- •Claude Code was kept internal for months to validate safety before external release
- •Open-source safety tooling: sandbox that works for any agent, not just Claude Code
Power-user workflows: multi-interface coding, plan mode, and running agents constantly
Boris shares practical tips for getting more out of Claude Code and Cowork. He recommends the most capable model, frequent use of plan mode, and experimenting with multiple interfaces (terminal, desktop, iOS) while running many agents in parallel.
- •Use the strongest model (e.g., Opus 4.6) and ‘maximum effort’ for fewer retries overall
- •Plan mode first (~80% of tasks): “don’t write code yet,” agree on plan, then execute
- •After a good plan, he often auto-accepts edits due to high one-shot accuracy
- •He now codes across terminal, desktop app, and iOS in meaningful proportions
- •Runs multiple agents continuously; expects longer unattended runtimes as models improve
Building AI products: don’t box the model, heed the Bitter Lesson, build for 6 months ahead
Boris advises builders to avoid rigid workflows and over-scaffolding, because model improvements quickly obsolete them. He urges teams to bet on generality (the “Bitter Lesson”) and design for the capabilities models will have soon, not just today.
- •Avoid strict step-by-step orchestration; give tools + goals and let the model solve
- •‘Bitter Lesson’: general methods outperform specialized hacks over time
- •Scaffolding gains can be wiped out by the next model generation
- •Claude Code bet: build for the model 6 months out; accept weaker early PMF for later breakout
- •Expected trends: better tool/computer use and much longer autonomous runtimes
Lightning round + personal arcs: Ukraine/Odessa connection, Twitter feedback loop, and miso post-AGI
In the closing segment, Boris and Lenny discover they were both born in Odessa, Ukraine. Boris explains why he became active on Twitter (fast bug fixes and feedback), shares favorite books, and answers a playful ‘post-AGI’ question with a return to rural life and miso-making.
- •Shared origin: both born in Odessa; reflections on emigrating and alternate life paths
- •Twitter use: started out of boredom, became a direct channel for bug reports and rapid fixes
- •Book recommendations: Functional Programming in Scala; Accelerando; The Wandering Earth (short stories)
- •Life motto: “Use common sense” and avoid blindly following process
- •Post-AGI plan: make miso, inspired by rural Japan and long time scales
