Stop 14 · What this course left out
The last thing a course should do is say where it stops, and where to go from there.
What you have
What it is gave you the shape: an and a loop, and then you wrote one. What the model is like covers two properties of the model itself: it varies (stop 4) and it invents (stop 5). The text you write covers the two kinds of text you write and what each can change. What it costs is money, a ceiling, and one way of pushing both somewhere else. When it goes wrong is everything off-plan: text that lies to it, actions that cannot be undone, calls that fail. How you know is how you tell whether a change helped (stop 13).
These are not parallel facts; they share one structure. Everything the model knows about the task is in the request — the array, the system prompt and the tool descriptions — and everything it can do is in that tool list. Faced with behaviour you have not seen before, asking those two questions usually locates it.
Watch a run nobody arrangedAgentTape
What it isEvery run in this course was written: each step and each token count was chosen to make one point clearly.
Why this course left it outReal runs are not that tidy. They are longer and messier, with long stretches of dull repetition and the occasional failure nobody would have thought to write. Teaching needs the tidy version; understanding needs the other one.
Where to goAgentTape replays a Claude Code session that already happened: a timeline, the messages array as it grew, and where the tokens went. The way of reading you picked up at stop 2 works there unchanged.
Frameworks
What it isThe loop in this course is thirty-odd hand-written lines. In a real project that part usually comes from a framework: tool registration, retries, state, concurrency and tracing are already written.
Why this course left it outWriting it by hand first is deliberate. A framework hides this loop, and when something hidden goes wrong you need to know what was hidden — which is what all fourteen stops were about. In the other order you end up with a system that runs and that you cannot explain.
Where to goFramework documentation reads much more easily now: you know what is inside its run(), and you know which questions to ask — how tool results are truncated, how failures are retried, what it does when the context fills, and where approval hangs.
Evaluation in earnest
What it isstop 13 gives the smallest version that works: ten tasks, a pass count, judged by hand. Doing it properly involves more — larger sets, automated grading, results broken out by category, running on every change rather than when you remember, and feeding production failures back into the set.
Why this course left it outBecause ten hand-judged cases already catch most of the I thought that fixed it cases, and the investment a full evaluation setup asks for is enough to stop someone starting at all. Get ten first; talk about the rest afterwards.
Where to goThe next two moves are usually to write the pass conditions as code — even if that is a few regular expressions and a few assertions — and to run the set in CI so it fires on every prompt change. After those two, the larger tooling starts to be worth its cost.
Multi-agent systems
What it isThe last section of stop 9 covers only the simplest arrangement: one agent hands a stretch of work to another. Beyond it there are many shapes — agents in parallel, reviewing each other, split by role, sharing state.
Why this course left it outBecause there is not much settled knowledge here yet, and unsettled material does not belong in a course about fundamentals. The more practical reason: most problems that look like they need several agents are solved by one agent with better tools, more cheaply and with less to debug.
Where to goIf you do go there, the thing worth carrying from stop 9 is the cost of a boundary: each layer you add is a layer the outer one can no longer see into. The common failure in these systems is not that an agent got something wrong; it is that nobody could see that it had.
Four directions
The four areas above are what this course deliberately does not cover. Each says why, because the reason is usually more useful than the material: it tells you when to go and look, and when you do not need to yet.
After fourteen stops what you have is a mental model you can take apart: one array, one loop, some text you wrote, some tools you supplied, and the ways each of them breaks. Its value is not that it is complete but that when you meet something you have not seen, you know which layer to open.