Playbooks
Foundations explains what each primitive is. Courses teach one tool end to end. Playbooks sit between them: a named procedure for a specific, recurring problem - “how do I get an agent to build a feature from a mockup,” “how do I trust an agent’s fix without reading every line” - that works the same way regardless of which CLI you’re driving it from.
Find your play
Section titled “Find your play”Start from the moment you’re in, not from a table of contents:
| The moment you’re in | The play | Its shape |
|---|---|---|
| The agent says “done, all fixed!” - and you have no way to tell if that’s true | TDD with agents | A ratchet: two commits, and the order is the technique |
| You pasted a mockup, got roughly the right layout, a blue that isn’t in your palette, and a hand-rolled toggle your codebase already had | Design-to-code | A ledger: what the image drops, and one fix per loss |
| You’re about to edit code whose shape you don’t hold, and the alternative is a morning of grepping | Architecture diagrams via agent | A funnel narrowing to one receipt, then a three-way choice about what to do with it |
| You caught yourself babysitting an agent through work you could have described completely up front | AFK agents | A timeline: gates before, during, and after your absence |
| The agent keeps making wide, wrong edits in one part of the codebase, session after session | AI-ready code | A rubric: four probes, read in any order |
| You need a video with real text on screen, and the model that makes footage can’t spell your URL | Video with agents | A pipeline built around one cheap inspection step |
If you only learn two: TDD with agents (the check that can say no) and AI-ready code (the context that stops wrong turns) - most of the others build on those two ideas.
What every page promises
Section titled “What every page promises”Three readers are always served. Where each layer sits follows the shape of the play, not a template - a rubric you read in any order can’t be laid out like a loop where reading out of order destroys the meaning:
- In a hurry - the one copyable move or install command, at the top, working in minutes. Take the fish and go.
- Learning the craft - the procedure, with the why riding each move: run it twice and you own it, in any tool, including ones that don’t exist yet.
- Going deep - failure modes, recovery paths, and receipts. This is the reference layer; there’s no length cap here by design.
Nobody is expected to read a whole page. Everybody is expected to leave with something.
Anything perishable - a named tool, a version, a price - is quarantined in a dated current picks block rather than braided into the procedure, so the durable part of a page stays true when the tool of the month changes.
Two genres
Section titled “Two genres”Process plays are about how you run an agent on a codebase - delegate a fix and trust the result, walk away from a run without regretting it, make a repo legible to a session that wakes up knowing nothing. That’s TDD, Design-to-code, AFK agents, and AI-ready code.
Capability plays are about what you get out of an agent - diagrams and video today; decks and documents by the same logic. One principle governs the genre: agents are strongest in text and code, so route the artifact through a code-shaped format you can check and edit, not a pixel output you can only regenerate. That’s Architecture diagrams and Video with agents. Each carries a “substrate decision” section - the template for deriving your own play when new tools ship, since the named tools rot and the decision doesn’t.
Different genres, same load-bearing move: every play turns on routing the agent’s claim through a check that can say no - a red test that predates the fix, a grep for raw hex, a stop-gate the run can’t edit, an edge receipt against the code, a rendered frame you actually look at. The play is the judgment about which check, and when.
Skills are the fish; playbooks are the fishing
Section titled “Skills are the fish; playbooks are the fishing”Many of these moves ship as installable skills: where a page has a pick worth naming it sits in that page’s In a hurry? or Off the shelf block, and npx skills find searches the cross-tool registry at skills.sh for more. The skill runs the procedure; the playbook is the why and the when - and the judgment for the day the skill’s happy path ends.
More playbooks are on the way in both genres. If the one you need isn’t here yet, the closest primitive is probably in Foundations, or check the course for your tool.