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 feed-reader service - a FastAPI app, a SQLite file, and two failing tests the README only half confessed to. Ten modules later you’d fixed the real bugs, wired readability-lxml in (the library that digs the article body out of the messy HTML feeds actually serve), and built the thing that did the work - one deliverable per module, most of them 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 parse_date offset 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 (/stash + resync_feed)
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/add-feed-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 (+ the resync-chain.yaml design)
9 · Teams	Split a job too big for one context - and know when that split isn’t worth it	The readability migration, agents/expertise/extraction-lead.md
10 · Daily workflow	Add the whole thing up and judge it honestly	The synthesis below

What the harness costs, and what it bought

The core chapter taught you to put four questions to anything that enters a session - what layer is this, what does it cost, what does it buy, who decided - and named the four principles underneath them: capability, context, control, and cost. This is the place to run that accounting over the whole harness at once.

Capability. What Pi could do out of the box was four tools, a loop with no ceiling, and whatever the model itself knew - the floor everything else stands on, and small enough that you read every word of it. Everything past that floor, you added. /stash and resync_feed taught Pi two new moves, for one more tool schema sent on every turn for the rest of its life - still the most-used file in the tree, so the schema pays its rent. The spawn primitive and the verifier added isolation and a second opinion that doesn’t trust the first. The migration team added focused contexts instead of one mixed one, and its own chapter’s verdict stands: it earned its keep on a migration that genuinely needed splitting, and most day-to-day stash work doesn’t clear that bar.

Context. The window filled, and you learned to manage it in layers rather than fight it. Sessions resume and fork instead of forcing you to re-derive; compaction buys room at the price of a lossy summary (16,384 tokens reserved, 20,000 kept verbatim - Pi’s real defaults, traced in the compaction lesson); APPEND_SYSTEM.md carries the five durable rules for a 63-word rent, paid every session, worth it every time you don’t re-explain them; the skill’s 61 words of frontmatter sit in the prompt while its 225-word body loads only when a request matches. And underneath all of it, the full record on disk never shrinks - what got summarized out of the window is still on disk to be read back.

Control. Almost none shipped, and what you rebuilt you can read end to end: a rule file plus a hook that stops a delete aimed at stash.db; a gate that blocks skipping ahead on a multi-part job; a plan kept in front of the model on every turn by re-reading the file; a verifier with no chat input, correctable only through the file that defines its claims. You also learned the honest boundary of that control - a tool_call hook is not a sandbox, and a rule in context is guidance, not a wall. Two files in the tree are still designs rather than working code - tilldone.ts and resync-chain.yaml, flagged as unfinished by their own lessons and counted as such here, not hidden.

Cost. The bill was itemized all week. Fixed costs Pi ships and you can read: the tool schemas, the sub-1,000-token system prompt, compaction’s 36,384 spoken-for tokens. Variable costs you learned to route: the toy 15x gap between a frontier model at high thinking effort and a cheap one at low, on mechanical rows, and the local model’s flat zero inside a hard context ceiling. Turn costs - the currency gates spend. And the one cost with no ceiling: maintenance, because every default you declined to accept is a file only you (or whoever reads your .pi/ directory) can fix.

There is no grand total, and the course refuses to invent one: those units - tokens, turns, dollars, coordination, attention - do not sum without a conversion rate nobody measured. A fake total would be exactly the kind of number this course keeps declining to print. What you take away instead is the judgment: which layer earns its rent on which kind of work, checked against real counts rather than remembered enthusiasm.

Held against what this module promised, the build holds up honestly: every file traces to the chapter that taught it (the build log walked it file by file), every layer’s cost above is stated in countable units, a teammate reading the tree alone can tell the two unfinished pieces from the sixteen finished ones, and the keep-or-not verdict for each layer is the one its own chapter argued - including the verdicts that came back conditional rather than flat yes (the team that earns its keep only on migrations big enough to need splitting is the clearest), and the two files still waiting to be finished.

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 accounting 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.”