There are two ways to work with an AI agent and I had tried both.
Write the thing yourself and hand over only the tedious parts.
Or hand over the whole task and audit whatever comes back at the end.
The first is slow.
The second is fast right up until it is wrong, and by then the wrong thing is finished.
I expected this series to be about forcing a third option into existence.
Nine parts of making an agent follow a workflow it would rather skip.
That is not what happened.
I never had to enforce it once.
The queue that started this had a payload contract nobody had verified, and each phase after that cost me something before it gave anything back.
A plan that would not move until the risk register named the provider contract the brief had only guessed at.
A build that missed nothing except what my own brief left out.
A review that stopped handing back a feeling and started handing back a verdict on every requirement I had already called done.
A matrix instead of a trusted green run.
A rollback with a name on it before anything got called shipped.
And a retrospective that would not let a lesson through until it had checked itself against the trail.
Eight parts of that.
What I did not expect was which part turned out to be automatic.
The Fight I Expected Never Started By the time I finish writing a requirement, I already know roughly what it is going to cost.
Most engineers do.
You can feel the difference between a one-line fix and something that is going to touch four files and a migration before you have written a single line of it.
What I assumed was that the agent could not feel that, and that policing the gap would be my job forever.
Reminding it to run the chain.
Catching it when it decided a spike was small enough to skip.
It has not needed the reminder.
Small bugs do not trigger a brief and a plan, and they should not.
A standard requirement, a spike, anything long or cross-cutting, runs the full cycle in order.
The classification lands where I would have put it, without me putting it there.
That is not the agent being clever.
It is the one part of the system I have not shown you across eight parts: a short instruction file at the repo root that classifies every request before anything is touched, with the seven skill files sitting underneath it.
Trivial work gets handled inline.
Standard or complex work runs the chain, each phase reading the previous artifact rather than the conversation.
Underneath that sit the pieces that never earned their own article because they are plumbing, not phases: a slug that keeps every artifact for one item under a single name, a requirement manifest that separates what I actually said from what was inferred, an exit gate no artifact passes on its own say-so, and a waiver that leaves a paper trail even when skipping a phase was the right call.
It is less machinery than it sounds like.
It is mostly a rule about when the machinery applies.
The Chain Gave Me Somewhere to Stand It took me most of the series to notice where I had ended up standing.
Not at the keyboard writing every line.
Not at the end of the process reading a finished diff and trying to reconstruct whether it matches something I described days ago.
Somewhere in the middle, at the gates, watching each artifact land before the next phase reads it.
That position did not exist in either of the two ways I had worked before.
When I was writing everything, there was nothing to review because I was the one making the decisions as I went.
When I was handing off whole tasks, the only place to stand was at the end, where every correction is expensive because the work is already finished.
The chain put me somewhere in between and gave me something specific to do there.
Approve the brief or send it back.
Read the plan before the build starts.
See a requirement come back partial and decide whether it holds up the work.
Every one of those is small on its own.
Together they are the difference between hoping the result lands on what I asked for