Source Ledger — Chapter 1: Context Engineering

Primary source (the book)

• Source PDF: source-pdfs/01-chapter-01.pdf (21 pages)
• Extracted source: extracted-chapters/01-chapter-01.md (cleaned) and extracted-chapters/01-chapter-01.txt (raw, form-feed page boundaries preserved)
• Extraction tool: pdftotext -layout -enc UTF-8 (Poppler, shipped with Git for Windows)
• OCR needed: No — extraction was clean text.

Enrichment sources

The lesson silently incorporates material from two external Anthropic publications. Per project convention, no inline > Source: or > Enrichment — ... labels appear in the learner-facing lesson — the labels caused visual confusion. This source ledger is the single source of provenance: every per-section mapping below tells you which paragraphs came from the book, which from Anthropic, and which were authored as pedagogical scaffolding for this training.

• [E1] Anthropic engineering blog — "Effective Context Engineering for AI Agents" — https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
• [E2] Anthropic cookbook — "Context Engineering: Memory, Compaction, and Tool Clearing" — https://platform.claude.com/cookbook/tool-use-context-engineering-context-engineering-tools

Pedagogical enrichment by the training author

The following additions are not from the book and not from Anthropic — they are pedagogical material written for this training. They are inventoried here so a reviewer can audit them separately. No inline labels are placed in the learner-facing lesson; only the > Analogy — ... callouts carry an in-lesson label.

