You've reached the end: the week on stash, and where to go next

That’s the course. Before you close it, look back at the week you just walked, because the shape of it is the actual lesson.

The arc, in one breath

You started with a repo you didn’t write: stash, a friend’s read-it-later service, working well enough to trust but not quite finished. Ten modules later you’d turned it into something better, and in the same motion built the thing that did the turning - one artifact per module, each one still sitting in your .pi/ directory right now.

Module	You can now…	Artifact
1 · Getting started	Ship a real fix through an agent with nothing hidden from you	The feed-date fix, committed
2 · The core	Read the exact system prompt and every tool call’s exact arguments	ctx.getSystemPrompt(), the session JSONL
3 · Context	Fork instead of dragging a wrong turn forward; stop re-explaining stash’s conventions	.pi/APPEND_SYSTEM.md
4 · Models & config	Route cheap work to a cheap model on purpose, and know a local model’s honest ceiling	settings.json / models.json
5 · First extension	Give Pi a permanent move it didn’t ship with	extensions/stash-tools.ts
6 · Rebuild the defaults	Rebuild exactly the guardrails you decided stash needed	damage-control.ts, plan-injector.ts, statusline.ts (tilldone.ts still unfinished)
7 · Skills & packages	Package a procedure once, share it, load it only on demand	skills/onboard-content-source/SKILL.md
8 · Subagents	Fan work out in parallel, and check it with an agent that doesn’t trust the builder	agents/verifier.md
9 · Teams	Split a job too big for one context - and know when that split isn’t worth it	agents/expertise/extraction-lead.md
10 · Daily workflow	Add the whole thing up and judge it honestly	The ledger below

The complete context ledger

Module 2 opened a table with one rule: every layer this course adds gets a row, and the row never leaves the “who decided” column blank. Every module since has closed by adding to it. Here’s the whole thing, replayed once, with one column added: whether each layer actually earned what it cost.

Layer	What it costs	What it buys	Who decided	Earned its keep?
The four default tools + system prompt (module 2)	Fixed and small enough to read in one sitting; bash alone is capped at 100 lines or 10KB, a named default	Removes not knowing what the agent can do before it acts	Pi shipped it; you can read all of it	Pass - the floor everything else stands on
APPEND_SYSTEM.md + compaction (module 3)	Loaded every session; compaction keeps the most recent 20,000 tokens and reserves 16,384 for the reply, a fixed cap	Removes re-explaining stash’s conventions every session, and losing a decision to a summary that dropped it	You wrote the file; Pi enforces the cap	Pass
Model routing (module 4)	Same tokens, different price - module 4’s own toy sweep put the backlog at 15x frontier-and-high against cheap-and-low	Removes paying frontier price for work with nothing to reason about	You set the routing; the model doesn’t choose its own price	Pass
stash-tools.ts (module 5)	One more tool schema, sent on every turn for the rest of its life, whether you use it or not	Removes the manual Python-shell dance for a chore you’d already repeated four times	You wrote it, and you’re the one paying for it now	Pass - still the most-used file in the tree
The four rebuild-the-defaults extensions (module 6)	Each gate is a check that runs before the real tool call does - a turn spent asking “is this allowed”	Removes an unguarded write to stash.db/.env, silent task drift, a plan that falls out of context, and not knowing what a session is costing right now	You - every rule in every file is one you wrote	Conditional - 3 of 4 finished and tested; tilldone.ts’s own lesson says its state rebuild isn’t done
Skill + prompt + theme (module 7)	Only name and description sit in context until the skill matches; the body loads on demand, not on every turn	Removes writing the onboarding steps by hand each time, and retyping the recurring triage pass	You	Pass
Verifier + batch driver (module 8)	A second window, spawned separately, plus the cost of the handoff - the verifier only knows what you wrote down as a falsifiable claim	Removes trusting the builder’s own report of its own work	You - and the verifier can only be corrected by editing its file, never by arguing with it	Conditional - the verifier is real and tested; the batch driver is a design its own lesson says Pi doesn’t run
Migration team (module 9)	Coordination overhead across multiple windows - module 9’s own accounting: total tokens spent are roughly the same as one context doing it alone, maybe more once every lead’s overhead is counted	Removes one context trying to hold a migration too big for it; buys legibility, not savings	You, and only after the honest test in module 9 passed	Conditional - real for the migration; module 9’s own verdict is that most day-to-day stash work doesn’t clear the bar

Why there’s no grand total row: the “what it costs” column mixes tokens, turns, dollars, and coordination overhead - four different units that don’t sum into one number without inventing a conversion rate this course never measured. That’s not an oversight. Adding a fake total would be exactly the kind of number section 5 of this course’s own register rules out: a multiplier nobody actually computed, dressed up as if it had been.

Check that table against this module’s own targets: target 1 (every file traces to a module) - met, the build log did it row by row. Target 2 (cost stated for every layer, not just benefit) - met, every row above has one. Target 3 (a teammate could tell what’s finished) - met, and honestly: 2 of 15 files are marked unfinished right in the tree, not hidden. Target 4 (an honest keep-or-not verdict per layer) - met, and three of eight rows above are “conditional,” not an automatic pass. All four targets hold, and two of them hold precisely because this table admits what didn’t finish rather than rounding it up.

Two places to go from here

For the spec-level other half - Foundations. This course was a story: one project, one harness built piece by piece, each primitive introduced exactly when stash demanded it. Foundations is the same picture from the other side - lookup-shaped, authoritative, the place to go for the complete list of extension lifecycle events or the precise config-merge order rather than the slice this course’s story needed.

For the other tools you work across - the sibling courses. Almost nobody lives in one agent all day, and the instincts you just built transfer directly, even though every tool spells them differently. Claude Code, Codex, opencode, GitHub Copilot, and Cursor run on the same teach-by-doing spine: one repo, one week, primitives introduced as the work needs them. The discipline you just practiced on stash - closing the gap between what you know and what the agent knows - is the same discipline, told in a different tool’s idiom.

The question this course opened with

Go back to the very first page. Before you’d typed a single Pi command, the question on the table was: how is the tool you have right now shaping what you believe is possible?

You couldn’t really answer that at the start, because you’d only ever driven agents that hid their own wiring - a system prompt you never saw, tool calls that scrolled past, guardrails that existed but whose exact shape you never had to learn. It’s hard to know what a closed box is shaping in you, because the shaping happens exactly where you can’t see it.

Now you can answer it, because you spent ten modules with a tool that hid nothing - and paid, in full view, for every piece of what it left out. The ledger above is that payment, itemized. A closed harness shapes what you believe is possible by deciding, invisibly, what’s worth showing you. An open one shapes it too - just in the other direction, by making you build the thing before you can lean on it, and by leaving two line items unfinished where a closed tool would have shown you nothing to finish at all.

Neither is free. The open one just hands you the bill instead of folding it into the price. Carry that test into whatever you build next, on whatever tool you pick up: not “is this harness good,” but “who is paying for what I can’t see, and would I rather it were me.”