Refinement, not coding, was the bottleneck all along
Several teams turned the same rough story into wildly different plans. The agent did not create the ambiguity. It showed that deciding what the work means was always the slow step.
Written by
-
Benedikt Stemmildt Founder & Co-CEO
Published: 23 June 2026 Updated: 2 min read
We ran the same rough story through several agent setups, and what stuck with me was how much hidden decision work the outputs dragged into the open.
One story, many readings
Same input for everyone. Same task: turn this rough ticket into something a team could actually build.
The results barely looked like they came from the same story. One team kept it tight. Another expanded it into a sprawling technical plan. The rest landed somewhere in between, each one a different reading of what the work actually meant.
The easy read is that agents are unpredictable. I don’t think that’s the lesson, though. The agent didn’t create the ambiguity. It made it impossible to ignore.
The keyboard was never the slow part
For years we talked as if coding was the bottleneck. Code was slow to write, so every productivity conversation pointed at the keyboard: faster autocomplete, better IDEs, better generators.
Now the line turns a ticket into a pull request in no time. And the moment it does, the old hidden work stands up in plain sight. Refinement was the bottleneck all along.
What does this story mean? What’s in scope? Which edge cases matter, and what does done actually look like? Which of the implied requirements are real, and which are just noise?
That work never lived in the compiler. It lived in meetings, hallway conversations, product intuition, and the memory of the senior people who had watched the system break before.
A vague story gets built anyway
A vague story doesn’t get sharper because an agent touches it. It gets built, confidently, on whichever interpretation the agent happened to pick. Sometimes that’s a useful guess. Sometimes it’s an expensive one.
Point the agents at the ambiguity first
So the move that helps is aiming the agents at the ambiguity before they build anything. Let them surface the missing decisions, propose the acceptance criteria and dig out the edge cases. Then the humans make the calls. That’s still refinement, just with a much better mirror held up to it.
That shifts the job. The question stops being “who can implement this” and turns into “who’s allowed to decide what it means.”
When your team feels slow right now, where is the delay really sitting: in writing the code, or in deciding what the work actually is?
Further reading
Written by
-
Benedikt Stemmildt · Founder & Co-CEO
More on Specification and review
- An autonomous agent has to verify its own work Agent-built features can look finished and be broken. The user will not check, so the agent has to, and that changes how you build one.
- 1,300 agent PRs a week rest on three million tests Stripe's 1,300 unattended pull requests a week get quoted everywhere. What makes them work is the test layer and the harness underneath the agents.
- When code is cheap, agreeing on what to build is the bottleneck Slow typing used to force teams to agree before they built. With agents, a vague ticket produces two confident builds, so the fix moves upstream into a short alignment doc.
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 Product Managers and Product OwnersWant to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check