There are two ways to hand work to an AI agent, and most teams only know they've chosen the wrong one when the review queue tells them.
Homework is when you hand the agent options. Here's the palette, here's the component library, here's a folder of guidelines; go build a settings page. The agent makes dozens of unguided choices (which red, which spacing, which variant, which pattern), each one a small probabilistic bet placed against the average of the internet. Then a human sits in review and grades the bets. The agent did homework; now you're marking it. The bottleneck didn't disappear. It moved into your calendar.
Delegation is when you hand the agent decisions. The values are tokenized. The meaning is encoded: this token is for danger, that one is brand. The intent is written in a spec that can't be misread. The delivery is wired so the right context reaches the agent at the moment of work. Now "build the settings page" isn't a hundred open choices. It's execution against decisions already made. Review shrinks from grading every guess to checking the exceptions.
The difference between those two modes is the whole tokens-to-agents argument, and it's why the four layers matter as a chain rather than as a menu.
Because each layer alone leaks. Tokens without semantics: the agent sees every value and no meaning, and improvises the meaning (ours got to 80 percent this way, slipping exactly at the component details). Semantics without specs: the agent styles correctly and builds the wrong thing, beautifully. Specs without runtime delivery: intent exists but never reaches the agent mid-task, so it might as well be in a drawer. Every layer hands the next one the context it needs; break the chain anywhere and guessing re-enters there.
Stack them and something categorical happens: probabilistic guessing gets replaced by deterministic context. The agent stops guessing which red because the semantic layer answers it. Stops guessing the button's props because the contract answers it. Stops guessing what done means because the spec answers it. Reliability stops being a property of the model and becomes a property of your system. That's the shift that matters, because models improve on someone else's schedule; your system improves on yours.
This is also the honest answer to "the agents will just get smarter, why build any of this?" Smarter helps homework; it doesn't convert homework into delegation. A brilliant new hire still can't know your brand red from your danger red on day one; the information isn't in their head because it's nowhere readable at all. Intelligence doesn't substitute for encoded decisions. It just guesses more fluently, which is arguably worse, because fluent wrong survives review longer.
I want the soft spots on the table too, because the case is stronger with them in view. The maintenance is real: living specs and governed systems run at something like a third of the effort, ongoing, and the people doing this seriously say so out loud. Brownfield is immature: encoding intent for a decade of tangled code is still an unsolved craft. And the far end of the road has honest skeptics: Böckeler, who drew the spec maturity map, warns that spec-as-source could inherit old model-driven development's rigidity plus LLM non-determinism. The direction is clear even where the timeline isn't. Self-healing loops and agentic IDEs (Kiro is already collapsing roughly forty-hour builds into about eight hours of human effort) are pulling this from experiment toward standard practice. We're not all the way there, and pretending otherwise would cost this argument its credibility.
But the bet itself is simple enough to say in one line: increasingly, the spec is the prompt, and the code is just its current output. Delegation over homework. Systems that encode decisions over teams that re-litigate them per task. The architects who get there first aren't the ones with the best prompts. They're the ones treating the design system as infrastructure today, so that every future agent, on every future model, inherits their decisions instead of guessing at them.
That's the whole stack, and the whole bet. It's the one I'm making in production, and so far, it's paying.
Start where the leverage is: the free agent-ready starter kit at tokenstoagents.ai/kit gives you the readiness checklist and every template in this series.