Skip to content

Blog

Fast agents push the bottleneck back to the requirements

Delivery was built around slow coding. With code, review and deployment fast, questions return faster than anyone answers them, and the constraint moves to where requirements are written.

Written by

Specification and review

Published: 28 September 2026 Updated: 1 min read

The questions now come back faster than anyone can answer them.

Delivery grew up around slow coding

Software delivery grew up around one slow station: writing code. Refinement, planning and sign-off ran at its pace, and questions back to the requirements came just as slowly.

Now code, review and deployment are suddenly fast. The process around them was never designed for that.

The pressure runs backwards

An agent hits a detail that is vague or contradictory, and the question goes straight back to whoever wrote the requirement. That is backpressure.

Theory of Constraints says a line runs at the speed of its tightest station. Take that constraint away and it moves. Here it moved upstream.

Robert Glaser, who spoke at Future Coding Day in Copenhagen last week, argues on his Elastic Loop page on why the constraint moved (opens in a new tab) that once building got cheap, the constraint moved to both ends of the loop. One end is deciding what is worth building.

Two teams hit the same wall

Both come from our experience. One client team got fast enough that its backlog ran empty. In their words, the bottleneck is now requirements.

On another project the build keeps stopping on open questions. The team is weighing letting the agents work at night and keeping the day for answers.

The line falls out of step

The rest of the process still runs at the old pace, so the whole line falls out of step. The new bottleneck is where requirements are written and questions answered.

Before you buy engineering another round of speed, look at who answers the questions. If answering takes longer than building, your constraint already sits at the front.

Further reading

  1. Breaking the Loop: Why agents never finish on their own Agents in a software factory always find another problem, another ticket, another improvement. Only a second, much slower loop can say when the work is finished: the one that reaches the market. 22 min read
  2. Architects already solved non-determinism with eventual consistency Architects reject AI-generated code because it is non-deterministic. They solved that exact problem a decade ago in their event-driven systems, and the saga pattern shows where the correctness comes from. 1 min readShort post
  3. YAGNI still holds, for a different reason Cheap code tempts teams to generate the flexible version just in case. But writing was never the only cost. Reading, debugging, and changing the code still cost a human, and YAGNI now protects those. 2 min readShort post

All 23 posts on Specification and review

ClientsClient work

Test the constraint in your system

The Factory Readiness Assessment connects this research to your value stream, your data, and the next decision.

Training on this topic: Agentic Engineering for Developers and QA
See the assessment

Want to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check