CATALOG / ALL LESSONS

119 lessons across 19 phases

Each lesson is a single claim you can act on. The phase structure is the dependency graph; the path is the URL.

119 of 119 lessons are authored, and 19 of 19 practice modules are written. For the agent-readable form see llms.txt; for the API see developer.html.

Phase 00 — Setup & Tooling

Your tools shape your thinking. Set them up once.

  1. 1. Dev Environment
  2. 2. Git as Your Safety Net — your safety net, not optional
  3. 3. Terminal and Shell
  4. 4. Editor Setup
  5. 5. Debugging and Profiling

Practice module 00.1 — Break this repo on purpose. Recover it. Recover it faster. (Break)

Phase 01 — Foundations of AI

The words everything else leans on.

  1. 6. What a Language Model Is
  2. 7. Tokens — why text becomes currency — why text becomes currency
  3. 8. The Context Window — the only budget that matters — the only budget that matters
  4. 9. Prompt, Inference, API
  5. 10. What "Agentic" Means
  6. 11. Latency, Cost, and Rate Limits

Practice module 01.1 — Explain any codebase to yourself, out loud. Find the jargon leaks. (Instrument)

Phase 02 — Git Deep

Commit = photograph. Branch = label. `worktree` hides `working tree`.

  1. 12. Commit Is a Photograph, Not a Diff
  2. 13. Branches Are Movable Labels, Not Copies
  3. 14. Merge and Rebase
  4. 15. Conflicts: What They Are, How They Resolve
  5. 16. Recovering Lost Work
  6. 17. Stashing, and Why Agents Break Things
  7. 18. Remotes, Forks, and the Full Mental Model

Practice module 02.1 — Break it. Recover it. Recover it again, faster. (Break)

Phase 03 — Models & Families

Open-weight vs frontier. What actually costs money.

  1. 19. Open-Weight vs Frontier
  2. 20. Model Aliases and Routing — teach `sonnet`, never hardcoded IDs — teach `sonnet`, never hardcoded IDs
  3. 21. Effort Levels and Extended Thinking
  4. 22. Prompt Caching — why switching models makes a turn slow — why switching models makes a turn slow
  5. 23. Quantization, Distillation, Fine-Tuning
  6. 24. SLMs — When a 350M Model Wins — When a 350M Model Wins
  7. 25. Decision Models Beat Generation on Cost
  8. 26. The Taxonomy: LLM / Decision Model / SLM

Practice module 03.1 — Route a real workload across model tiers. Find where the frontier model was wasted. (Instrument)

Phase 04 — Claude Code

The tool, from first run to fluency.

  1. 27. What Claude Code Is
  2. 28. Install, First Run, Verify
  3. 29. Files and Edits — and When It Refuses — and When It Refuses
  4. 30. Sessions, `/clear`, `/compact`
  5. 31. The Agentic Loop — the one concept everything hangs on
  6. 32. What Loads Into the Window, and What Doesn't
  7. 33. Permissions and Permission Modes
  8. 34. Settings — 4 Files, 5 Precedence Levels — 4 Files, 5 Precedence Levels
  9. 35. Plan Mode and Checkpoints
  10. 36. Checkpointing, `/rewind`, Recovery
  11. 37. Troubleshooting — Reading Errors Properly — Reading Errors Properly

Practice module 04.1 — Configure a real project. Know which settings file won. (Build)

Phase 05 — Commands & Skills

The most flexible extension layer.

  1. 38. Built-in Commands
  2. 39. Why Custom Commands Merged Into Skills
  3. 40. What a Skill Is
  4. 41. Anatomy — the Frontmatter Field Table — the 21-Field Frontmatter Table
  5. 42. The Invocation Matrix — Who Can Trigger It — Who Can Trigger It
  6. 43. Install a Skill
  7. 44. Author a Skill From Scratch

Practice module 05.1 — Author a skill. Use it. Break it. Fix the frontmatter. (Break)

Phase 06 — Subagents

Context isolation.

  1. 45. Subagent Markdown Format
  2. 46. Built-in Subagents — Explore, Plan, general-purpose — `Explore`, `Plan`, `general-purpose`
  3. 47. Author a Subagent — and the Fork-Context Subtlety
  4. 48. Skills Inside Subagents — the genuinely confusing case — the genuinely confusing case

Practice module 06.1 — Write a subagent that does one job perfectly and refuses everything else. (Build)

Phase 07 — MCP

A protocol, not a tool.

  1. 49. What MCP Is
  2. 50. Four Transports — http / sse *(deprecated)* / stdio / ws
  3. 51. Scopes, Precedence, Config Shape
  4. 52. Build an MCP Server From Scratch
  5. 53. The Trust Model and Prompt Injection
  6. 54. OAuth, Headers, and MCP Tool Search

Practice module 07.1 — Build an MCP server. Then ask: would you trust a repo you cloned? (Decide)

Phase 08 — Hooks

Events on the loop. Enforcement, not requests.

  1. 55. What a Hook Is
  2. 56. All the Events, Matchers, Handler Types
  3. 57. Hook Script Shape — stdin JSON → stdout / exit code — stdin JSON → stdout / exit code
  4. 58. The Exit-1-vs-2 Trap
  5. 59. Build a Guardrail Hook
  6. 60. Debugging Hooks

Practice module 08.1 — Write a hook that makes an unsafe action *impossible*. (Build)

