The old product loop — build, ship, measure, hope — was rational when building cost months. Teams front-loaded certainty because a wrong assumption wasted a quarter of engineering time. Hence the research decks, the 40-page specs, the sign-off meetings. All of it was insurance against expensive mistakes.
Then AI collapsed the cost of building. It did nothing for the cost of building the wrong thing.
That's the whole story of how iteration changed. A wrong assumption used to waste engineering time. Now it means you ship the wrong thing at unprecedented speed — and shipped slop isn't neutral. Every half-considered feature spends user trust you can't easily buy back.
The new loop, in plain steps
- Name the riskiest assumption. Not the roadmap item — the belief that, if wrong, kills the feature.
- Build the smallest real version. Working code, realistic dummy data, one flow end to end. Not a deck about it. (Vertical prototyping is the technique.)
- Put it in front of a real person in the real moment. Not a hallway test — the actual situation that triggers their need. If the intent doesn't land in a prototype, it won't land in production.
- Learn, then write the learning down. The loop's output isn't the artifact — it's the sharpened context. Written down, it makes the next loop (and every coding agent involved) start smarter. Artifacts pile up; learning compounds.
Example
the same feature, two processes
Before: six weeks. Research → spec → sprint planning → build → launch → the dashboard shows nobody used it → post-mortem.
After: five days. Monday, name the assumption. Tuesday, working slice with realistic data. Thursday, two target users try it in context. Friday, the assumption is dead, the learning is written down, and the next loop starts.
Killing an idea in five days is cheap. Discovering it's dead in production is not.
What you measure changes too
Screens produced and story points burned measure motion, not progress. The numbers that matter now:
- Loops per week — how often a real assumption meets a real user
- Kill rate — dead ideas found early are a sign of health, not failure
- Time to felt value — does shipped code deliver something a user would miss?
The quality ceiling nobody budgets for
AI-generated output has a visible sameness — teams routinely iterate two or three extra rounds just to escape the default look. That's not wasted time; that's the new baseline. Budget the loops, or ship something that looks like everyone else's first draft. (Why that's dangerous: Taste Is the Last Moat — judgment is what's left when capability is rented.)
Try this week: take the riskiest assumption on your roadmap and timebox one full loop — build, test with two real users, decide — to five days. Whatever happens, you'll learn more than the spec would have told you.
Go deeper: why the old process felt safe (and no longer is)
Specs and sign-offs were certainty rituals — reasonable when mistakes were expensive and slow to correct. But front-loaded certainty is bought with time, and it's still guessing: the document just makes the guess look official. When a working version costs a day, the cheapest certainty available is contact with reality. The ritual didn't become wrong; it became the expensive option.
The bottleneck didn't disappear. It moved — from building to knowing what to build, and from shipping to judging what you shipped. Iteration is how ambitious teams keep their speed pointed at something worth reaching.