Daily workflow

The automation chapter left the stack running with nobody at the keyboard: unattended codex exec runs that fail shut when something needs a permission nobody can grant, a CI workflow carrying the repo’s real commands and honestly labeled never-executed-in-this-course, and the SDK waiting for the day one call isn’t the right shape. That was the last primitive. Every move Codex makes on budgetcli has now been learned, priced, and run at least once. Nothing below is new.

budgetcli, the course’s small running-example repo (a personal-finance API: 166 lines of Python and about 230 lines including tests, config, rules, and README), is what the moves run on. What hasn’t happened yet is running them together, cold, without assembling them from parts. The core fact is the one the course opened with, still true: each new session starts cold except what is written down where Codex reads by default, and what is written down informs, never enforces. What the course changed is what is standing around the repo when that cold session opens. The rules file (AGENTS.md, loaded automatically every session) that sat there before you arrived gained its parse-path rule. The parse itself was hardened to Decimal. A deterministic check went around the money path.

So this chapter adds nothing. It runs the existing stack as reflexes instead of decisions, on the course’s defined teaching job - onboarding a fourth bank’s CSV export, a constructed scenario the repo does not contain - and reports honestly on what holds.

The check this chapter runs

The teaching scenario, stated plainly because its numbers get used below: it defines the fourth-bank job as costing roughly eleven exchanges on a cold Monday with a plain prompt, and the course’s chapters each priced their own move against it. The honest question for this chapter is not a number. It is two questions:

• Do the reflexes fire - right profile, right brief, right recovery - without you reconstructing them from scratch each time?
• When the job runs cold, what does the machinery hold on its own - the Decimal parse, the pin (a fixed test case that feeds 0.29 through and asserts 29, from the subagents chapter), the gate (a hook-run check that re-runs the money tests on any edit under app/importers/ or app/services/, from the extending chapter) - and what still depends on you?

Read the second question the honest way: the machinery half is defensible because it is machinery. The parse converts through Decimal, the pin feeds 0.29 through and asserts 29, and the hook re-runs the money tests on any edit under app/importers/ or app/services/. Friday’s agent is not more virtuous than Monday’s. Friday’s repo is harder to get wrong.

(The same two estimators as the rest of the course - 10 tokens per line of code, 4 characters per token for prose - covered once in the opening chapter and not repeated here.)

The stack, cited back to where it was built

Four lessons, every one already on disk. This chapter builds nothing; it checks whether you reach for the right thing without being asked:

• Make the profile switch a reflex - two named postures, one per mode of work, switched the moment the task changes shape.
• Brief it once, sharply - the four parts of a brief an agent cannot misread, and the habit of rewriting rather than nudging a bad run.
• Recover when the stack doesn’t hold - interrupt, size the damage, steer or restart; and the honest accounting of where the stack’s arithmetic is loose.
• Close the course - the whole arc synthesized, and where to go next.

None of it is hard, and none of it is new information - you have done every one of these moves at least once already. The only thing this chapter teaches is the difference between knowing a move and reaching for it without being asked.

Start with the cheapest habit to build and the one that pays the most: make the profile switch a reflex.