• Newcomer preface (## Before we start — agent, prompt, and context in plain language). Defines LLM, prompt, agent, harness, context, and context window in plain English for readers new to agent engineering.
• Per-section analogies. Eleven > Analogy — ... callouts: one per numbered lesson section (§1–§6), one per Strategy sub-section (§4.1–§4.4), one at the top of §4 setting up the running "kitchen" analogy, and one closing whole-chapter analogy.
• Whole-chapter analogy (## The whole chapter in one image — the long-shift chef). A sustained restaurant-kitchen analogy that re-frames the chapter's six sections for less-technical readers.
• Four SVG diagrams authored for this training (not reproduced from the book's figures, which we do not have rights to):
• Figure P.1 — "What's in the context window?" (preface).
• Figure 1.A — "Context growth across turns" (§2).
• Figure 1.B — "The four strategies at a glance" (§4 intro).
• Figure 1.C — "The Goldilocks scale for system prompts" (§5).
• Each figure has a figcaption that explicitly notes it is pedagogical and not from the book.
• Practical exercise — "Drive context engineering in Claude Code." A ~30–45 minute hands-on walkthrough that takes the learner through Write / Select / Compress / Isolate plus a Goldilocks-zone sub-agent prompt rewrite, on a small sandbox project the learner creates locally. Includes seed file contents, step-by-step commands, expected outcomes, reflection prompts, and a success checklist. Sandbox project is created by the learner outside the training repo; nothing in the exercise modifies the training repo itself.

Quiz items and learning objectives remain grounded in the book chapter and the labeled Anthropic enrichment sources — none of the pedagogical analogies, diagrams, or exercise steps are themselves assessed.

Objective → Source Mapping

Lesson Section → Source Mapping

Enrichment section → source mapping

Quiz Items → Source Mapping

Figures Referenced In Source (not reproduced in training)

Unsupported Or Unclear Items

Optional Enrichment

None added in this unit. All lesson content is grounded in the chapter source.

Source Ledger — Chapter 2: The Gist of Claude Code

Primary source (the book)

• Source PDF: source-pdfs/02-chapter-02.pdf
• Extracted source: extracted-chapters/02-chapter-02.txt (raw, form-feed page boundaries preserved)
• Extraction tool: pdftotext -layout -enc UTF-8 (Poppler, shipped with Git for Windows)
• OCR needed: No — extraction was clean text.

Enrichment sources

The lesson silently incorporates material from three official Anthropic documentation pages. Per project convention, no inline > Source: or > Enrichment — ... labels appear in the learner-facing lesson — the labels caused visual confusion in Chapter 1 and were dropped. This source ledger is the single source of provenance: every per-section mapping below tells you which paragraphs came from the book, which from Anthropic docs, and which were authored as pedagogical scaffolding for this training.

• [E1] Anthropic docs — How Claude remembers your project — https://code.claude.com/docs/en/memory
• [E2] Anthropic docs — Connect Claude Code to tools via MCP — https://code.claude.com/docs/en/mcp
• [E3] Anthropic docs — Configure permissions — https://code.claude.com/docs/en/permissions
• [E4] Anthropic docs — Choose a permission mode — https://code.claude.com/docs/en/permission-modes (added on the post-launch audit pass — needed to accurately describe plan-mode entry/exit and the approval flow)
• [E5] Anthropic docs — Settings — https://code.claude.com/docs/en/settings (added on the post-launch audit pass — used in the §2 memory-vs-settings callout to cite the actual settings precedence chain)
• [E6] Anthropic docs — Commands — https://code.claude.com/docs/en/commands (added on the post-launch audit pass — used to confirm canonical slash-command names like /model singular and to confirm /exit-plan-mode is not a documented command)

The user explicitly asked for enrichment "only where needed — do not overcomplicate." Three sources is intentional: it's enough to cover the chapter's three load-bearing topics (memory, MCP, permissions) with depth the book doesn't have, without adding noise.

Pedagogical enrichment by the training author

The following additions are not from the book and not from Anthropic — they are pedagogical material written for this training. They are inventoried here so a reviewer can audit them separately. No inline labels are placed in the learner-facing lesson; only the > Analogy — ... callouts carry an in-lesson label.

• Newcomer preface (## Before we start — Claude Code, MCP, plan mode, and spec-driven design in plain language). Defines Claude Code, CLAUDE.md, MCP, plan mode, and spec-driven design in plain English for readers new to agent engineering.
• Per-section analogies. Seven > Analogy — ... callouts: one per numbered lesson section (§1 hotel check-in, §2 house rules on the fridge, §3 hotel keycard, §4 USB devices, §5 binder tabs, §6 blueprint), plus one closing whole-chapter analogy.
• Whole-chapter analogy (## The whole chapter in one image — onboarding a new contractor). A sustained "new contractor on site" analogy that re-frames the chapter's six sections for less-technical readers.
• Three SVG diagrams authored for this training (not reproduced from the book's figures, which we do not have rights to):
• Figure P.1 — "The four things Chapter 2 wires up around Claude Code" (preface): memory, MCP, plan mode, permission gate.
• Figure 2.A — "CLAUDE.md scope ladder" (§2): managed → user → project → local with load order arrow.
• Figure 2.B — "Every tool call passes through the gate" (§3): the deny → ask → allow evaluation flow.
• Each figure has a figcaption that explicitly notes it is pedagogical and not from the book.
• Practical exercise — "Drive the Chapter 2 setup in Claude Code." A ~30–45 minute hands-on walkthrough that takes the learner through /init, hand-editing CLAUDE.md with conventions, exercising all three permission-prompt options, plan-mode-driven spec writing, implementation against the spec via @ reference, optional MCP install with claude mcp add ... -s user, and a continuity check across /compact / /clear / /exit. Built on a Linkroll sandbox project (a Python stdlib CLI) the learner creates locally. Deliberately swapped from the book's Next.js / HookHub stack to keep the prerequisite footprint small (Python is on most machines; Node is gated to an optional step).
• Sandbox swap rationale. The book's HookHub project requires Node, npx, npm permissions, and a Next.js scaffolding pass before the learner reaches the Claude Code mechanics. The Chapter 2 exercise keeps the focus on the Claude Code mechanics by using a Python stdlib CLI instead — same lessons, fewer install steps. Learners who want the full HookHub experience can follow the book's setup directly; nothing in the training contradicts it.

Quiz items and learning objectives remain grounded in the book chapter and the labeled Anthropic enrichment sources — none of the pedagogical analogies, diagrams, or exercise steps are themselves assessed.

Objective → Source Mapping

Lesson Section → Source Mapping

Quiz Items → Source Mapping

Figures Referenced In Source (not reproduced in training)

Unsupported Or Unclear Items

Optional Enrichment

None added beyond the three labeled enrichment sources. The user's explicit guidance was to keep enrichment minimal and "only where needed."

Source Ledger — Chapter 3: A Tour of Essential Commands

Primary source (the book)

• Source PDF: source-pdfs/03-chapter-03.pdf (45 form-feed pages in the extraction)
• Extracted source: extracted-chapters/03-chapter-03.md (cleaned, with <!-- page N --> markers) and extracted-chapters/03-chapter-03.txt (raw, form-feed page boundaries preserved)
• Extraction tool: pdftotext -layout -enc UTF-8 (Poppler, shipped with Git for Windows)
• OCR needed: No — extraction was clean text.

Enrichment sources

The lesson silently incorporates material from the official Anthropic documentation, the Anthropic engineering blog, the Anthropic news feed, the Anthropic cookbook, the Claude pricing page, and one outside post that the book itself cites (LangChain on CAIR). Per project convention, no inline > Source: or > Enrichment — ... labels appear in the learner-facing lesson — the labels caused visual confusion in Chapter 1 and were dropped. This source ledger is the single source of provenance: every per-section mapping below tells you which paragraphs came from the book, which from labelled enrichment, and which were authored as pedagogical scaffolding for this training.

• [E1] Anthropic docs — Settings — https://code.claude.com/docs/en/settings
• [E2] Anthropic docs — Commands — https://code.claude.com/docs/en/commands
• [E3] Anthropic docs — Hooks — https://code.claude.com/docs/en/hooks
• [E4] Anthropic docs — How Claude remembers your project — https://code.claude.com/docs/en/memory
• [E5] Anthropic docs — Checkpointing — https://code.claude.com/docs/en/checkpointing
• [E6] Anthropic docs — Extend Claude with skills — https://code.claude.com/docs/en/skills
• [E7] Anthropic docs — VS Code & Cursor extension — https://code.claude.com/docs/en/vs-code
• [E8] Anthropic engineering — Equipping agents for the real world with Agent Skills — https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills
• [E9] Anthropic engineering — Best practices for Claude Code — https://www.anthropic.com/engineering/claude-code-best-practices
• [E10] Anthropic news — How Anthropic teams use Claude Code — https://www.anthropic.com/news/how-anthropic-teams-use-claude-code
• [E11] Anthropic cookbook — Introduction to Claude Skills — https://platform.claude.com/cookbook/skills-notebooks-01-skills-introduction
• [E12] Anthropic cookbook — Building custom Skills for Claude — https://platform.claude.com/cookbook/skills-notebooks-03-skills-custom-development
• [E13] Claude pricing page — https://claude.com/pricing
• [E14] LangChain — The Hidden Metric That Determines AI Product Success — https://blog.langchain.com/the-hidden-metric-that-determines-ai-product-success/

This count is larger than Chapters 1 and 2 because Chapter 3 is the book's "everything you'll touch daily" chapter — settings, commands, hooks, memory, checkpoints, and Skills — and every one of those surfaces has materially changed in Anthropic's docs since the book went to print. Enrichment is used to correct and update the book rather than to add unrelated material.

Pedagogical enrichment by the training author

The following additions are not from the book and not from Anthropic — they are pedagogical material written for this training. They are inventoried here so a reviewer can audit them separately. No inline labels are placed in the learner-facing lesson; only the > Analogy — ... callouts carry an in-lesson label.

• Newcomer preface (## Before we start — billing, hooks, checkpoints, and Skills in plain language). Defines billing modes, hook, checkpoint, and Skill in plain English for readers new to agent engineering.
• Per-section analogies. Seven > Analogy — ... callouts: one per numbered lesson section (§1 three ways to buy electricity for the workshop, §2 the control panel and the wall plates, §3 the safety interlocks on a workshop press, §4 the workshop's notebooks, §5 the press-the-button undo on a workbench, §6 the workshop's jigs), plus one closing whole-chapter analogy (the workshop tour).
• Whole-chapter analogy (## The whole chapter in one image — the workshop tour). A sustained workshop analogy that re-frames the chapter's six sections — billing, control panel, interlocks, notebooks, camera, jigs — for less-technical readers.
• Two SVG diagrams authored for this training (not reproduced from the book's figures, which we do not have rights to):
• Figure P.1 — "The six surfaces this chapter wires up" (preface): billing & auth, slash commands, hooks, memory, rewind/checkpoints, Skills, arranged around the Claude Code core.
• Figure 3.A — "CAIR — and where /rewind moves the needle" (§5): the Value / (Risk × Correction) formula with an arrow showing that /rewind lowers Correction and thereby raises CAIR.
• Each figure has a figcaption that explicitly notes it is pedagogical and not from the book.
• Practical exercise — "Drive every surface in this chapter." A ~30–45 minute hands-on walkthrough that takes the learner through a fresh ~/cct-ch3-exercise/ sandbox: settings hot-reload and a deny rule, three-tier memory (project / user / auto-memory), building a Stop hook and demonstrating exit-2-blocks-vs-exit-1-doesn't, /rewind for code-only restore and confirming it can't undo bash side effects, and authoring a .claude/skills/commit-summary/SKILL.md with allowed-tools and !-injection. Includes a success checklist, reflection prompts, and common pitfalls. Sandbox is created outside the training repo; nothing in the exercise modifies the training repo itself.

Quiz items and learning objectives remain grounded in the book chapter and the labelled enrichment sources — none of the pedagogical analogies, diagrams, or exercise steps are themselves assessed.

Objective → Source Mapping

Lesson Section → Source Mapping

Enrichment section → source mapping

Quiz Items → Source Mapping

Figures Referenced In Source (not reproduced in training)

Unsupported Or Unclear Items

Optional Enrichment

• [E11] Anthropic cookbook — Introduction to Claude Skills and [E12] Building custom Skills for Claude. Runnable notebooks that reproduce the Skills surface on the Anthropic API side (rather than the Claude Code CLI side). Useful for advanced learners who want to author Skills that are portable between Claude Code and Anthropic-API-driven agent harnesses. Linked in Further Reading but not required for the chapter quiz or the practical exercise.
• [E9] Best practices for Claude Code and [E10] How Anthropic teams use Claude Code. Two longer-form posts that reinforce the chapter's framings — hooks as deterministic verification, CLAUDE.md bootstrapping conventions — with internal Anthropic adoption examples. Linked in Further Reading; not assessed.

Source Ledger — Chapter 4: Extending Claude Code with MCP Servers and Plugins

Primary source (the book)

• Source PDF: source-pdfs/04-chapter-04.pdf (45 form-feed pages in the extraction)
• Extracted source: extracted-chapters/04-chapter-04.md (cleaned, with <!-- page N --> markers) and extracted-chapters/04-chapter-04.txt (raw, form-feed page boundaries preserved)
• Extraction tool: pdftotext -layout -enc UTF-8 (Poppler, shipped with Git for Windows)
• OCR needed: No — extraction was clean text.

Enrichment sources

The lesson silently incorporates material from the official Model Context Protocol specification (now hosted by the Linux Foundation), the official Claude Code MCP and plugin documentation, the Anthropic news feed, the Anthropic engineering blog, Cloudflare's CodeMode posts and Agents SDK reference, and the official MCP servers registry and the Claude Code plugin marketplace repo. Per project convention, no inline > Source: or > Enrichment — ... labels appear in the learner-facing lesson — the labels caused visual confusion in Chapter 1 and were dropped. This source ledger is the single source of provenance: every per-section mapping below tells you which paragraphs came from the book, which from labelled enrichment, and which were authored as pedagogical scaffolding for this training.

• [E1] MCP spec — Introduction — https://modelcontextprotocol.io/introduction
• [E2] MCP spec — Architecture — https://modelcontextprotocol.io/docs/learn/architecture
• [E3] MCP spec — Transports — https://modelcontextprotocol.io/specification/2025-11-25/basic/transports
• [E4] MCP spec — Tools primitive — https://modelcontextprotocol.io/specification/2025-11-25/server/tools
• [E5] MCP spec — Resources primitive — https://modelcontextprotocol.io/specification/2025-11-25/server/resources
• [E6] MCP spec — Prompts primitive — https://modelcontextprotocol.io/specification/2025-11-25/server/prompts
• [E7] Anthropic docs — Connect Claude Code to tools via MCP — https://code.claude.com/docs/en/mcp
• [E8] Anthropic docs — Connect to MCP servers quickstart — https://code.claude.com/docs/en/mcp-quickstart
• [E9] Anthropic docs — Create plugins — https://code.claude.com/docs/en/plugins
• [E10] Anthropic docs — Plugins reference — https://code.claude.com/docs/en/plugins-reference
• [E11] Anthropic docs — Plugin marketplaces — https://code.claude.com/docs/en/plugin-marketplaces
• [E12] Anthropic docs — Discover plugins — https://code.claude.com/docs/en/discover-plugins
• [E13] Anthropic news — Introducing the Model Context Protocol — https://www.anthropic.com/news/model-context-protocol
• [E14] Anthropic news — Donating MCP and establishing the Agentic AI Foundation — https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation
• [E15] Anthropic engineering — Code execution with MCP: Building more efficient agents — https://www.anthropic.com/engineering/code-execution-with-mcp
• [E16] Anthropic engineering — Effective context engineering for AI agents — https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
• [E17] Anthropic engineering — Writing effective tools for AI agents — https://www.anthropic.com/engineering/writing-tools-for-agents
• [E18] Anthropic engineering — Equipping agents for the real world with Agent Skills — https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills
• [E19] Cloudflare blog — Code Mode: the better way to use MCP — https://blog.cloudflare.com/code-mode/
• [E20] Cloudflare blog — Code Mode: give agents an entire API in 1,000 tokens — https://blog.cloudflare.com/code-mode-mcp/
• [E21] Cloudflare Agents SDK — CodeMode reference — https://developers.cloudflare.com/agents/api-reference/codemode/
• [E22] Official MCP servers registry — https://registry.modelcontextprotocol.io/
• [E23] Official MCP reference servers — https://github.com/modelcontextprotocol/servers
• [E24] Claude Code official plugin marketplace — https://github.com/anthropics/claude-code/blob/main/.claude-plugin/marketplace.json

This count is larger than Chapter 3's because Chapter 4's surfaces have all moved materially since the book went to print: MCP governance was donated to the Linux Foundation in December 2025 ([E14]); Anthropic published a first-party parallel to Cloudflare's CodeMode in November 2025 ([E15]); the plugin docs, plugin marketplace, and /plugin UI continue to evolve; and the public MCP registry ([E22]) did not exist when the book was written. Enrichment is used to correct and update the book rather than to add unrelated material.

Pedagogical enrichment by the training author

The following additions are not from the book and not from Anthropic or the MCP spec — they are pedagogical material written for this training. They are inventoried here so a reviewer can audit them separately. No inline labels are placed in the learner-facing lesson; only the > Analogy — ... callouts carry an in-lesson label.

• Newcomer preface (## Before we start — MCP, hosts/clients/servers, and plugins in plain language). Defines MCP, host, MCP server, MCP client, plugin, and marketplace in plain English for readers new to agent engineering, with the governance update folded in.
• Per-section analogies. Eight > Analogy — ... callouts, one per numbered lesson section: §1 the universal travel adapter; §2 a restaurant pass; §3 plugging in a USB device; §4 three drawers in your toolbox (rewritten from the original "house keys / office keys / visitor pass" framing after the post-build audit re-aligned §4 to the canonical local/project/user scope model); §5 a desk piled with manuals you'll never open today; §6 a walkie-talkie game of telephone; §7 from dictation to writing code; §8 an app store with a code-review pane.
• Whole-chapter analogy (## The whole chapter in one image — the universal cable). A sustained workbench/apprentice analogy that re-frames the chapter's eight sections — protocol, three roles, install, scope, context, limitations, code-against-MCP, plugins — for less-technical readers.
• Four SVG diagrams authored for this training (the book's figures are not reproduced — we do not have rights):
• Figure P.1 — "MCP at a glance" (preface): host with three internal MCP clients, each connected one-to-one to a separate MCP server.
• Figure 4.A — "The integration problem — and what MCP changes" (§1): side-by-side N×M (16 edges) vs N+M (8 edges) comparison.
• Figure 4.B — "Context window — same project, two configurations" (§5): stacked horizontal bar chart of context allocation before (~20% MCP) and after (~2.4% MCP) --strict-mcp-config.
• Figure 4.C — "Ping-pong vs single-shot" (§7): traditional MCP round-trip loop vs code-against-MCP single-execution shape.
• Each figure has a figcaption that explicitly notes it is pedagogical and not from the book.
• Conceptual activity — "Audit your current MCP setup." Ten-minute audit on the learner's own project: /mcp + /context + per-server scope, secrets, and necessity checks, plus a clean-run startup command sketch. Stretch task: design a project-shaped plugin.
• Practical exercise — "Drive MCP scope, context, and plugins on a sandbox project." A ~30–40 minute hands-on walkthrough that takes the learner through a fresh ~/cct-ch4-exercise/ sandbox: baseline /mcp + /context, add Context7 at project scope with claude mcp add --scope project (explicit --scope project is required — claude mcp add defaults to local scope which writes to ~/.claude.json, not .mcp.json), optionally add Tavily at user scope, run a strict scoped session with --mcp-config + --strict-mcp-config and measure the context drop, install and verify a plugin from the demo Claude Code marketplace at anthropics/claude-code (distinct from the auto-loaded claude-plugins-official marketplace), then /reload-plugins and tear-down. Includes a success checklist, reflection prompts, and common pitfalls. Sandbox is created outside the training repo; nothing in the exercise modifies the training repo itself.

Quiz items and learning objectives remain grounded in the book chapter and the labelled enrichment sources — none of the pedagogical analogies, diagrams, or exercise steps are themselves assessed.

Objective → Source Mapping

Lesson Section → Source Mapping

Unsupported / Pedagogical-Only Claims

The following are statements in the learner-facing lesson that are not from the book and not directly from the labelled enrichment. They are listed so a reviewer can audit them in isolation.

Quiz Item → Source Mapping

Drift / Corrections Applied

Places where the book is out of date or partly wrong, and what the lesson does about it.

PDF page-number caveat

Page references in this ledger are based on pdftotext form-feed boundaries (the Chapter 4 PDF extracts to 45 form-feed pages), not printed book page numbers. The printed book may number these differently. Confidence ratings are based on PDF-page positions; cross-check with the printed book if exact pagination is required.

Source Ledger — Chapter 5: Automating Your Development Workflow with Claude Code and GitHub

Primary source (the book)

• Source PDF: source-pdfs/05-chapter-05.pdf
• Extracted source: extracted-chapters/05-chapter-05.md (cleaned, with approximate <!-- page N --> markers — 8 of them) and extracted-chapters/05-chapter-05.txt (raw extraction)
• Extraction tool: pdftotext -layout -enc UTF-8 (Poppler, shipped with Git for Windows)
• OCR needed: No — extraction was text, but see the PDF page-number caveat at the end. The Chapter 5 extraction lacked clean form-feed page boundaries, so page markers and references in this ledger are approximate.
• Book's three main sections: "Installing and configuring the Claude Code GitHub integration" (pp. ~1–4), "Using Claude Code to resolve GitHub issues" (pp. ~4–6), and "Adding repository context with CLAUDE.md" (pp. ~7–8).

Enrichment sources

The lesson silently incorporates material from the official Claude Code documentation (GitHub Actions, code review, authentication, best practices, headless mode, the Claude Agent SDK, and memory/CLAUDE.md), Anthropic's blog, the anthropics/claude-code-action GitHub repository (its example workflows and security doc), and the official GitHub Actions documentation (workflows, events, secrets, and the GitHub-App-vs-OAuth-app distinction). Per project convention, no inline > Source: or > Enrichment — ... labels appear in the learner-facing lesson — the labels caused visual confusion in Chapter 1 and were dropped. This source ledger is the single source of provenance: every per-section mapping below tells you which paragraphs came from the book, which from labelled enrichment, and which were authored as pedagogical scaffolding for this training.

• [E1] Anthropic docs — Claude Code GitHub Actions — https://code.claude.com/docs/en/github-actions
• [E2] Anthropic docs — Code review — https://code.claude.com/docs/en/code-review
• [E3] Anthropic docs — Authentication / long-lived token — https://code.claude.com/docs/en/authentication
• [E4] Anthropic docs — Claude Code best practices — https://code.claude.com/docs/en/best-practices
• [E5] Anthropic docs — Headless mode — https://code.claude.com/docs/en/headless
• [E6] Anthropic docs — Claude Agent SDK overview — https://code.claude.com/docs/en/agent-sdk/overview
• [E7] Anthropic docs — Memory / CLAUDE.md — https://code.claude.com/docs/en/memory
• [E8] Anthropic blog — How Anthropic teams use Claude Code — https://claude.com/blog/how-anthropic-teams-use-claude-code
• [E9] GitHub Action — anthropics/claude-code-action repo — https://github.com/anthropics/claude-code-action
• [E10] GitHub Action — example workflows — https://github.com/anthropics/claude-code-action/tree/main/examples
• [E11] GitHub Action — security model — https://github.com/anthropics/claude-code-action/blob/main/docs/security.md
• [E12] GitHub docs — About workflows — https://docs.github.com/en/actions/concepts/workflows-and-actions/about-workflows
• [E13] GitHub docs — Events that trigger workflows — https://docs.github.com/en/actions/reference/workflows-and-actions/events-that-trigger-workflows
• [E14] GitHub docs — Using secrets in GitHub Actions — https://docs.github.com/en/actions/how-tos/write-workflows/choose-what-workflows-do/use-secrets
• [E15] GitHub docs — GitHub Apps vs OAuth apps — https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/differences-between-github-apps-and-oauth-apps

Enrichment is unusually load-bearing in this chapter because the GitHub-integration surface has moved materially since the book went to print: the action GA'd to @v1 (the book shows @beta), the beta mode: "tag" / mode: "agent" vocabulary and inputs were removed in favour of a single auto-detecting action, the branch name is now a configurable input whose default differs from the book's slash form, the action's example claude.yml listens on more events than the book shows (while the docs' inline "basic workflow" shows fewer), and the action's default behaviour (push-a-branch-and-PR-link, no auto-merge) needs reconciling with the book's "Claude creates a pull request" narrative. The enrichment is used primarily to correct and update the book — see the Drift / Corrections Applied table, which is the most important section of this ledger for Chapter 5. A 2026-06-14 accuracy re-audit (see the drift table) softened several over-claims: the workflow is presented as representative, not canonical; gh is useful, not a required prerequisite for /install-github-app; the two-template chooser and claude-code-review.yml are framed as book-era rather than guaranteed current installer output; the branch suffix is framed as a configurable default; and a dated June-15-2026 subscription-billing caveat was added.

Pedagogical enrichment by the training author

The following additions are not from the book and not from Anthropic or GitHub docs — they are pedagogical material written for this training. They are inventoried here so a reviewer can audit them separately. No inline labels are placed in the learner-facing lesson; only the > Analogy — ... callouts carry an in-lesson label.

• Newcomer preface (## Before we start — GitHub Actions, workflows, and two kinds of auth in plain language). Defines GitHub Actions, event, workflow, job, step, action (the reusable unit), runner, secret, and the two-credentials distinction (GitHub App vs model credential) in plain English for readers new to CI/CD, plus a smallest-well-formed-workflow YAML example and a note on the issue/PR objects. Grounded in [E12]–[E15] and [E9]; the two-credentials framing is the chapter's central conceptual scaffold.
• Per-section analogies. Seven > Analogy — ... callouts, one per numbered lesson section: §1 the contractor who works after hours; §2 the dispatch desk (event = call, workflow = standing instruction sheet, runner = dispatched truck, action = specialist, two badges = two credentials); §3 onboarding a new hire (gh login = front-desk ID, App = building badge, model credential = payroll, secret store = locked drawer); §4 the eager intern and the load-bearing label; §5 everyone gets a photocopy of the blueprints; §6 the runbook on the wall; §7 the QA bench with its own checklist.
• Whole-chapter analogy (## The whole chapter in one image — the contractor with a key to the shop). A sustained contractor/after-hours analogy that re-frames the chapter's seven sections — install, architecture, the break, branch-per-issue, the CLAUDE.md fix, and the review gate — for less-technical readers.
• Four SVG diagrams authored for this training (the book's figures are not reproduced — we do not have rights):
• Figure P.1 — "Anatomy of a GitHub Actions run" (preface): event → workflow → job-on-runner → steps → result, with a note that secrets are referenced, never written.
• Figure 5.A — "The Claude-on-GitHub loop" (§2): @claude comment → claude.yml → ephemeral runner → claude-code-action@v1 → Claude Code (headless, Agent SDK), with the two independent credentials feeding in and the human-merges-not-Claude endpoint.
• Figure 5.B — "Why the rename broke" (§4): local variable → JSON payload → third-party API, before (keys match, accepted) vs after the rename (required key missing, rejected).
• Figure 5.C — "Same issue, two runs" (§6): Run 1 (no CLAUDE.md, broken integration) vs Run 2 (committed CLAUDE.md with the contract gotcha, correct change), side by side.
• Each figure has a figcaption that explicitly notes it is pedagogical and not from the book.
• "Interactive vs automated" comparison table (§1). Six-row table (where it runs / what starts it / who watches / permission prompts / course-correction / the safety net) contrasting Chapters 1–4's interactive use with this chapter's unattended use. Pedagogical synthesis; the headless "process terminates at a permission boundary" row is grounded in [E5].
• Conceptual activity — "Write the CLAUDE.md lines that would stop a 2 a.m. mistake." Ten-minute individual exercise: list 3–5 load-bearing facts an autonomous agent would get wrong, write the single CLAUDE.md line for each, decide which need hard enforcement (test/hook) vs advisory context, and trim to 8–10 lines. Includes a stretch task sketching a PR-review workflow (a learner-named copy of one of the action's pr-review-*.yml examples) with one --system-prompt line and one --allowedTools "Bash(…)" entry.
• Practical exercise — "Drive the autonomous loop and prove that context fixes it." A ~35–45 minute hands-on walkthrough with two tracks: Track A wires the real GitHub integration (/install-github-app, the App, the model credential, @claude on an issue, review the claude/issue-… branch without merging); Track B reproduces the chapter's central finding entirely locally with no GitHub account — a tiny repo with a load-bearing payload key, run claude -p headless (the same non-interactive mode the Action uses) without CLAUDE.md (reproduce the break), then with CLAUDE.md (fix it), then a pytest contract check that passes on the good change and fails on the stashed broken one. Includes a success checklist and common pitfalls. Sandbox is created at ~/cct-ch5-lab/, outside the training repo.

Quiz items and learning objectives remain grounded in the book chapter and the labelled enrichment sources — none of the pedagogical analogies, diagrams, the comparison table, the activity, or the exercise steps are themselves assessed.

Objective → Source Mapping

Lesson Section → Source Mapping

Unsupported / Pedagogical-Only Claims

The following are statements in the learner-facing lesson that are not from the book and not directly from the labelled enrichment. They are listed so a reviewer can audit them in isolation.

Quiz Item → Source Mapping

Drift / Corrections Applied

Places where the book is out of date or partly wrong, and what the lesson does about it. This is the most important section for Chapter 5 — the book is materially stale on the GitHub-integration surface, which moved to a GA'd @v1 action after the book went to print. Each row is verified against the current canonical docs ([E1], [E3], [E5], [E9], [E11]). Re-audited 2026-06-14 against examples/claude.yml, action.yml, usage.md, the github-actions / authentication / headless / code-review docs, and the examples/ directory listing — this pass softened several over-claims (representative-not-canonical workflow; gh not a required prerequisite; book-era two-template chooser; configurable branch suffix) and added the gh-prerequisite and June-15-2026 billing rows.

PDF page-number caveat

The Chapter 5 extraction lacked clean form-feed page boundaries, so the cleaned extracted-chapters/05-chapter-05.md uses approximate <!-- page N --> markers (8 of them, hand-placed at section transitions). All page references in this ledger (p. ~N) are therefore approximate and based on those reconstructed boundaries, not on printed book page numbers or reliable form-feed positions. The printed book may number these differently. Cross-check with the printed book if exact pagination is required; the section names ("Installing and configuring the Claude Code GitHub integration," "Using Claude Code to resolve GitHub issues," "Adding repository context with CLAUDE.md") are the more reliable locators.

Source Ledger — Chapter 6: Claude Code Planning and Multi-agent Workflows

Primary source (the book)

• Source PDF: source-pdfs/06-chapter-06.pdf (16 pages)
• Extracted source: extracted-chapters/06-chapter-06.md (cleaned, with <!-- page N --> markers for all 16 pages). There is no usable .txt for this chapter — see the Extraction caveat at the end.
• Extraction tool: none of the usual text extractors worked — the Chapter 6 PDF is image-only (each page is composed of rendered images; pdftotext -layout and pypdf both returned 0 characters). The chapter was extracted by rendering all 16 pages to PNG at 150 DPI with PyMuPDF (fitz) and transcribing them visually into extracted-chapters/06-chapter-06.md. The transcription preserves the book's original wording verbatim (including stale terminology and one page-break artifact in a numbered list).
• Book's main sections (from the extract): "Claude Code planning mode" → "Characteristics of planning mode" → "Benefits of spec-driven development" → "Example: Iterating on the hook marketplace specification" → "Persisting the hook marketplace specification" (pp. 2–7); "Running Claude Code agents in parallel" → "Example: Parallel development in the HookHub project" → "Assigning independent tasks to agents" → "Executing tasks concurrently" → "Reviewing and committing changes" (pp. 8–14); "Summary" (p. 15).

Enrichment sources

The lesson silently incorporates material from the official Claude Code documentation and Anthropic's blog. Per project convention, no inline > Source: or > Enrichment — ... labels appear in the learner-facing lesson — the only in-lesson labelled callouts are the > Analogy — ... boxes. This source ledger is the single source of provenance.

• [E1] Anthropic docs — Permission modes / plan mode — https://code.claude.com/docs/en/permission-modes
• [E2] Anthropic docs — Claude Code best practices (explore-plan-code-commit) — https://code.claude.com/docs/en/best-practices
• [E3] Anthropic docs — Git worktrees — https://code.claude.com/docs/en/worktrees
• [E4] Anthropic docs — Subagents — https://code.claude.com/docs/en/sub-agents
• [E5] Anthropic docs — Agent teams — https://code.claude.com/docs/en/agent-teams
• [E6] Anthropic docs — Common workflows (plan mode) — https://code.claude.com/docs/en/common-workflows#how-to-use-plan-mode (the book's own cited pointer for plan mode)
• [E7] Anthropic docs — Memory / CLAUDE.md — https://code.claude.com/docs/en/memory
• [E8] Anthropic docs — Agents overview (parallel-work surfaces) — https://code.claude.com/docs/en/agents
• [E9] Anthropic docs — Slash commands — https://code.claude.com/docs/en/commands

2026-06-14 accuracy re-audit. An independent audit flagged several over-/under-statements in the multi-agent, worktree, and spec-persistence material. All were verified against the current canonical docs ([E1]–[E9]) and corrected across the lesson, quiz, this ledger, and the training-output mirror. The Anthropic blog ("How Anthropic teams use Claude Code") was removed as an authority for Claude Code behavior — the parallel-sessions claim it supported is now grounded in the best-practices doc ([E2]). See the Drift / Corrections Applied table for the full list.

Unlike Chapter 5, the book is mostly current on this chapter's surface (verified against the canonical docs before authoring — see the Drift / Corrections Applied table). Enrichment is used to (a) complete the picture (the Shift+Tab and --permission-mode plan entry methods alongside the book's /plan; the explore-plan-code-commit framing), (b) name what the book describes only obliquely (Git worktrees — the book's "its own working directory on its own branch, with an independent copy of the codebase" is worktrees in all but name, deferred to "later in this book"), and (c) disambiguate the senses of "multi-agent" — the book leans on terminal instances vs subagents vs agent teams, and the lesson adds that current Claude Code has further parallel-work surfaces (Agent View / claude agents, dynamic workflows, /batch) so the three are taught as an on-ramp, not an exhaustive list.

Pedagogical enrichment by the training author

Not from the book and not from the docs — written for this training, inventoried here for separate audit. No inline labels in the lesson except the > Analogy — ... callouts.

• Newcomer preface (## Before we start — planning, specs, and what "multi-agent" really means). Defines plan mode (read-only), specification / spec-driven development, independent vs dependent tasks, the senses of "multiple agents" (the book's three — terminal instances / subagents / agent teams — plus a pointer that current Claude Code has more: Agent View, dynamic workflows, /batch), and a short Git primer (branch, commit, status/diff/add/commit) for the parallel half. Grounded in [E1]–[E5], [E8], [E9]; the multi-agent disambiguation (and the explicit "this is bigger than three" note) is the chapter's central clarification.
• Per-section analogies. Six > Analogy — ... callouts, one per numbered section: §1 measure twice, cut once; §2 the blueprint before the build; §3 two cooks, one kitchen; §4 laundry-and-dinner vs walls-and-paint; §5 two contractors, two rooms, one key rule; §6 shared bench, separate workshops, and an apprentice.
• Whole-chapter analogy (## The whole chapter in one image — design it, split it, isolate it). A sustained house-renovation analogy threading all six sections (design before hammering → split by non-overlap → run independent crews in lanes → give each crew its own site).
• Four SVG diagrams (the book's figures are screenshots and are not reproduced — we do not have rights, and they're image-only screenshots besides):
• Figure 6.A — "explore → plan → code → commit": explore/plan read-only inside plan mode → committed spec.md (durable context) → approval gate → code/commit; the spec feeds code.
• Figure 6.B — "Two instances, one shared branch": two terminals each scoped to a disjoint file merge cleanly; a warning that overlapping edits → conflict.
• Figure 6.C — "Independent → parallel · Dependent → sequential": two independent lanes that merge vs a define-API→build-frontend chain.
• Figure 6.D — (text table, not SVG) the three-mechanisms comparison (terminal instances / subagents / agent teams). Rendered as a Markdown table, not a diagram.
• Each SVG figcaption explicitly notes it is pedagogical and not from the book.
• Three-mechanisms comparison table (§6). Terminal instances (+ worktrees) vs subagents vs agent teams, by what-it-is / isolation / best-for. Pedagogical synthesis grounded in [E3]/[E4]/[E5].
• Conceptual activity — "Spec it, then split it." Ten-minute individual exercise: write a five-line plan-mode spec for a small feature, decompose into 3–6 tasks, label each independent/dependent, and draw the parallel/sequential run plan (flagging hidden shared-file dependencies). Grounded in §2 and §4.
• Practical exercise — "Plan it read-only, then build it with two agents at once." A ~35–45 min hands-on lab on a framework-free static "linkboard" sandbox (a HookHub stand-in: index.html + two independent stylesheets styles/hero.css and styles/cards.css), created at ~/cct-ch6-lab/ outside the training repo. Part 1 drives plan mode read-only (confirm git status clean while planning) and persists a spec to .claude/linkboard-spec.md; Part 2 runs two claude instances in parallel, each scoped "modify only … / do not modify …" to one stylesheet, then reviews with git status/git diff and commits once; Part 3 (stretch) upgrades to claude --worktree for true isolation and asks the learner to name a colliding task pair. The sandbox deliberately uses no npm/Node (the book's HookHub is Next.js) so every learner can run it.

Quiz items and learning objectives remain grounded in the book chapter and the labelled enrichment; none of the analogies, diagrams, the comparison table, the activity, or the exercise steps are themselves assessed.

Objective → Source Mapping

Lesson Section → Source Mapping

Unsupported / Pedagogical-Only Claims

Statements in the learner-facing lesson that are not from the book and not directly from the labelled enrichment, listed for isolated audit.

Quiz Item → Source Mapping

Drift / Corrections Applied

The book is largely current on this chapter's surface (verified against [E1]–[E9]). The items below are the places the lesson completes, renames, or softens the book — none are book errors of the Chapter-5 magnitude. The 2026-06-14 re-audit added the worktree-caveats, subagent-capabilities, agent-teams-gating, spec-memory-framing, and blog-removed rows below.

Extraction caveat (image-only PDF)

source-pdfs/06-chapter-06.pdf is an image-only PDF — every page is a set of rendered images with no text layer (confirmed: pdftotext -layout and pypdf both returned 0 characters; pages carry 16–21 embedded images each). Standard extraction was therefore impossible. The source-of-truth extracted-chapters/06-chapter-06.md was produced by rendering each page to PNG at 150 DPI (PyMuPDF) and transcribing the images visually. Consequences a reviewer should know:

• Page markers are reliable (the renderer gave clean per-page boundaries), but printed book page numbers are unknown — <!-- page N --> is the PDF page index, not the book's printed page.
• The book's figures are screenshots (terminal/browser captures embedded as images). They are not transcribed pixel-for-pixel and not reproduced in the lesson (we have no rights, and they're bitmaps). Figure captions are preserved in the extract, marked "(screenshot, not transcribed)". The one figure with narrative text baked in (Fig 6.4, the shared-codebase/merge-conflict diagram) had several low-confidence labels marked [unclear] in the extract — none of those uncertain labels are relied on by the lesson (the lesson's §3 claims rest on the clean body prose, not the diagram text).
• Re-transcription, not OCR. No OCR engine (tesseract) or PDF rasterizer (pdftoppm/ghostscript) was available locally; PyMuPDF was installed specifically to render the pages. If exact wording matters for a citation, cross-check against the printed book.

Source Ledger — Chapter 7: Working with Claude Code Subagents

Primary source (the book)

• Source PDF: source-pdfs/07-chapter-07.pdf (57 pages)
• Extracted source: extracted-chapters/07-chapter-07.md (visual transcription, with <!-- page N --> markers for all 57 pages). There is no usable .txt for this chapter — see the Extraction caveat at the end.
• Extraction tool: none of the usual text extractors worked — the Chapter 7 PDF is image-only (each page is composed of rendered images; pdftotext -layout and pypdf both returned 0 characters). The chapter was extracted by rendering all 57 pages to PNG at 150 DPI with PyMuPDF (fitz) into work/07-chapter-07-pages/ and transcribing them visually into extracted-chapters/07-chapter-07.md. The transcription preserves the book's original wording verbatim — including stale terminology (the "Task tool" name) and the creator's misspelled handle ("IndieDevDan" / "IndieDev.com").
• Book's main sections (from the extract): "Introduction to Claude Code subagents" (pp. 2–7); "Configuring the first subagent" via /agents — describe / generate-with-Claude / manual, tool selection, model/visual settings, reviewing the generated code-comedy-carl.md (pp. 8–13); "Testing our subagent" — Fibonacci file, funny review @main.py, spawning two sequential instances (pp. 13–16); "Context flow while using subagents" + "Context windows in action" — the one-prompt-down / one-summary-back model and the 200K-token worked example (pp. 16–20); "Example: Creating a Mermaid diagram subagent" — tool pollution, the two levers (description vs system-prompt body), the untrusted-definition security warning, refining output to return only the diagram code (pp. 20–35); "Scaling with concurrent subagents" — the Infinite Agentic Loop repo, HookHub setup, /infinite, six parallel Hero variations, human selection (pp. 35–48); "Infinite prompt" — the high-order/meta prompt under the hood, four phases, the Agent ("task") tool, agent assignment protocol (pp. 49–56); "Summary" (pp. 56–57).

Enrichment sources

The lesson silently incorporates material from the official Claude Code documentation, Anthropic's engineering blog, the Anthropic cookbook, and one community pattern repository. Per project convention, no inline > Source: or > Enrichment — ... labels appear in the learner-facing lesson — the only in-lesson labelled callouts are the > Analogy — ... boxes. This source ledger is the single source of provenance.

• [E1] Anthropic docs — Subagents — https://code.claude.com/docs/en/sub-agents
• [E2] Anthropic docs — Run agents in parallel / agents overview — https://code.claude.com/docs/en/agents
• [E3] Anthropic docs — Agent teams — https://code.claude.com/docs/en/agent-teams
• [E4] Anthropic docs — Slash commands — https://code.claude.com/docs/en/commands
• [E5] Anthropic docs — Worktrees — https://code.claude.com/docs/en/worktrees
• [E6] Anthropic engineering — How we built our multi-agent research system — https://www.anthropic.com/engineering/multi-agent-research-system
• [E7] Anthropic engineering — Building effective agents — https://www.anthropic.com/engineering/building-effective-agents
• [E8] Anthropic engineering — Effective context engineering for AI agents — https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
• [E9] Anthropic cookbook — Orchestrator-workers / using sub-agents — https://platform.claude.com/cookbook/patterns-agents-orchestrator-workers (and https://platform.claude.com/cookbook/multimodal-using-sub-agents)
• [E10] Community pattern — Infinite Agentic Loop by IndyDevDan / disler — https://github.com/disler/infinite-agentic-loop (MIT; creator's site https://agenticengineer.com, channel https://www.youtube.com/@indydevdan)

The book is largely current on this chapter's surface (subagents had not drifted far between the book's writing and this build — verified against the canonical docs before authoring; see the Drift / Corrections Applied table). Enrichment is used to (a) complete the picture (the frontmatter schema beyond what the book lists, the built-in Explore/Plan agents, the three invocation methods, the broader scope hierarchy); (b) quantify and ground the context-isolation argument (the ~1,000–2,000-token condensed-summary figure and the "attention budget" framing from [E8]; the ~4×/~15× token multipliers and the orchestrator-worker architecture from [E6]; the orchestrator-workers pattern name from [E7]); and (c) correct two genuine book errors (the creator's name/handle and the framing of the Infinite Agentic Loop as merely "the implementation" rather than a community pattern).

Pedagogical enrichment by the training author

Not from the book and not from the docs — written for this training, inventoried here for separate audit. No inline labels in the lesson except the > Analogy — ... callouts.

• Newcomer preface (## Before we start — agents, subagents, context windows, and "meta" prompts). Defines the main agent, a subagent (own system prompt / own isolated context window / selective tool access), a context window and why quality degrades before the ceiling (the attention-budget idea), system prompt vs user prompt, concurrent vs sequential, a "meta"/high-order prompt by analogy to higher-order functions, and where this sits relative to Chapter 6's three senses of "multiple agents." Grounded in [E1], [E8]; the higher-order-functions analogy and the Chapter-6 bridge are the chapter's framing devices.
• Per-section analogies. Seven > Analogy — ... callouts, one per numbered section: §1 the specialist with a sealed brief; §2 filling out the job requisition; §3 the cautious dispatcher; §4 the assistant who hands you a one-page memo; §5 the recipe card and the cook's training; §6 six architects, one brief; §7 the manager who writes the tickets, not the code.
• Whole-chapter analogy (## The whole chapter in one image — delegate, isolate, then multiply). A sustained consulting-partner analogy threading all seven sections (take the meeting / delegate the digging → staff each job deliberately → tune on two dials → run a competition for the biggest decisions).
• Three SVG diagrams (the book's figures are screenshots and are not reproduced — we do not have rights, and they're image-only screenshots besides):
• Figure 7.A — main↔subagent context flow: one prompt down, one condensed summary (~1–2k tokens) back, the subagent's heavy internal tokens never added to the lean main thread.
• Figure 7.B — the two levers: the description (read by Claude to decide when to delegate and to write the task prompt it sends the subagent) vs the system-prompt body (sent only to the subagent → controls internal logic and output format).
• Figure 7.C — the Infinite Agentic Loop fan-out: one spec + count → main agent as orchestrator → a wave of six parallel subagents (via the Agent tool) → many variations → human review and selection; infinite mode plans further waves until context runs out.
• Each SVG figcaption explicitly notes it is "Pedagogical diagram by this training, not from the book."
• Conceptual activity — "Design a subagent on paper." Ten-minute individual exercise: pick a recurring side-task, write the frontmatter (name + trigger-bearing description), apply least privilege to tools (and name what's withheld and why), write one lever-2 body instruction that controls output format, and decide the parallelism phrasing. Grounded in §1/§3/§5.
• Practical exercise — "Build, shape, and parallelize a subagent." A ~35–45 min hands-on lab on a framework-free, stdlib-only Python sandbox (three small files with planted defects — prices.py float-drift, auth.py non-constant-time comparison, slugify.py missing punctuation strip), created at ~/cct-ch7-lab/ outside the training repo. Part 1 creates a least-privilege reviewer with /agents (project scope, generate-with-Claude, read-only tools); Part 2 invokes it on one file and watches context isolation (/context, plus the /agents Running tab and Ctrl+O transcript viewer); Part 3 pulls both levers (edit the body for an output-format change requiring a restart; tighten the description for an emphasis change); Part 4 contrasts the sequential phrasing against an explicit "in parallel / a separate agent for each" phrasing to force concurrency. The sandbox deliberately uses no npm/Node (the book's HookHub is Next.js) so every learner can run it.

Quiz items and learning objectives remain grounded in the book chapter and the labelled enrichment; none of the analogies, diagrams, the activity, or the exercise steps are themselves assessed.

Objective → Source Mapping

Lesson Section → Source Mapping

Unsupported / Pedagogical-Only Claims

Statements in the learner-facing lesson that are not from the book and not directly from the labelled enrichment, listed for isolated audit.

Quiz Item → Source Mapping

Drift / Corrections Applied

The book is largely current on this chapter's surface (verified against [E1]–[E10]). Most items below are places the lesson completes, renames, or softens the book. None reach the Chapter-5 magnitude.

2026-06-14 accuracy re-audit. An independent audit flagged five over-/under-statements about subagent context composition, invocation methods, the Ctrl+R/Cmd+R keyboard claim, the "description is appended to the main system prompt" implementation claim, and the source-boundary framing of the Infinite Agentic Loop / orchestrator-workers / token-cost numbers. All were verified against the current canonical docs ([E1] sub-agents, [E2] agents, agent-view, interactive-mode, cli-reference) and corrected across the lesson, quiz, this ledger, and the training-output mirror. The new rows below (marked 2026-06-14) record each. The book's original wording is preserved verbatim in extracted-chapters/ and is not edited.

Extraction caveat (image-only PDF)

source-pdfs/07-chapter-07.pdf is an image-only PDF — every page is a set of rendered images with no text layer (confirmed: pdftotext -layout and pypdf both returned 0 characters; the image-only check python -c "import pypdf; print(sum(len(p.extract_text() or '') for p in pypdf.PdfReader('source-pdfs/07-chapter-07.pdf').pages))" printed 0). Standard extraction was therefore impossible. The source-of-truth extracted-chapters/07-chapter-07.md was produced by rendering each of the 57 pages to PNG at 150 DPI (PyMuPDF / fitz) into work/07-chapter-07-pages/ and transcribing the images visually. Consequences a reviewer should know:

• Page markers are reliable (the renderer gave clean per-page boundaries), but printed book page numbers are unknown — <!-- page N --> is the PDF page index, not the book's printed page. There is no .txt mirror for this chapter.
• The book's figures are screenshots (terminal / editor / browser captures embedded as images, plus the two architecture diagrams in Figs 7.8 and 7.10). They are not transcribed pixel-for-pixel and not reproduced in the lesson (we have no rights, and they're bitmaps). Figure captions and the gist of each figure are preserved in the extract, marked "[Figure: …]". The page-44 six-variation list carries an explicit transcription-uncertainty note in the extract (small source text); the lesson's six variation names match it.
• The book's stale terms and the creator's misspelling are intentionally preserved verbatim in the extract — the extract retains "task tool," "IndieDevDan," and "Kudos to IndieDev.com" exactly as in the source. Do not edit extracted-chapters/07-chapter-07.md to match the lesson's corrections; it is the verbatim book source-of-truth and is supposed to retain the book's wording. The corrections live only in the lesson, the quiz, this ledger, and the training-output mirror.
• Re-transcription, not OCR. No OCR engine (tesseract) or PDF rasterizer (pdftoppm/ghostscript) was available locally; PyMuPDF was installed specifically to render the pages. If exact wording matters for a citation, cross-check against the printed book.

Source Ledger — Chapter 8: Creating and Customizing Output Styles

Primary source (the book)

• Source PDF: source-pdfs/08-chapter-08.pdf (39 pages)
• Extracted source: extracted-chapters/08-chapter-08.md (visual extraction, with <!-- page N --> markers for all 39 pages). There is no usable .txt for this chapter — see the Extraction caveat at the end.
• Extraction tool: none of the usual text extractors worked — the Chapter 8 PDF is image-only (each page is composed of rendered images; the image-only check python -c "import pypdf; print(sum(len(p.extract_text() or '') for p in pypdf.PdfReader('source-pdfs/08-chapter-08.pdf').pages))" printed 0). The chapter was extracted by rendering all 39 pages to PNG at 150 DPI with PyMuPDF (fitz) into work/08-chapter-08-pages/ and transcribing them visually into extracted-chapters/08-chapter-08.md. Extraction style: to avoid reproducing a copyrighted Packt chapter at length, the explanatory prose is captured as faithful section-by-section summaries, while every heading, code block, command, YAML/JSON, file path, key name, and flag is captured verbatim (these are the load-bearing/functional elements the lesson needs). Treat code/config/paths in the extract as exact; treat prose as a structural summary, and re-open the page images for exact sentence wording.
• Book's main sections (from the extract, in order): "Creating a custom output style with Claude Code" (the /output-style picker; built-in Default/Explanatory/Learning; the user-scoped minimal-bullets.md; "How output styles work" = replaces the software-engineering instructions; pp. 1–6); "Why YAML" + "Creating YAML as an output style" (the project-scoped yaml-concise.md; the YAML task-plan example; pp. 6–13); "Creating an advanced project-level output style" (retro-ASCII_blog.md → HTML page; "Automating file generation" = embedding a ## Workflow instruction; pp. 13–19); "Working with multiple output styles" (launching a second instance; specialized output-style workflows; pp. 19–22); "Customizing the status line in Claude Code" (/statusline; the statusLine settings key + uv run ~/.claude/statusline.py; the minimal statusline.py reading output_style; ANSI color; the extended get_last_user_prompt reading transcript_path; pp. 22–34); "The future of AI coding: a team of specialized agents" (multiple instances by role/output-style; the Neo-Genius start-up-team illustration; naming frontend-engineer/backend-engineer/devops/security-review; pp. 35–38); "Summary" (pp. 38–39).

Enrichment sources

The lesson silently incorporates material from the official Claude Code documentation. Per project convention, no inline > Source: or > Enrichment — ... labels appear in the learner-facing lesson — the only in-lesson labelled callouts are the > Analogy — ... boxes. This source ledger is the single source of provenance.

• [E1] Anthropic docs — Output styles — https://code.claude.com/docs/en/output-styles
• [E2] Anthropic docs — Customize your status line — https://code.claude.com/docs/en/statusline
• [E3] Anthropic docs — Settings — https://code.claude.com/docs/en/settings
• [E4] Anthropic docs — Memory / CLAUDE.md — https://code.claude.com/docs/en/memory
• [E5] Anthropic docs — CLI reference (--append-system-prompt / --system-prompt) — https://code.claude.com/docs/en/cli-reference
• [E6] Anthropic docs — How Claude Code uses prompt caching — https://code.claude.com/docs/en/prompt-caching
• [E7] Anthropic docs — Best practices: run multiple Claude sessions — https://code.claude.com/docs/en/best-practices
• [E8] Anthropic docs — Subagents — https://code.claude.com/docs/en/sub-agents
• [E9] Anthropic docs — Agent teams — https://code.claude.com/docs/en/agent-teams

Unlike Chapter 7 (which was largely current), this chapter's central surface had drifted materially — the book's primary command, /output-style, no longer exists (deprecated v2.1.73, removed v2.1.91), and the built-in style list and the custom-style frontmatter both grew. All facts were verified against the canonical docs before authoring (and the load-bearing pages — [E1] output-styles and [E2] statusline — were fetched directly, not taken from a summary). Enrichment is used to (a) correct the removed /output-style command → /config → Output style; (b) complete the built-in style set (add Proactive), the frontmatter (keep-coding-instructions, force-for-plugin), the third managed-policy scope, and the full status-line JSON schema; (c) clarify the system-prompt mechanics (instructions appended; software-engineering block dropped unless keep-coding-instructions: true) and the contrast with CLAUDE.md / --append-system-prompt / subagents / Skills; and (d) reframe honestly the book's "team of specialized agents" against the documented parallel-work tools (subagents / experimental agent teams).

Pedagogical enrichment by the training author

Not from the book and not from the docs — written for this training, inventoried here for separate audit. No inline labels in the lesson except the > Analogy — ... callouts.

• Newcomer preface (## Before we start — system prompts, output styles, stdin/stdout, and ANSI). Defines system prompt vs user prompt, what an output style and a status line are, stdin/stdout/pipes, JSON vs YAML, frontmatter, ANSI escape codes, and the bridge from Chapter 7 (subagents shape a delegated helper; this chapter reshapes the main session's interface). Grounded in [E1], [E2].
• Per-section analogies. Six > Analogy — ... callouts, one per numbered section: §1 the dress-code card by the door; §2 the script vs. the sticky note; §3 the form vs. the blank page; §4 the note on the order ticket vs. the conveyor belt (a style's workflow instruction is a request, like a note; a hook is the deterministic conveyor belt); §5 the car dashboard; §6 the open-plan office with labeled desks.
• Whole-chapter analogy (## The whole chapter in one image — you're at the mixing board). A sustained producer-at-the-mixing-board analogy threading all six sections (choose the format → wire the channels → light the VU meters → staff the booths).
• Two SVG diagrams (the book's figures are screenshots/illustrations and are not reproduced — we have no rights, and they're image-only besides):
• Figure 8.A — how an output style rewrites the system prompt: three stacked-block columns (Default; custom with keep-coding-instructions: false → software-engineering block removed, custom instructions appended; custom with true → all kept), plus a footnote that CLAUDE.md is not part of the system prompt (added as a user message after it).
• Figure 8.B — the status-line data flow: session JSON → stdin → statusline.py (read, pick fields, ANSI) → stdout → the rendered status bar.
• Each SVG figcaption explicitly notes it is "Pedagogical diagram by this training, not from the book." (See the Diagram-count note below for why this chapter ships two, not three.)
• Conceptual activity — "Audit and design your own output style." Ten-minute individual exercise: spot a repeated re-prompt, pick the right layer (output style vs CLAUDE.md vs --append-system-prompt vs subagent) using the §2 table, draft frontmatter (with a deliberate keep-coding-instructions decision), draft three body rules (+ an optional ## Workflow rule), and choose scope. Grounded in §1/§2/§4.
• Practical exercise — "Reshape the interface: two output styles and a live status line." A ~35–45 min hands-on lab on a framework-free, stdlib-only sandbox (~/cct-ch8-lab/ with one tiny greet.py), outside the training repo. Part 1 selects a built-in style via /config (not the removed /output-style) and runs /clear (or starts a new session) so it takes effect — the lab makes the "read once at session start" rule explicit at every style switch; Part 2 hand-writes a project-scoped minimal-bullets.md (select → /clear → re-ask); Part 3 demonstrates keep-coding-instructions (default-false drops the coding behavior; true keeps it); Part 4 builds a status line manually (a hand-written stdlib statusline.py + a statusLine block in project .claude/settings.json) as the primary, self-contained, reversible path, with the /statusline command presented as a faster alternative that generates a script in global ~/.claude/ and updates settings automatically (no project-settings picker). Uses plain python3 (book uses uv run) so no extra installs are required.

Diagram-count note. This chapter intentionally ships two original SVG diagrams (8.A system-prompt rewrite; 8.B status-line data flow). The §6 "team of specialized instances" idea is conveyed through prose, the comparison table, and the labeled-desks analogy rather than a third SVG, because the honest framing (it's the book's metaphor, not a documented architecture) is better carried in text than in a diagram that might imply it's a first-class feature. Earlier chapters shipped 3–4 diagrams; two is a deliberate choice here, not an omission.

Quiz items and learning objectives remain grounded in the book chapter and the labelled enrichment; none of the analogies, diagrams, the activity, or the exercise steps are themselves assessed.

Objective → Source Mapping

Lesson Section → Source Mapping

Unsupported / Pedagogical-Only Claims

Statements in the learner-facing lesson that are not from the book and not directly from the labelled enrichment, listed for isolated audit.

Quiz Item → Source Mapping

Drift / Corrections Applied

This chapter's central surface had drifted materially since the book — unlike Chapter 7. The book's primary command was removed, and the built-in styles and frontmatter both grew. All items verified against the canonical docs ([E1] output-styles and [E2] statusline fetched directly). The book's original wording is preserved verbatim in extracted-chapters/ and is not edited.

2026-06-15 accuracy re-audit. A follow-up review (verified against [E1] output-styles, [E2] statusline, [E3] settings, [E5] cli-reference) tightened five things across the lesson, quiz, this ledger, and the training-output mirror: (1) every place that switched an output style now makes the /clear-or-new-session step explicit before observing the change (it was stated as a rule but the practical steps implied immediate effect); (2) the embedded-workflow claims were softened from "the style carries out a procedure on every response" to "the style asks Claude to — an instruction, not a guaranteed action — and for must-run steps use a hook/script"; (3) the book's "/statusline spawns a sub-agent" claim was dropped (unsupported by [E2]; the docs say it generates a script in ~/.claude/ and updates settings automatically) and the practical exercise no longer implies a project-settings picker; (4) the settings-precedence summary was corrected from the wrong "managed → user → project → local" to the documented managed → command-line args → local → project → user; (5) the §4 analogy was reworked (rubber-stamp → order-ticket-note vs. conveyor-belt) to carry the nudge-vs-guarantee distinction. The new rows below (marked 2026-06-15) record each. The verbatim extract was not edited.

Extraction caveat (image-only PDF, summarized prose)

source-pdfs/08-chapter-08.pdf is an image-only PDF — every page is a set of rendered images with no text layer (the image-only check printed 0). Standard extraction was impossible. The source-of-truth extracted-chapters/08-chapter-08.md was produced by rendering each of the 39 pages to PNG at 150 DPI (PyMuPDF / fitz) into work/08-chapter-08-pages/ and transcribing the images visually. Consequences a reviewer should know:

• Mixed-fidelity extract. To avoid reproducing a copyrighted Packt chapter at length, the explanatory prose in the extract is captured as faithful section-by-section summaries, while headings, code blocks, commands, YAML/JSON, file paths, key names, and flags are verbatim (these are the functional elements the lesson depends on). Treat code/config/paths as exact; treat prose as a structural summary. If exact sentence wording is needed for a citation, re-open the page images in work/08-chapter-08-pages/.
• Page markers are reliable (clean per-page boundaries), but printed book page numbers are unknown — <!-- page N --> is the PDF page index, not the book's printed page. There is no .txt mirror.
• The book's figures are screenshots/illustrations (terminal/editor/browser captures, plus the "Human–AI collaboration" and "Neo-Genius" illustrations). They are not transcribed pixel-for-pixel and not reproduced in the lesson (we have no rights, and they're bitmaps). Figure captions and the gist are preserved in the extract as [Figure: …] placeholders. The two lesson diagrams are original pedagogical SVGs.
• A few code regions were screenshots (Figs 8.12/8.17 of statusline.py); the same code is given in clean body text on pp. 25–26 and 32–33, which is what the lesson uses. Two prose lines were partly cut by the page fold/UI chrome (the page-18 ## Workflow snippet; the page-10 yaml-concise description: line) — captured as far as legible and noted in the extract.
• Re-transcription, not OCR. No OCR engine or PDF rasterizer was available locally; PyMuPDF was installed specifically to render the pages. If exact wording matters for a citation, cross-check against the printed book.

Source Ledger — Chapter 9: Understanding Agent Skills

Primary source (the book)

• Source PDF: source-pdfs/09-chapter-09.pdf (30 pages)
• Extracted source: extracted-chapters/09-chapter-09.md (visual extraction, <!-- page N --> markers for all 30 pages). There is no usable .txt for this chapter — see the Extraction caveat at the end.
• Extraction tool: the Chapter 9 PDF is image-only (the image-only check python -c "import pypdf; print(sum(len(p.extract_text() or '') for p in pypdf.PdfReader('source-pdfs/09-chapter-09.pdf').pages))" printed 0). Extracted by rendering all 30 pages to PNG at 150 DPI with PyMuPDF (fitz) into work/09-chapter-09-pages/ and transcribing visually. Mixed-fidelity: headings, code, commands, YAML/SKILL.md contents, file paths, key names, flags, and table cells are verbatim; explanatory prose is captured as faithful section-by-section summaries (to avoid reproducing a copyrighted chapter at length). Treat code/config/paths/tables as exact; treat prose as a structural summary, and re-open page images for exact sentence wording.
• Book's main sections (from the extract, in order): "The gist of agent skills" (the HookHub baseline; Scenario 1 styling without skills → prompting directly / the CLAUDE.md-bloat trap; Scenario 2 styling with skills → the brand-guidelines skill from anthropics/skills, installed via the plugin marketplace; progressive context loading; pp. 1–9); "Diving deeper into agent skills" (the git-pushing skill from mhattingpete/claude-skills-marketplace; the smart_commit.sh script; opinionated workflows; "a skill is a packaging mechanism — deterministic scripts, AI calls, or both"; editing When to Use doesn't change selection; enabling automatic approval via settings.local.json; modifying the script to call the Claude CLI (claude -p); breaking the directory structure → recovery; context: fork / agent / disable-model-invocation; pp. 9–24); "Comparing agent skills with other agent primitives" (Skills vs MCP vs subagents vs slash commands; Table 9.1; pp. 25–29); "Summary" (pp. 29–30).

Enrichment sources

The lesson silently incorporates material from the official Claude Code docs and the Anthropic engineering blog. Per project convention, no inline > Source: / > Enrichment — … labels appear in the learner-facing lesson — the only in-lesson labelled callouts are the > Analogy — … boxes. This ledger is the single source of provenance.

Official Claude Code behavior (authoritative):

• [E1] Anthropic docs — Skills — https://code.claude.com/docs/en/skills
• [E2] Anthropic docs — MCP — https://code.claude.com/docs/en/mcp
• [E3] Anthropic docs — Subagents — https://code.claude.com/docs/en/sub-agents
• [E4] Anthropic docs — Commands — https://code.claude.com/docs/en/commands
• [E5] Anthropic docs — Plugins — https://code.claude.com/docs/en/plugins
• [E6] Anthropic Agent SDK — Agent Skills (quickstart) — https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Enrichment / context (NOT official Claude Code behavior — clearly labelled as background):

• [E7] Agent Skills open standard — https://agentskills.io
• [E8] Anthropic engineering — Equipping agents for the real world with Agent Skills — https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills
• [E9] Anthropic engineering — Code execution with MCP / Effective context engineering for AI agents — https://www.anthropic.com/engineering/code-execution-with-mcp, https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
• [E10] Community — LangChain DeepAgents — https://docs.langchain.com/labs/deep-agents/overview
• [E11] Community — claude-skills-marketplace by mhattingpete (Apache-2.0) — https://github.com/mhattingpete/claude-skills-marketplace

The book is broadly current on the skills concept (skills, progressive disclosure, scripts, the primitive comparison all hold), but several specifics had drifted or needed sharpening; all Claude Code behavior was verified against [E1]–[E6] before authoring (and the load-bearing skills page [E1] was fetched directly during a follow-up accuracy pass — see Drift / Corrections Applied). Source-boundary discipline: Claude Code behavior claims rest on [E1]–[E6]; engineering posts, the open standard, LangChain, and community marketplaces ([E7]–[E11]) are used only as enrichment/context and are never presented as official Claude Code behavior. Launch dates and token figures are treated as book/announcement context, not docs-verified facts.

Pedagogical enrichment by the training author

Not from the book and not from the docs — written for this training, inventoried here for separate audit.

• Newcomer preface (## Before we start — skills, "primitives," progressive disclosure, and the CLI). Defines the bridge from Chapter 3 (skills introduced mechanically there; this chapter is the architecture), "primitive," the context window (recap), progressive disclosure (one-line), and claude -p. Grounded in [E1], and Chapters 3/4/7 continuity.
• Per-section analogies. Five > Analogy — … callouts, one per numbered section: §1 the recipe card in the kitchen drawer; §2 the library with a card catalog; §3 the appliance button with a program behind it; §4 the assistant with a playbook who isn't a robot; §5 four tools on one workbench.
• Whole-chapter analogy (## The whole chapter in one image — the well-run workshop). A sustained workshop analogy threading all five sections (don't bury the bench → cards drive machines → good workers don't freeze → right tool, right job).
• Two SVG diagrams (the book's figures are screenshots and are not reproduced):
• Figure 9.A — progressive disclosure in three stages (listing at startup → body on selection, persists in-session → bundled file on demand), with a lean-context panel. figcaption notes selection reads the listing (the description).
• Figure 9.B — a skill as packaging: main agent selects skill → skill runs script → deterministic path or AI path (claude -p) → commit; with the agent-reasoning backstop (recovery possible, not guaranteed) and a "use a hook when a step must run every time" note.
• Each figcaption explicitly notes it is "Pedagogical diagram by this training, not from the book."
• Conceptual activity — "Decide skill, subagent, MCP, or neither." Ten-minute exercise practising the §5 routing judgment + drafting a description. Grounded in §5/[E1].
• Practical exercise — "Build a skill that bundles a script, then make it think." A ~35–45 min framework-free, stdlib-only lab (~/cct-ch9-lab/): build a project-level repo-brief skill with a bundled stats.sh (referenced via ${CLAUDE_SKILL_DIR}), prove selection follows the listing (Part 2), upgrade the script to call claude -p with a fallback (Part 3), and break the path to observe recovery as a capability (Part 4). No npm/Node, no accounts. Distinct from Chapter 3's commit-summary exercise (which taught making a slash-command skill) — Ch9's focuses on scripts, progressive disclosure, and deterministic-vs-AI.

Quiz items and learning objectives remain grounded in the book chapter and the labelled enrichment; none of the analogies, diagrams, the activity, or the exercise steps are themselves assessed.

Objective → Source Mapping

Lesson Section → Source Mapping

Unsupported / Pedagogical-Only Claims

Quiz Item → Source Mapping

Drift / Corrections Applied

The book is broadly current on skills, but a follow-up accuracy pass (verified directly against [E1] skills, plus [E2]–[E6]) tightened several points. The book's original wording is preserved verbatim in extracted-chapters/ and is not edited.

2026-06-15 accuracy pass. Verified against [E1] (fetched directly), [E2] MCP, [E3] subagents, [E4] commands, [E5] plugins, [E6] Agent SDK. Eight adjustments propagated across the lesson, quiz, this ledger, and the training-output mirror. The new rows below record each.

Extraction caveat (image-only PDF, summarized prose)

source-pdfs/09-chapter-09.pdf is an image-only PDF — no text layer (the image-only check printed 0). The source-of-truth extracted-chapters/09-chapter-09.md was produced by rendering each of the 30 pages to PNG at 150 DPI (PyMuPDF / fitz) into work/09-chapter-09-pages/ and transcribing the images visually. Consequences a reviewer should know:

• Mixed-fidelity extract. Explanatory prose is captured as faithful summaries; headings, code, commands, YAML/SKILL.md contents, file paths, key names, flags, and table cells are verbatim. Treat code/config/paths/tables as exact; treat prose as a structural summary. Re-open the page images in work/09-chapter-09-pages/ for exact sentence wording.
• Page markers are reliable, but printed book page numbers are unknown — <!-- page N --> is the PDF page index. There is no .txt mirror.
• The book's figures are screenshots (terminal/editor/browser captures, plus illustrations) and are not reproduced (the two lesson diagrams are original SVGs).
• Table 9.1's first data row was partially cut at the top of page 28 in the render — only the tail of its cells was legible (Skills "…performed", MCP "…services", Subagents "…agents", Slash commands "…short calls"). The remaining eight rows are fully captured. The lesson's consolidated comparison is built from current docs ([E1]–[E4]) rather than the book's table, so this gap does not affect the lesson; cross-check the printed book if the exact first-row wording is needed.
• Re-transcription, not OCR. PyMuPDF was used to render pages; no OCR engine was involved. Cross-check the printed book if exact wording/pagination matters.

Source Ledger — Chapter 10: Using Claude Code Desktop

Primary source (the book)

• Source PDF: source-pdfs/10-chapter-10.pdf (43 pages; page 43 is Packt back-matter promo, not chapter content).
• Extracted source: extracted-chapters/10-chapter-10.md (visual extraction, <!-- page N --> markers; the markers are PDF-page indices, not printed book pages). There is no usable .txt for this chapter — see the Extraction caveat at the end.
• Extraction tool: the Chapter 10 PDF is image-only (the image-only check python -c "import pypdf; print(sum(len(p.extract_text() or '') for p in pypdf.PdfReader('source-pdfs/10-chapter-10.pdf').pages))" printed 0). Extracted by rendering all 43 pages to PNG at 150 DPI with PyMuPDF (fitz) into work/10-chapter-10-pages/ and transcribing visually. Mixed-fidelity: headings, code, commands, file paths, key names, flags, and branch names are verbatim; explanatory prose is captured as faithful section-by-section summaries (to avoid reproducing a copyrighted chapter at length). Treat code/commands/paths/branch names as exact; treat prose as a structural summary, and re-open page images for exact sentence wording.
• Book's main sections (from the extract, in order): "Introducing Claude Code desktop integration and background agents" (pp. 2–3); "Claude Code installation and operating modes: Local versus cloud" — Selecting the workspace folder (Local worktree mode) / Switching to Claude Code web (pp. 3–9); "How Git worktrees enable parallel development" (pp. 9–11); "Orchestrating parallel local and cloud agents" — run Next.js locally / coordinate local + cloud / concurrent feature dev / observe remote branch creation / process research results / worktree layout / preparing to merge (pp. 11–20); "Understanding Git Worktrees in Claude Code" — how Claude uses a worktree / multiple worktrees in parallel (pp. 20–24); "Merging parallel feature branches" — merge into project/hookhub / test before pushing / validate / finalize (pp. 24–30); "Running Claude Code in the cloud via mobile" — review the PR / verify locally (pp. 30–37); "When Parallel Agents Are Counterproductive" — Note/Pro-tip + Parallel Development Checklist (pp. 37–41); "Summary" (pp. 41–42).

Enrichment sources

The lesson silently incorporates material from the official Claude Code docs, the Anthropic blog, and Anthropic engineering/cookbook content. Per project convention, no inline > Source: / > Enrichment — … labels appear in the learner-facing lesson — the only in-lesson labelled callouts are the > Analogy — … boxes. This ledger is the single source of provenance.

Official Claude Code behavior (authoritative):

• [E1] Anthropic docs — Desktop app — https://code.claude.com/docs/en/desktop
• [E2] Anthropic docs — Desktop quickstart — https://code.claude.com/docs/en/desktop-quickstart
• [E3] Anthropic docs — Worktrees (Run parallel sessions with worktrees) — https://code.claude.com/docs/en/worktrees
• [E4] Anthropic docs — Run agents in parallel — https://code.claude.com/docs/en/agents
• [E5] Anthropic docs — Agent View — https://code.claude.com/docs/en/agent-view
• [E6] Anthropic docs — Claude Code on the web — https://code.claude.com/docs/en/claude-code-on-the-web
• [E7] Anthropic docs — Remote Control — https://code.claude.com/docs/en/remote-control

Announcement / color (NOT official Claude Code behavior — clearly labelled as background):

• [E8] Anthropic blog — Redesigning Claude Code on desktop for parallel agents — https://claude.com/blog/claude-code-desktop-redesign
• [E9] Anthropic blog — Agent view in Claude Code — https://claude.com/blog/agent-view-in-claude-code
• [E10] Anthropic blog — Claude Code on the web — https://claude.com/blog/claude-code-on-the-web

Concept / background (NOT official Claude Code behavior — clearly labelled as background):

• [E11] Anthropic engineering — How we built our multi-agent research system — https://www.anthropic.com/engineering/multi-agent-research-system
• [E12] Anthropic research — Building Effective AI Agents — https://www.anthropic.com/research/building-effective-agents
• [E13] Anthropic cookbook — Orchestrator-workers — https://platform.claude.com/cookbook/patterns-agents-orchestrator-workers

This is the fastest-moving surface in the book — the desktop app, the cloud/web experience, and the mobile paths were redesigned and expanded through 2025–2026. The book is broadly correct on the load-bearing concepts (local vs cloud; worktree isolation; integrate-test-then-push merging; the wrong-starting-branch failure mode all hold), but several specifics had drifted, firmed up, or — in the case of the book's "a cloud session runs without your MCP/hooks/output styles" gotcha — were too broad and have been corrected (a cloud session is a fresh clone, so repo-committed config travels; only user-local config doesn't — see Drift #9). All Claude Code behavior was verified against [E1]–[E7] (a 2026-06-16 re-audit fetched [E1] desktop, [E3] worktrees, [E6] Claude Code on the web, plus github-actions and remote-control directly — see the dated note in the Drift table). Source-boundary discipline: Claude Code behavior claims rest on [E1]–[E7]; blogs [E8]–[E10] are announcement/color; engineering/research/cookbook ([E11]–[E13]) are concept/background. The ~order-of-magnitude token figures from the multi-agent research system are treated as "as reported," NOT as Claude Code behavior.

Pedagogical enrichment by the training author

Not from the book and not from the docs — written for this training, inventoried here for separate audit.

• Newcomer preface (## Before we start — desktop app, "local vs cloud," branches, worktrees, and merging). Defines the desktop app vs the terminal, local vs cloud / background agents, a branch (recap), a worktree (one-line, forward-pointing to §3), merging + a pull request (recap from Chapter 5), and parallel/orchestration (bridge from Chapters 5–7). Grounded in [E1]–[E3] and Chapters 5/6/7 continuity.
• Per-section analogies. Seven > Analogy — … callouts, one per numbered section: §1 the same car, now with a dashboard; §2 your own workshop vs a contractor's shop; §3 separate workbenches, one shared stockroom; §4 a head chef running three stations; §5 a dress rehearsal before opening night; §6 checking on the contractor from the road; §7 opening every lane at the supermarket.
• Whole-chapter analogy (## The whole chapter in one image — the workshop with a satellite shop). A sustained workshop-plus-satellite-shop analogy threading all seven sections (dashboard over the bench → two places to work → separate benches, one stockroom → fire the stations but check the base → dress rehearsal before opening night → don't open every lane).
• Three SVG diagrams (the book's figures are screenshots and are not reproduced):
• Figure 10.A — local vs cloud operating modes side by side (one engine → two execution environments; local = your disk + full config; cloud = clone-from-GitHub sandbox, default env, commits + PR, persists, scales).
• Figure 10.B — the worktree layout (one repository / .git object store → three working directories on three branches: main on project/hookhub untouched, two worktrees on vigilant-fiestel / zealous-jemison → merge back into project/hookhub).
• Figure 10.C — the integration-branch merge (three feature branches → temporary project/hookhub-merge integration branch where the CSS conflict is resolved → test locally :3002 → push to project/hookhub; both the resolution and the push human-gated).
• Each figcaption explicitly notes it is "Pedagogical diagram by this training, not from the book."
• Conceptual activity — "Split a real feature set into parallel and sequential work." Ten-minute, individual, no-setup exercise practising the §4/§7 judgment (independent vs dependent; per-agent prompts naming starting branch + file boundaries; merge order; spot the trap). Grounded in §4/§7/[E4].
• Practical exercise — "Run a worktree-isolated parallel merge, end to end." A ~35–45 min framework-free lab in ~/cct-ch10-lab/ using only git + the Claude CLI — no npm/Next.js, no desktop app, no cloud account. Part 1: one worktree + see the isolation (a commit lands off project/hookhub); Part 2: a second parallel worktree on a different file; Part 3: integrate both on a throwaway project/hookhub-merge branch, force + resolve a real styles.css conflict, pass a trivial "test" gate, then merge to project/hookhub; Part 4: clean up the worktrees + delete the throwaway branch. Reproduces the chapter's core mechanics portably; the desktop/cloud surfaces automate these exact Git steps.

Quiz items and learning objectives remain grounded in the book chapter and the labelled enrichment; none of the analogies, diagrams, the activity, or the exercise steps are themselves assessed.

Objective → Source Mapping

Lesson Section → Source Mapping

Unsupported / Pedagogical-Only Claims

Quiz Item → Source Mapping

Drift / Corrections Applied

The book is broadly current on the load-bearing concepts (local vs cloud, worktree isolation, integrate-test-then-push, the wrong-branch failure), but this is the fastest-moving surface in the book, so accuracy passes (verified directly against [E1]–[E7]) tightened several specifics — and the 2026-06-16 re-audit corrected the book's over-broad cloud-config gotcha (repo-committed config does travel), decoupled worktree.baseRef from cloud checkout, and scoped "human-gated" to the taught workflow. The book's original wording is preserved verbatim in extracted-chapters/ and is not edited.

2026-06-15 accuracy pass. Verified against [E1] desktop, [E2] desktop-quickstart, [E3] worktrees, [E4] agents, [E5] agent view, [E6] Claude Code on the web, [E7] Remote Control. The adjustments below were propagated across the lesson, quiz, this ledger, and the training-output mirror. The rows record each. 2026-06-16 re-audit (cloud config / base-ref boundary / merge automation). A second pass re-fetched [E1] desktop, [E3] worktrees, and [E6] Claude Code on the web (plus code.claude.com/docs/en/github-actions and …/remote-control) and corrected three over-broad claims in rows #3, #7, and #9: (#9) the book's "cloud runs without your MCP/hooks/output styles" is too broad — repo-committed config travels with the clone, only user-local config doesn't, and output styles aren't doc-covered (so no hard claim); (#3) worktree.baseRef governs local worktrees and is not tied to cloud-session checkout (cloud = fresh clone) — the earlier draft's §4 link was decoupled; (#7) "human-gated" is scoped to the taught local-merge workflow, since Desktop PR monitoring documents Auto-fix and Auto-merge. Propagated across the lesson, quiz, this ledger, and the training-output mirror. The book's original wording remains untouched in extracted-chapters/.

Extraction caveat (image-only PDF, summarized prose)

source-pdfs/10-chapter-10.pdf is an image-only PDF — no text layer (the image-only check printed 0). The source-of-truth extracted-chapters/10-chapter-10.md was produced by rendering each of the 43 pages to PNG at 150 DPI (PyMuPDF / fitz) into work/10-chapter-10-pages/ and transcribing the images visually. Consequences a reviewer should know:

• Mixed-fidelity extract. Explanatory prose is captured as faithful summaries; headings, code, commands, file paths, key names, flags, and branch names are verbatim. Treat code/commands/paths/branch names as exact; treat prose as a structural summary. Re-open the page images in work/10-chapter-10-pages/ for exact sentence wording.
• Page markers are reliable, but printed book page numbers are unknown — <!-- page N --> is the PDF page index. There is no .txt mirror.
• Page 43 is Packt back-matter promo (other-titles / "leave a review" marketing), not chapter content — ignore it for sourcing.
• The book's figures are screenshots (desktop/terminal/browser/GitHub/mobile captures) and are not reproduced (the three lesson diagrams are original SVGs).
• needs review — page-24 figure number. The printed figure number on PDF page 24 rendered ambiguously as "Figure 10.2x"; inferred to be 10.24 because the following page carries 10.25. Flagged in the extract and mirrored in work/open-issues.md. Cross-check the printed book if the exact figure number matters.
• needs review — worktree name ambiguity. The first worktree's branch name appears in the source screenshots as both vigilant-fiestel and vigilant-fieste1 (an l/1 OCR/visual ambiguity at small render size; the extract also shows the looser early rendering "vigilant feistal"). The lesson and diagrams standardize on vigilant-fiestel for consistency; the alternate vigilant-fieste1 is recorded here as the source ambiguity. The exact on-screen string is not load-bearing for any lesson claim (it's an auto-generated friendly name); cross-check the page images if a citation needs the literal string.
• Re-transcription, not OCR. PyMuPDF was used to render pages; no OCR engine was involved. Cross-check the printed book if exact wording/pagination matters.

Source Ledger — Chapter 11: Understanding Deep Agents

Primary source (the book)

• Source PDF: source-pdfs/11-chapter-11.pdf (20 pages; page 20 is Packt back-matter promo, not chapter content). This is the final chapter (Part 3).
• Extracted source: extracted-chapters/11-chapter-11.md (visual extraction, <!-- page N --> markers; the markers are PDF-page indices, not printed book pages). There is no usable .txt for this chapter — see the Extraction caveat at the end.
• Extraction tool: the Chapter 11 PDF is image-only (the image-only check python -c "import pypdf; print(sum(len(p.extract_text() or '') for p in pypdf.PdfReader('source-pdfs/11-chapter-11.pdf').pages))" printed 0). Extracted by rendering all 20 pages to PNG at 150 DPI with PyMuPDF (fitz) into work/11-chapter-11-pages/ and transcribing visually. Mixed-fidelity: headings, code, commands, file paths, key names, flags, tool names, and the LangChain base-prompt excerpt are verbatim; explanatory prose is captured as faithful section-by-section summaries (to avoid reproducing a copyrighted chapter at length). Treat code/commands/paths/tool-names as exact; treat prose as a structural summary, and re-open page images for exact sentence wording.
• Book's main sections (from the extract, in order): "Agent taxonomy in production systems" (pp. 1–3; the ReAct reason→act→observe loop, hybrid RAG, Figure 11.1 taxonomy, Figures 11.2/11.3 flowcharts); "Shallow agents and their limitations" (pp. 3–5; function calling → context grows → context rot as bloat/contradiction/pollution; Figure 11.4) — within it "Coding agents" (pp. 5–6; Claude Code/Devin/Cursor/Gemini CLI) and "Innovation at the application layer" (pp. 6–7; the Agent Harness Note); "What makes an agent deep?" (pp. 7–8; the four building blocks; Figure 11.5 adapted from the LangChain blog); "Planning tool in Deep Agents" (pp. 8–9; explicit dynamic to-do list; TodoWrite/TodoRead with {todos: Todo[]}); "Subagents and hierarchical delegation" (pp. 9–11; isolated context, returns only the final result; Figures 11.6/11.7); "Filesystem access in Deep Agents" (pp. 12–14; Read/Write/Edit/Glob/Grep/NotebookEdit and the LangChain ls/read_file/write_file/edit_file/glob/grep interface; the three-box model Figure 11.9); "The filesystem as a context engine" (pp. 14–15; write-out + select-back); "System prompt" (pp. 15–18; a reasoning framework not a flowchart; heuristic principles; language efficiency; the LangChain DeepAgents base_prompt.md excerpt, MIT-licensed); "Summary" (p. 19).

Enrichment sources

The lesson silently incorporates material from the official Claude Code docs, the LangChain DeepAgents materials, and Anthropic engineering/cookbook content. Per project convention, no inline > Source: / > Enrichment — … labels appear in the learner-facing lesson — the only in-lesson labelled callouts are the > Analogy — … boxes. This ledger is the single source of provenance.

Claude Code behavior (authoritative — official docs):

• [E9] Anthropic docs — Subagents — https://code.claude.com/docs/en/sub-agents
• [E10] Anthropic docs — Tools reference — https://code.claude.com/docs/en/tools-reference
• [E11] Anthropic docs — Permission modes — https://code.claude.com/docs/en/permission-modes
• [E12] Anthropic docs — Memory — https://code.claude.com/docs/en/memory
• [E15] Anthropic docs — Commands (/tasks = background tasks; verified in the 2026-06-16 re-audit) — https://code.claude.com/docs/en/commands
• [E16] Anthropic docs — Output styles (output styles modify the system prompt) — https://code.claude.com/docs/en/output-styles
• [E17] Anthropic docs — Agent SDK: modifying system prompts (the separate system-prompt API surface) — https://code.claude.com/docs/en/agent-sdk/modifying-system-prompts

LangChain DeepAgents (authoritative for the FRAMEWORK's design + the "deep agent" term — NOT Claude Code behavior):

• [E1] LangChain blog — Deep Agents — https://www.langchain.com/blog/deep-agents
• [E2] LangChain — deepagents docs (overview) — https://docs.langchain.com/oss/python/deepagents/overview
• [E3] LangChain — deepagents repo — https://github.com/langchain-ai/deepagents
• [E4] LangChain blog — How agents can use filesystems for context engineering — https://blog.langchain.com/how-agents-can-use-filesystems-for-context-engineering/

Concept / background (NOT Claude Code behavior — clearly labelled as background):

• [E5] Anthropic — Building Effective AI Agents — https://www.anthropic.com/research/building-effective-agents
• [E6] Anthropic engineering — Effective context engineering for AI agents — https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
• [E7] Anthropic engineering — How we built our multi-agent research system — https://www.anthropic.com/engineering/multi-agent-research-system
• [E8] Anthropic cookbook — Orchestrator-workers — https://platform.claude.com/cookbook/patterns-agents-orchestrator-workers
• [E13] ReAct: Synergizing Reasoning and Acting in Language Models (arXiv) — https://arxiv.org/abs/2210.03629
• [E14] GPT Researcher (open-source deep-research agent) — https://github.com/assafelovic/gpt-researcher

This chapter is conceptual — it teaches an architecture (the "deep agent" four-pillar pattern) rather than a Claude Code surface to operate, so most of the load-bearing claims are about the framework idea and only a handful are Claude Code behavior. The book is broadly current on the concept: the taxonomy, context rot, the four building blocks, and the filesystem-as-context-engine principle all hold. The specifics that drifted are (1) the terminology — "deep agent" is a community/LangChain articulation, not an Anthropic/Claude Code label (the book itself acknowledges LangChain articulated it); and (2) the planning tool names — the book's TodoWrite/TodoRead are the legacy surface, replaced by the Task* family ([E10]). All Claude Code behavior was verified against [E9]–[E12]. Source-boundary discipline: Claude Code behavior claims rest on [E9]–[E12]; the LangChain materials [E1]–[E4] are authoritative for the framework's design and the "deep agent" term but not for Claude Code behavior; Anthropic engineering/research/cookbook [E5]–[E8] are concept/background, and the orchestrator-worker token/eval figures (≈4×/≈15×/≈90.2% from [E7]) are treated as "as reported," NOT as Claude Code behavior; ReAct [E13] is the academic foundation.

Pedagogical enrichment by the training author

Not from the book and not from the docs — written for this training, inventoried here for separate audit.

• Newcomer preface (## Before we start — agents, ReAct, "long-horizon", harnesses, and the four pillars). Recaps what an agent is, the ReAct loop, shallow vs. deep, "long-horizon" + context rot, the agent harness, and the four pillars (one line each). States up front that "deep agent" is a community/LangChain term, not an Anthropic/Claude Code label (Anthropic more commonly discusses "long-running / long-horizon" agentic work, context engineering, and agents/workflows rather than defining "deep agent" as an official term). Grounded in [E1], [E6], [E13] and book continuity (Chapters 1, 7, 9).
• Per-section analogies. Seven > Analogy — … callouts, one per numbered section: §1 vehicles on the road (bicycle vs. long-haul truck vs. fitted-out workshop truck); §2 a desk that's never cleared; §3 what makes an expedition, not a walk; §4 the whiteboard the surgeon keeps glancing at; §5 the general contractor and the trades; §6 the detective's case room, not their pockets; §7 the constitution, not the to-do list.
• Whole-chapter / whole-book analogy (## The whole chapter in one image — the expedition, and the whole book). A sustained expedition analogy threading all seven sections, then a book capstone mapping all 11 chapters back to the four pillars / context engineering. No new claims.
• Three SVG diagrams (the book's figures are taxonomy/flowchart/architecture diagrams + terminal screenshots and are not reproduced):
• Figure 11.A — the agent taxonomy as nested regions (Agents in production ⊃ shallow [ReAct loop] and deep [long-horizon]; deep ⊃ deep-research agents and coding agents; the harness as the wrapping application layer).
• Figure 11.B — the four pillars as four columns holding a roof labeled "long-horizon execution," each mapped to its Claude Code surface (system prompt + CLAUDE.md; Task*/legacy TodoWrite; the Agent tool; Read/Write/Edit/Glob/Grep), all resting on a "context engineering" foundation; three of the four flagged as context-management moves.
• Figure 11.C — the filesystem context-engine three-box model (all-available ⊃ selected vs. required), contrasting "without a filesystem" (everything dumped → overflow → rot) with "with a filesystem" (write state out to disk; glob/grep select a small set that covers required).
• Each figcaption explicitly notes it is "Pedagogical diagram by this training, not from the book."
• Conceptual activity — "Find the four pillars in a tool you use." Ten-minute, individual, no-setup exercise practising the §3–§7 lens (locate each pillar in a deep agent you use; tie each to a failure it prevents; spot the three context-management moves; name the loose language you'd correct). Grounded in §2–§7.
• Practical exercise — "Watch the four pillars run in Claude Code." A ~35–45 min framework-free lab in ~/cct-ch11-lab/ using only Claude Code + git — no npm, no LangChain install, no API keys. Part 1: a deliberately multi-step task → watch the Task* to-do list update (legacy TodoWrite flagged). Part 2: delegate exploration to a subagent → it returns a summary from an isolated context (/context before/after). Part 3: write state to NOTES.md, then retrieve selectively with grep/glob. Part 4: add a CLAUDE.md heuristic and watch behavior shift (Pillar 1). Optional read-only stretch: open the LangChain DeepAgents base_prompt.md to compare. Reproduces the chapter's concepts as something the learner can see, portably.

Quiz items and learning objectives remain grounded in the book chapter and the labelled enrichment; none of the analogies, diagrams, the activity, or the exercise steps are themselves assessed.

Objective → Source Mapping

Lesson Section → Source Mapping

Unsupported / Pedagogical-Only Claims