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

That is the course. Nothing new happens on this page - it is the whole arc, looked back at, with the scenario’s numbers finally reconciled against the definition the opening chapter wrote before you had installed anything.

What each chapter left you able to ask

Strip away the tool-specific mechanics and every chapter handed you one question you can now ask that you could not before:

1. Getting started - what actually happened in that turn, and does the diff match what I asked for?
2. Sessions & context - is this still the same line of work, or does the next task want a clean window?
3. Approvals & sandbox - how far can this run reach on its own, and where does it have to stop and ask?
4. Rules - is this written down where Codex reads it - and is guidance enough, or does something need to enforce it?
5. Models & effort - does this task’s shape actually earn the extra thinking, or is the pattern already decided?
6. Subagents - does this search belong in the window that has to hold the answer, or in someone else’s?
7. Skills - is this a fact Codex should always hold, or a procedure it should run on recognition?
8. Extending Codex - does Codex need more reach here, or does something in this loop need to be able to say no?
9. Automation - what replaces me, stage by stage, when nobody’s at the keyboard to catch the wrong turn?
10. Daily workflow - do these reflexes fire on their own now, or am I still assembling them from parts?

The whole stack, priced by what it spends and holds

Every chapter priced its own move where a number answered a real question. Rather than replay those numbers in one grid, here is the same synthesis organized the way the course actually taught you to think - by what each move spends, what it holds, and whether it survives the session that built it:

• Context. The rules file (~115 estimated tokens a session, ~150 with the parse-path rule) informs every session from now on - and never enforces. The skill pays a ~90-token stub every session and loads ~300 more only when the situation fires. Sessions still start cold; what changed is what the cold session finds written down.
• Capability. Matching model and effort to task shape keeps pattern work cheap and gives design forks the depth they need - the profiles carry that judgment so it recurs. Delegation moved noisy reading out of the window that holds the answer.
• Control. The two dials, bundled into named profiles, bound what runs may touch. The hooks added the guarantees no instruction can give: the statements wall and the money-tests gate hold unattended, on the patterns they match. The sandbox is a wall; the rules are a wish; the hook is a rail.
• Cost. Nothing above was free. Rules and skills pay rent every session; MCP reach pays per loaded schema, standing; matched effort pays per turn. The unattended runs moved the cost of watching into the cost of wiring checks ahead of time - and the exit code is worth exactly what someone wired into it.

The through-line underneath all four: every fix here replaced a cost you paid every session with a cost you pay only when the world underneath the fix moves.

The scenario, reconciled

The course defined its teaching scenario before you had installed anything: the same job - onboarding a fourth bank’s CSV - costs 11 exchanges on a cold Monday and 2 by Friday, in the scenario’s own bookkeeping. The reconciliation has two halves, and only one of them was ever about exchanges.

Monday: a cold session and a plain prompt - 11 exchanges of narrating the procedure, correcting misreadings, re-describing things the repo already knew. And the repo as Monday found it carried a second failure the count never measured: the amount parse in app/importers/csv.py ran money through a float, violating rules that were on disk and loaded the whole time.

That violation pre-dated the agent. It sat in a live money path with no pin and no gate, and nothing - written or otherwise - was going to catch it.

Friday: the 21-line AGENTS.md that has been on disk since before the course began - about 115 estimated tokens a session, 150 with the parse-path rule the rules chapter added - plus the budget-build profile drilled into a reflex take the same job to 6 exchanges: the exact checkpoint the skills chapter measured. The import-bank-csv skill takes it the rest of the way, from 6 to 2.

And the zero-violation half of Friday’s promise is carried by machinery Monday never had: the Decimal parse, the pin that feeds 0.29 through and asserts 29, and the hook that re-runs the money tests on every money edit.

11 minus 5 minus 4 lands on 2. That arithmetic is the scenario’s own bookkeeping, not a set of isolated measurements: the 5 belongs to the rules-file-plus-profile combination, the 4 to the skill, and the effort dial spends tokens, not turns. The honest edge of that arithmetic is worth re-reading if the tidiness above sounds too clean.

What this costs you now

Every fix in this course charged something, and this one charges later. A rules-file line is a snapshot of what was true the week it was written; the day a new rule enters the codebase and nobody updates the file, you are back to explaining it by hand, and you will not notice until the agent gets it wrong.

A profile is a snapshot of how much you trusted a piece of work when you named it. A skill is a snapshot of one procedure; the day a format shows up in a shape it never saw, you are the one who notices, extends, and re-teaches it.

The hooks are the same trade in a different currency: they hold on the exact strings they can see, and everything else walks past them. None of that is a defect in the plan. It is the plan’s own shape, restated: every fix here replaced a cost you paid every session with a cost you pay only when the world underneath the fix moves.

Maintaining the files the course added - one rule, three profiles, one skill, two hook scripts, one workflow - is now part of running budgetcli (the course’s running example, a small self-hosted personal-finance API in Python and FastAPI), the same way the code itself is.

Two places to go from here

For the spec-level other half - Foundations. This course was a story: one repo, one week, each primitive introduced exactly when the work demanded it. That is the right way to learn the moves, but it stayed deliberately light on the exhaustive “what is this primitive and every option it takes” view. Foundations is that view - lookup-shaped, authoritative, holding the complete hooks option list and the precise AGENTS.md discovery order, not just the slice the story needed. This course taught the practice; Foundations is the reference.

For the other tools you work across - the sibling courses. Most engineers do not live in one agent, and the habits you just built transfer. The Claude Code course and the OpenCode course are both live now, each running this same teach-by-doing spine - one repo, one week, primitives introduced as the work needs them - so whichever is in your rotation, it is the same journey in that tool’s idiom.

Copilot, Cursor, and Pi courses round out the shelf. The primitives are universal even though every tool spells them a little differently - learn the discipline once and you carry it across all of them.

The whole job

Strip away the tool and every chapter taught one thing. AI coding agents are extraordinary at the general - broad, fast, fluent across languages - and blind to the particular: they do not know your codebase, your conventions, your domain, or that on budgetcli money is integer cents and never a float. You are the inverse - slower, narrower, but you know all of that cold.

And the course added the second half of that lesson: knowing the rule is not what keeps it true. The rules file carried the money rule from before day one, and the float parse shipped anyway. What keeps a rule true is machinery - a hardened parse, a pin, a gate - and knowing which one a situation needs is now part of what you know.

That is the discipline. Not prompting tricks, not a clever command - closing the gap between what you know and what the agent knows, on purpose, every time, with the right container: rules that inform, profiles that bound, skills that package, hooks that enforce. The work on budgetcli is done. Now go close it on the repo that is actually yours.