Building Claude Code with Boris Cherny

Summary of Building Claude Code with Boris Cherny

by Gergely Orosz

1h 37m•March 4, 2026
Listen to Episode

Overview of Building Claude Code with Boris Cherny

In this episode Gergely Orosz interviews Boris Cherny (creator and engineering lead of CloudCode / Claude Code) about how the project went from a research hack to one of the fastest growing developer tools, how Anthony (Anthropic) engineers now ship code when AI writes most of it, and what this shift means for software engineering skills, processes, safety, and team culture.

Key topics covered

  • Boris’s background: early hacking, startups, seven years at Meta (Facebook/Instagram) leading code quality, then joining Anthropic.
  • The origin story of CloudCode (Claude Code): internal adoption, early "field-AI" moments, decision to release to study safety in the wild.
  • How Boris uses Claude/Opus models in daily engineering: huge productivity gains (20–30 PRs/day; many written entirely by models).
  • CloudCode architecture & features: agent loop, tools (bash, file edit, web fetch), worktrees, desktop + mobile, CoWork UI, Agent Teams (swarms).
  • Safety & permissioning: multiple defensive layers (aligned models, classifiers, summaries, sandbox VM, allowlists, static analysis).
  • Dev workflow changes: parallel agents, plan mode, learn/explanatory modes, CI checks run by the agent, Claude as first-pass reviewer.
  • Organizational/process changes at Anthropic: generalized titles (“Member of Technical Staff”), minimal PRDs, heavy prototyping, cross-disciplinary contributors.
  • Broader implications: printing-press analogy for code generation, which skills matter going forward vs. which will decline.

Main takeaways

  • Practical shift: The model became good enough (Opus 4.5/4.6) to one‑shot many implementations; Boris reports uninstalling his IDE and letting agents produce most of his code.
  • Code quality still matters — perhaps more than ever — because AI-generated code needs verification. Anthropic pairs automated analysis, Claude-based review, and human sign-off.
  • Safety must be layered: model alignment + runtime classifiers + trust-minimizing interfaces (VMs, summaries, allowlists) are used together.
  • Simpler tooling can win: agentic search (model-driven glob/grep + tool use) replaced local vector RAG in CloudCode because it better handles code drift and permissions.
  • Team/process evolution: faster prototyping, fewer written PRDs, broader “technical” participation across roles (design, data science, finance) — teams are becoming more generalist.
  • Skills to cultivate: hypothesis-driven problem solving, curiosity, cross-disciplinary thinking, automation/observability, and the ability to design safe agent workflows. Debates over language/frameworks matter less.

Notable insights and quotes

  • Field-AI moments: Boris’s first internal PR got rejected because he wrote it by hand; after learning to use internal model tooling (Clyde), the model produced a working PR overnight.
  • “Let the model do its thing” — a corollary to the “bitter lesson”: give models tools and let them run programs instead of trying to treat the model like a narrowly-constrained component.
  • Printing-press analogy: current model-driven coding is likened to the printing press — democratizing a previously specialist skill and creating new roles/markets.
  • On titles: using a single title (“Member of Technical Staff”) encourages people to assume broader capabilities and reduces role barriers.

How CloudCode / Claude Code works (architecture & workflow)

  • Core: an agent query loop that uses small set of tools (bash, file edit, web fetch, etc.) and orchestrates sub-agents when helpful.
  • Client surfaces: terminal app, desktop Electron app, IDE extensions, mobile apps, web, Chrome extension — each with varying integration levels and sandboxing.
  • Parallelism: Boris runs many parallel agents (multiple checkouts or git worktrees), uses “plan mode” to get high-quality specs before one-shot implementation, and workflows scale to phones/cloud-hosted agents.
  • Agent Teams (Swarms): main agent delegates to multiple uncorrelated sub-agents (fresh context windows). This expands effective context and can outperform single-agent runs for complex tasks.
  • Verification: agents run tests, run Claude-based code review in CI, create/auto-install lint rules, and CloudCode can self-test by launching sub-processes that validate behavior.

