When to reach for Pi

You’ve now built the harness by hand, which puts you in a better position than most people evaluating a tool: you’re not guessing what Pi is good for, you watched yourself do it. So use that. Here’s the honest accounting - where it won, where it cost you, and where it actually sits next to the other tools you use.

The claim to check as you read this: Pi wins clearly on three of the four grounds below, and the fourth - cost - is real but bounded, not unlimited. Module 4’s own toy sweep (declared illustrative there, not a measurement) put the re-extraction backlog at 15x on the frontier model at high thinking against the cheap model at low, and the extra spend bought nothing, because mechanical rows have nothing to reason about. That ratio is deliberately coarse and the module says so. What survives the coarseness is the shape of the gap, on exactly the kind of work stash’s backlog is full of.

Where Pi wins

Observability. From module 2 onward you could see the whole system prompt at boot, every tool call’s exact arguments, every token and dollar spent. That’s not a minor convenience - it’s the difference between trusting a fix because you watched it happen and trusting it because the tool told you to. Most agents make you take that on faith; Pi is the one agent in this course that never asked you to.

Control. Every “missing” feature you rebuilt in module 6 and module 8 - the permission gate, the task discipline, the verifier - you built with a full view of the mechanism underneath, not a config toggle whose internals you have to trust. When the damage-control extension blocks a write to stash.db, you know exactly why, because you wrote the rule. Every gate in this harness is one you can read, diff, and turn off - nothing in it is a black box you’re trusting on faith.

Cheap, and cheap locally. The routing from module 4 - cheap models for bulk grunt work, a stronger model only where it earns its keep - is a habit Pi’s easy model-switching makes natural rather than exceptional, and the 15x gap above is what that habit is worth on mechanical work. When a local model made sense for throwaway work, you already knew its honest context ceiling going in, instead of discovering it mid-job. Same tokens, different price, and for the first time you actually control which price you pay.

Learning. This is the one that’s easy to undersell. Building a permission gate, a task-discipline gate, and a verifier from scratch taught you what those features actually do in any agent, including the ones that ship them by default. You now know what a “permission mode” is checking, not just that it exists.

Where it costs you

There’s a cost that runs under every one of those wins, and it doesn’t go away with practice: you own the maintenance. A minimal core with no built-in guardrails means every guardrail is a file you wrote, and every file you wrote is a file only you (or whoever reads your .pi/ directory) can fix when it breaks, when Pi’s extension API shifts under it, or when stash grows in a direction the rule didn’t anticipate.

Here’s that cost, made concrete instead of asserted: the last lesson counted your .pi/ directory at 15 files, and 2 of them - tilldone.ts and reextract-chain.yaml - are still exactly where their own lessons left them, flagged as unfinished and never picked back up. That’s not a hypothetical maintenance burden. It’s two specific, named files, sitting in your own directory right now, that nobody but you is going to finish.

Some Pi users call this whole trade the spaceship problem - the vendor bloat is gone, but so is the vendor’s job of keeping the thing running. It’s the same enemy this entire course has been naming since module 1, just arriving at its final bill: every default you didn’t accept, you rebuilt yourself, and a thing you built is a thing only you maintain. You get full control and full agency; you also get the pager, and right now the pager already has two open tickets. The spaceship problem isn’t a warning about some future cost - it’s the two files sitting in your tree today.

That trade is fine, and often worth it - but it’s worth naming plainly rather than dressing it up as pure upside. A tool that ships permission prompts by default and a tool that makes you build your own aren’t at different points on a quality scale; they’re making a different bet about who carries the ongoing cost.

The YOLO-by-default posture from module 1 and the gate you built in module 6 is the sharpest version of this trade: nothing stops a destructive command until you write the rule that does, and no rule you write is complete the day you write it - it’s complete until stash does something the rule didn’t anticipate. Full agency and full liability arrive in the same file, every time.

Primary tool, or the one you keep in reserve?

The honest answer isn’t “graduate to Pi as your main driver” - it’s closer to what shows up repeatedly among people who’ve actually lived with it for months: Pi tends to land as one tool in a stack, reached for on specific merits, not the only agent open all day. A harness this legible is genuinely valuable for a side project you want to understand completely, for cost-sensitive bulk work where a cheap model and full routing control save real money, and for exactly the kind of learning this course just put you through. It’s a harder sell as the thing you reach for when you just need a feature-complete assistant now and don’t want to think about the plumbing underneath it - that’s a legitimate use case, and it’s not the one Pi was built to serve.

So the test isn’t “is Pi good.” It’s: for this job, do you want the harness someone else already assembled, or do you want the one only you can read? stash was the right project to answer that question on, because you got to watch the harness earn its keep, piece by piece, against a real codebase with real rough edges. Carry the question, not a verdict, into the next tool you pick up.

Reconcile that against the opening claim: observability, control, and cost all held up under a real accounting - none of them were oversold. Maintenance didn’t hold up as a fourth win, and it was never claimed as one; it’s the one line item on this whole balance sheet that’s a cost with no ceiling, which is exactly why it gets the next lesson to itself before this one closes for good.

Next: close the course.