Phase 09 — Plugins

The packaging layer. Comes last for a reason.

  1. 61. *"Plugins Are the Packaging Layer"* — and why — and why
  2. 62. Plugin Anatomy — the directory and the manifest
  3. 63. Install from a Marketplace, and Author One
  4. 64. Plugin Economics — What Every Enabled Plugin Costs — What Every Enabled Plugin Costs

Practice module 09.1 — Package your skill + subagent + hook as one installable plugin. (Build)

Phase 10 — Memory & Instructions

How context persists.

  1. 65. CLAUDE.md — the 200-Line Rule — the 200-Line Rule
  2. 66. AGENTS.md, CLAUDE.local.md
  3. 67. Rules and Path-Scoped Rules
  4. 68. Auto Memory and `MEMORY.md`
  5. 69. Output Styles
  6. 70. Imports and External Context

Practice module 10.1 — Write a CLAUDE.md that changes behavior. Prove it. (Build)

Phase 11 — Parallelism I

The five names, and why they're different.

  1. 71. The Five Names
  2. 72. Subagents as Isolation
  3. 73. Agent Teams — Mailbox, Task List, Documented Limits — Mailbox, Task List, Documented Limits
  4. 74. Worktrees, Deep — session vs per-agent — session vs per-agent
  5. 75. Base Ref, Cleanup, and the /batch Path
  6. 76. How Isolation Is Actually Enforced — the blocking checks — the blocking checks

Practice module 11.1 — Build a parallel system. Prove isolation held. (Build)

Phase 12 — Parallelism II

Orchestration.

  1. 77. Cross-Session Messaging
  2. 78. Dynamic Workflows — the Script Decides — the Script Decides
  3. 79. `parallel()` vs `pipeline()`
  4. 80. The Completion-Order Gotcha
  5. 81. Workflow Runtime Caps
  6. 82. Loops — Scheduled and Recurring — Scheduled and Recurring
  7. 83. Hooks-Driven Automation — Events as Control Flow — Events as Control Flow
  8. 84. The Decision Framework — Which Mechanism, When — Which Mechanism, When
  9. 85. When NOT to Parallelize

Practice module 12.1 — Write a workflow with propose → verify. Hit the completion-order trap *on purpose*. (Break)

Phase 13 — Context Engineering

Context as architecture.

  1. 86. What Loads, What Costs
  2. 87. Progressive Disclosure — Skills as a Loading Strategy — Skills as a Loading Strategy
  3. 88. Context as Architecture, Not a Dump
  4. 89. Prompt Caching as a Design Constraint
  5. 90. Reducing Context Without Losing Capability

Practice module 13.1 — Cut a bloated context by half. Prove capability survived. (Instrument)

Phase 14 — Harness Engineering

The loop minus the intelligence.

  1. 91. What a Harness Is
  2. 92. Most Agent Calls Are Decisions, Not Generation
  3. 93. Decision Models Inside a Loop
  4. 94. Confidence Gating — Escalate Only When Unsure — Escalate Only When Unsure
  5. 95. Verification Loops — the Prerequisite for Unattended Runs — the prerequisite for unattended runs
  6. 96. Guardrails vs Instructions — Requests vs Enforcement — requests vs enforcement
  7. 97. Design Your Own Harness — and Defend the Trade-offs — and defend the trade-offs

Practice module 14.1 — Instrument a real loop. Find the 20% of calls costing 80%. (Instrument)

Phase 15 — Graph Engineering

Nodes, edges, and what genuinely parallelizable means.

  1. 98. Nodes and Edges
  2. 99. Task Graphs — Dependencies and the Frontier — Dependencies and the Frontier
  3. 100. Blocking Edges — What's Actually Parallelizable — What's Actually Parallelizable
  4. 101. Claiming — Stopping Two Agents Doing One Job — Stopping Two Agents Doing One Job
  5. 102. Wayfinding — Producing Decisions, Not Deliverables — Producing Decisions, Not Deliverables
  6. 103. Fan-Out / Fan-In Patterns
  7. 104. Failure Propagation — What Happens When One Node Dies — What Happens When One Node Dies
  8. 105. Design a Graph for a Real Project

Practice module 15.1 — Decompose a real project. Find the critical path. (Decide)

Phase 16 — Worktrees in Practice

Deep on the one you came for.

  1. 106. Session vs Agent Scope
  2. 107. Manual Worktrees — `git worktree add` — `git worktree add`
  3. 108. The Startup-Cache Trap
  4. 109. Merge Strategy for Agent Branches
  5. 110. Isolation Without a Commit Is Not a Backup

Practice module 16.1 — Reproduce the empty-branch bug. Then prevent it. (Break)

Phase 17 — Scaling & Operations

Running it for real.

  1. 111. Headless / Non-Interactive Mode
  2. 112. The Claude Agent SDK
  3. 113. Channels and Surfaces
  4. 114. Sandboxing and Security Model
  5. 115. Managing Settings at Scale

Practice module 17.1 — Automate a real task headlessly, end to end. (Build)

Phase 18 — Capstone

Ship it.

  1. 116. Spec → Graph → Build → Verify
  2. 117. Review Against the Docs
  3. 118. What Breaks in Production
  4. 119. Keeping Up — Claude Code Ships Weekly — Claude Code Ships Weekly

Practice module 18.1 — End-to-end with everything. (Build)