The Pragmatic Engineer

chevron_right

Building Claude Code with Boris Cherny

whatshot 1090 snips

Mar 4, 2026

Guest

Boris Cherny

Boris Cherny, creator and Head of Claude Code at Anthropic and author of Programming TypeScript, joins to talk about building agentic code tooling. He describes Claude Code’s evolution, parallel agents and deterministic review patterns. They explore retrieval from large codebases, sandboxing and safety layers, and how engineering roles shift as models write more code.

01:37:01

forum

Ask episode

web_stories

AI Snips

view_agenda

Chapters

menu_book

Books

auto_awesome

Transcript

info_circle

Episode notes

question_answer

ANECDOTE

Terminal Hack Grew Into Agentic Code Writer

Early Claude Code began as a terminal chat bot that Boris gave a single bash tool and file-edit capability.
The model surprised him by writing AppleScript to check his music and then evolved to use file and bash tools agentically.

insights

INSIGHT

Tool Adoption Grew Organically By Being Useful

Claude Code reached near-universal adoption inside Anthropic by being useful and optional, not forced.
Internal adoption climbed to ~100% of technical staff; Claude writes roughly 80% of Anthropic's code on average.

volunteer_activism

ADVICE

Run Multiple Agents With Parallel Worktrees

Use parallel checkouts or Git worktrees to run multiple Claude Code agents concurrently.
Boris keeps five terminal tabs (or the desktop app with worktree support) and round-robins agents to maximize throughput.

Get the Snipd Podcast app to discover more snips from this episode

Boris's early coding and startups

01:09 • 9min

chevron_right

Meta years and Better Engineering

09:45 • 9min

chevron_right

Joining Anthropic and Clyde discovery

18:47 • 3min

chevron_right

Origins of Claude Code

22:10 • 4min

chevron_right

From chatbot to agentic code writing

26:10 • 4min

chevron_right

Opus 4.5 moment and full trust

30:10 • 2min

chevron_right

Boris's Cloud Code workflow

31:58 • 4min

chevron_right

Using parallel agents and notifications

35:30 • 4min

chevron_right

PR volume, variety, and testing

39:28 • 2min

chevron_right

Automated review and human-in-loop

41:10 • 3min

chevron_right

Determinism: linters and best-of-n

44:11 • 2min

chevron_right

Cloud Code architecture and safety layers

46:19 • 2min

chevron_right

Prompt-injection defenses and WebFetch

48:40 • 19sec

chevron_right

RAG experiments and agentic search

48:59 • 3min

chevron_right

Permissions, sandboxing, and Unix pitfalls

51:51 • 2min

chevron_right

Anthropic culture and flat titles

54:10 • 4min

chevron_right

Prototype-driven product development

58:30 • 6min

chevron_right

Building and launching Cowork

01:04:19 • 3min

chevron_right

Cowork product and safety complexity

01:07:42 • 2min

chevron_right

Observability, privacy, and vendor mix

01:09:39 • 4min

chevron_right

Agent Teams (Swarms) and uncorrelated contexts

01:13:53 • 3min

chevron_right

Use cases and token costs for Swarms

01:17:00 • 1min

chevron_right

Adapting to rapid model change

01:18:01 • 4min

chevron_right

The printing-press analogy

01:22:16 • 7min

chevron_right

Standout engineer archetypes today

01:29:13 • 1min

chevron_right

Skills that matter and those fading

01:30:15 • 4min

chevron_right

Book recommendations and closing thoughts

• Mentioned in 5 episodes

Functional Programming in Scala

Rune R

Functional Programming in Scala, co-authored by Rune R and Paul Chiusano, delves into the principles and practices of functional programming within the context of the Scala programming language. The book provides a comprehensive guide to functional programming concepts, including immutability, higher-order functions, and monads. It explores how these concepts can be applied to build robust and scalable applications in Scala. The authors illustrate these concepts with practical examples and exercises, making it a valuable resource for both beginners and experienced programmers. The book's focus on practical application makes it a valuable resource for developers seeking to improve their Scala skills and adopt a more functional programming style.

#1342

• Mentioned in 30 episodes

Accelerando

Robert Schultz and Tina Faigen

The Accelerando series by Robert Schultz and Tina Faigen is a highly-regarded piano technique series. It includes seven books that guide students from their first lesson to advanced levels. Each book is filled with motivating studies that support all areas of standard piano technique, making it suitable for both children and adults. The series is designed to provide clear-cut goals for accelerated progress at every age and level.

#133

• Mentioned in 146 episodes

The Three-Body Problem

Cixin Liu

Cixin Liu's 'The Three-Body Problem' is a critically acclaimed science fiction novel that blends hard science with compelling storytelling. The story follows a group of scientists who make contact with an alien civilization, leading to unforeseen consequences for humanity. Liu's intricate world-building and exploration of complex scientific and philosophical themes have earned him widespread recognition. The novel is known for its ambitious scope and its exploration of the potential challenges and dangers of encountering extraterrestrial life. It's a thought-provoking work that has captivated readers worldwide.

#30638

• Mentioned in 2 episodes

Programming TypeScript

Boris Cherny

No description available.

Brought to You By:

• Statsig — ⁠ The unified platform for flags, analytics, experiments, and more.

• Sonar – The makers of SonarQube, the industry standard for automated code review

• WorkOS – Everything you need to make your app enterprise ready.

—

Boris Cherny is the creator and Head of Claude Code at Anthropic. He previously spent five years at Meta as a Principal Engineer and is the author of the book Programming TypeScript.

In this episode of Pragmatic Engineer, we went through how Claude Code was built and what it means when engineers no longer write most of the code themselves.

We discuss how Claude Code evolved from a side project into a core internal tool at Anthropic and how Boris uses it day-to-day. We go deep into workflow details, including parallel agents, PR structure, deterministic review patterns, and how the system retrieves context from large codebases. We also get into how Claude Cowork was built.

As coding becomes more accessible, the role of engineers shifts rather than shrinks. We examine what that shift means in practice, which skills become more important, and why the lines between product, engineering, and design are blurring.

—

Timestamps

(00:00) Intro

(11:15) Lessons from Meta

(19:46) Joining Anthropic

(23:08) The origins of Claude Code

(32:55) Boris's Claude Code workflow

(36:27) Parallel agents

(40:25) Code reviews

(47:18) Claude Code's architecture

(52:38) Permissions and sandboxing

(55:05) Engineering culture at Anthropic