Claude Code from Source
Claude Code from Source — Book Cover

Claude Code from Source

Architecture, Patterns & Internals of Anthropic's AI Coding Agent. 18 chapters across 7 parts. ~400 pages.

Reverse-engineered from source maps. Every chapter has transferable patterns you can steal for your own systems.

Part 1

Foundations

Before the agent can think, the process must exist.

1
The Architecture of an AI Agent

The 6 key abstractions, data flow, permission system, build system

 2
Starting Fast — The Bootstrap Pipeline

5-phase init, module-level I/O parallelism, trust boundary

 3
State — The Two-Tier Architecture

Bootstrap singleton, AppState store, sticky latches, cost tracking

 4
Talking to Claude — The API Layer

Multi-provider client, prompt cache, streaming, error recovery
Part 2

The Core Loop

The heartbeat of the agent: stream, act, observe, repeat.

5
The Agent Loop

query.ts deep dive, 4-layer compression, error recovery, token budgets

 6
Tools — From Definition to Execution

Tool interface, 14-step pipeline, permission system

 7
Concurrent Tool Execution

Partition algorithm, streaming executor, speculative execution
Part 3

Multi-Agent Orchestration

One agent is powerful. Many agents working together are transformative.

8
Spawning Sub-Agents

AgentTool, 15-step runAgent lifecycle, built-in agent types

 9
Fork Agents and the Prompt Cache

Byte-identical prefix trick, cache sharing, cost optimization

 10
Tasks, Coordination, and Swarms

Task state machine, coordinator mode, swarm messaging
Part 4

Persistence and Intelligence

An agent without memory makes the same mistakes forever.

11
Memory — Learning Across Conversations

File-based memory, 4-type taxonomy, LLM recall, staleness

 12
Extensibility — Skills and Hooks

Two-phase skill loading, lifecycle hooks, snapshot security
Part 5

The Interface

Everything the user sees passes through this layer.

13
The Terminal UI

Custom Ink fork, rendering pipeline, double-buffer, pools

 14
Input and Interaction

Key parsing, keybindings, chord support, vim mode
Part 6

Connectivity

The agent reaches beyond localhost.

15
MCP — The Universal Tool Protocol

8 transports, OAuth for MCP, tool wrapping

 16
Remote Control and Cloud Execution

Bridge v1/v2, CCR, upstream proxy
Part 7

Performance Engineering

Making it all fast enough that humans don't notice the machinery.

17
Performance — Every Millisecond and Token Counts

Startup, context window, prompt cache, rendering, search

 18
Epilogue — What We Learned

The 5 architectural bets, what transfers, where agents are heading

The 10 Patterns That Make It Work

1
AsyncGenerator as agent loop — yields Messages, typed Terminal return, natural backpressure and cancellation
2
Speculative tool execution — start read-only tools during model streaming, before the response completes
3
Concurrent-safe batching — partition tools by safety, run reads in parallel, serialize writes
4
Fork agents for cache sharing — parallel children share byte-identical prompt prefixes, saving ~95% input tokens
5
4-layer context compression — snip, microcompact, collapse, autocompact — each lighter than the next
6
File-based memory with LLM recall — Sonnet side-query selects relevant memories, not keyword matching
7
Two-phase skill loading — frontmatter only at startup, full content on invocation
8
Sticky latches for cache stability — once a beta header is sent, never unset mid-session
9
Slot reservation — 8K default output cap, escalate to 64K on hit (saves context in 99% of requests)
10
Hook config snapshot — freeze at startup to prevent runtime injection attacks