You've reached the end: the week on budgetcli, 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. budgetcli came to you as a friend’s weekend project — a self-hosted budgeting API, lightly documented, holding the promise of tracking your own money but not yet trustworthy enough to do it. Over the chapters you turned it into something you’d actually run.

You installed Codex, pointed it at the inherited repo, and shipped a first reviewed change — a small CSV date-parse fix — so you’d seen one full turn of the loop before anything was at stake. The work spanned days, so you learned to carry a session across time: resume yesterday’s thread, fork to try two categorisation approaches side by side, compact a window before it filled mid-refactor. Then it got real — this is your financial data — and you set the two trust dials, approvals and sandbox, deliberately and separately, and hit the teachable moment where the agent reached for the network and couldn’t, because workspace-write keeps it off by default.

When Codex kept reintroducing the float-money bug and the wrong category taxonomy, you stopped re-explaining and wrote it down once in AGENTS.md: money is integer cents, never float; here’s the category list; here’s how dates are handled. You learned to dial reasoning effort — light for a boilerplate CRUD endpoint, heavy for designing the categorisation rules engine — instead of paying maximum for everything. You pushed the noisy, high-volume work into subagents, fanned the three-year recategorisation across parallel workers, and gave each a git worktree so a multi-file money refactor could run several agents at once without trampling each other.

You packaged the per-bank CSV import — a different shape for every bank, the same procedure every time — as a reusable skill the model invokes on its own. You extended Codex’s reach to the external exchange-rate API over MCP and gated the dangerous edits with hooks that block writes to the real ledger and run the tests after every change. You let the whole thing run headless: the monthly report generated with nobody watching, the categoriser and tests wired into CI on every push. And in this last chapter you smoothed all of it down into reflex — two profiles you switch by instinct, prompts tight enough that runs go where you meant, friction shaved off the surface you touch most.

The point was never any single command. It was the habit underneath them: treating context, trust, and effort as things you steer on purpose, and doing it fluently enough that you stop noticing. An inherited weekend project became a service you trust with your own money — not because Codex is magic, but because at every step you closed the distance between what you knew about budgetcli and what the agent knew. You have that habit now.

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’s the right way to learn the moves, but it deliberately stayed light on the exhaustive “what is this primitive and every option it takes” view. Foundations is that view — lookup-shaped, authoritative, the place to go when you need the complete option list for hooks or the precise discovery order for AGENTS.md rather than the slice the story needed. It’s the same picture from the other side: this course taught you the practice; Foundations is the reference.

For the other tools you work across — the sibling courses. Most engineers don’t live in one agent, and the habits you just built transfer. The Claude Code course already exists and runs on this same teach-by-doing spine — one repo, one week, the primitives introduced as the work needs them — so if Claude Code is in your rotation, it’s the same journey told in that tool’s idiom. And the opencode course is next, built on the identical structure; when it lands it’ll teach the same instincts a third way. 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 don’t 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. Every move in this course was a way to hand the agent the context it was missing: rules that persist it, skills that package it, profiles that bound it, prompts that aim it.

That’s 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. Now go close it.