Case study
Delegating substantial delivery to agents, and checking it.
With the edges governed, the backlog could be delegated in waves of parallel agents. This is what that took: a roadmap and acceptance criteria agents could read, gates each wave had to pass, and people who decided whether what came back was right.
What was delegated
The repository knew enough about the product to say what right looked like. That made it possible to delegate the definition of the work, not only the work.
- The roadmap
- Generated from the repository's own context and kept there, organized into waves so each wave starts from what the last one established.
- Acceptance criteria
- Written for each piece of work from the same context, so the agent doing the work and the person checking it were reading the same definition of right.
- Definition of done and tests
- Set before a wave started, so the integration and testing gates had something concrete to check against.
How a wave runs
Within a wave, agents run in parallel. Between waves, what they learned is folded back into the plan before anyone starts again.
- Backlog
In the repository
Roadmap, acceptance criteria, definition of done and test expectations, written from the repository's own context and kept there.
- Wave
Agents in parallel
Several agents take separate pieces of the wave's scope at once, composing pages from the component library and reading the record through its standard interfaces.
- Retrospective
One from each agent
Each agent closes its piece with a retrospective: what was built, what was unclear, what it left for someone else.
- Gates
Integration and testing
The wave's work is integrated and tested against the acceptance criteria before it counts as done.
- Synthesis
A revised backlog
Retrospectives and gate results are folded into the backlog. The next wave starts from the revised plan, not the original one.
Next wave, from the revised backlog
One delivery run
One run, several waves over about two days, returned roughly forty wired pages: specifications met, data flowing between pages, minor adjustments rather than rework.
Follow-up loops ran the same way for the edge cases that only show up once pages are connected and used. Because the criteria lived in the repository, each loop started from the same definition of right rather than from a conversation about what had been meant.
By Michael's own reckoning, the run compressed what he would have planned as months of work into days.
The compression came from the governed edges, the parallel waves and the delegated definition of done.Where judgment sits
Agents answer the acceptance criteria. People decide whether the criteria were the right ones, and whether what came back is a product.
An independent QA reviewer who has tested Michael's products for years reviewed the result across environments, the way a user would. What the product is, which trade-offs are acceptable, and when a wave is genuinely finished stayed with people throughout. The agents were fast inside the edges. The judgment stayed in the room.
If you are about to do this
- Delegate the definition of done, not only the work.
When acceptance criteria and tests come from the same context as the backlog, the agent and the reviewer are reading the same thing. Most rework starts where they are not.
- Close every wave with retrospectives and a synthesis.
Parallel agents are only as good as what gets folded back into the backlog before the next wave starts.
- Keep an independent reviewer who tests as a user.
Someone who has tested your products for years will find what the authors, human or agent, did not see.
Need a leader who can
build with AI?
Let's talk about the product challenge, the team, and the outcomes you need—whether you're improving how your business runs or building something new.