Safety, permissions, and enterprise concerns

  • Swiss-cheese model: multiple independent defenses reduce risk (aligned model + runtime classifiers + summarized inputs + sandbox VMs + static analysis + allowlists).
  • Prompt-injection protection: improved model alignment, runtime classifiers that detect re-prompting attempts, and sanitizing/summarizing fetched content before exposing it to main agent.
  • Permission model: interactive prompts (run-once, session, global allow), pre-allow safe read-only utilities, and conservative defaults because many UNIX tools can be abused.
  • Data/privacy: Anthropic uses privacy-preserving logging/observability; as an enterprise vendor they cannot (and don't) inspect user content freely — significant design constraint.
  • RAG decision: local vector DBs were abandoned for simple agentic search (glob/grep) because of code drift, permission complexity, and maintenance overhead.

Developer workflow & productivity tips Boris described

  • Parallel workspaces: multiple terminal tabs or git worktrees; start agents in plan mode to get a good implementation plan before generating code.
  • Modes for onboarding vs. productivity: “learn/explanatory” mode for new codebase onboarding; “plan” + one-shot generation for familiar codebases.
  • Use of parallel agents: kick off multiple plan-mode agents in parallel, return to check results and merge/iterate; best‑of‑n and dedupe passes increase determinism.
  • Automate recurring review feedback: capture common reviewer comments and convert them to lint rules or automated checks (now delegated to the model to create those rules).
  • Mobile/Cloud agents: Boris often starts agents from his phone (cloud-hosted environments) for long-running or background tasks.
  • CI & agent review: Claude does the first pass in CI and catches a large share of issues (Boris estimates a substantial percent), with humans providing final approvals.

Team and product process at Anthropic (what changed)

  • Minimal hierarchy and generalized titles encourage cross-functional contribution.
  • PRDs and heavy up-front documentation are de-emphasized; the team prototypes rapidly and iterates with real code.
  • Ship early, listen, iterate: initial releases omit full platform coverage (e.g., macOS-only CoWork launch), then expand based on real usage.
  • Prototyping volume skyrocketed: dozens of interactive prototypes for the same feature are common; low cost of iteration lowers the threshold to try ideas.
  • Cross-role coding: designers, data scientists, finance, and product all ship code thanks to agent assistance lowering the barrier.

Skills that matter (and those that matter less)

  • More valuable:
    • Systematic, hypothesis-driven debugging and verification skills.
    • Curiosity and cross-disciplinary ability (product + engineering + domain).
    • Designing safe agent workflows, observability, and automation.
    • Rapid prototyping and user-feedback driven iteration.
  • Less critical:
    • Strong tribal attachment to one language or framework; model can translate and adapt.
    • Hand-crafting boilerplate or repetitive migrations (models can handle many of these).
  • Soft meta-skill: intellectual humility — re-evaluate previously discarded ideas as models rapidly improve.

Actionable recommendations for engineers

  • Learn the model layer: study tool-use patterns, prompt strategies, and how models interact with tools (not just chat prompts).
  • Automate repetitive reviewer feedback into lint rules and CI checks — enlist the model to write those automations.
  • Introduce layered safety: alignment, runtime classifiers, sandboxing, allowlists, and summarized inputs for external data.
  • Prototype fast and show concrete working demos to users instead of long PRDs; iterate from real usage.
  • Design observability with privacy constraints in mind — collect enough telemetry for debugging without exposing user content.
  • Try parallel agents and “plan mode” for familiar codebases; use explanatory/learn modes for onboarding.

Recommended reading & resources Boris mentioned

  • Fiction / context for long-term thinking:
    • Works by Cixin Liu (Three‑Body Problem and short stories)
    • Accelerando by Charles Stross (fast‑paced exploration of technological acceleration)
  • Technical:
    • Functional Programming in Scala (to learn types-first thinking and functional design)

Final thought

Boris frames the current transition as comparable to the printing press: a technology that democratizes an elite craft, expands the market for written work (or in this case, software), and creates new kinds of roles even as old roles transform. For engineers, the immediate opportunities are to learn the model/tooling layer, design robust verification and safety systems, and embrace cross-disciplinary, high‑velocity prototyping.