Skip to content

Blog

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.

Written by

Specification and review

Published: 2 June 2026 Updated: 2 min read

A team I work with shipped a feature twice last month. Same feature, two builds, a week apart. Nobody made a mistake. Two people each pointed an agent at the same ticket, and the ticket meant two different things.

Slow typing used to force agreement

For most of our careers, that did not happen often. Writing code was slow enough that the slowness hid the disagreement. By the time anything ran, the design had been argued into one shape. The cost of typing was a forcing function. It made teams agree before they built.

Take the typing cost away and the disagreement comes back into the open.

The bottleneck is agreeing on what to build

Code generation is solved. A full feature lands for a few dollars in an afternoon. So the constraint moved, and I’d say it moved somewhere uncomfortable. The bottleneck now is agreeing on what to build.

Alignment was always the slow part. We just never billed it that way. It hid inside estimation, inside the meeting where two engineers discovered they meant different things by “done”, inside the rework when a ticket came back. The factory did not create that work. It stripped away the thing that used to mask it.

When the line runs ticket to pull request in an afternoon, a vague ticket does not slow down. It produces anyway, fast and confident and wrong. Two engineers, two agents, two builds, one ticket that was never actually agreed on.

Catch the disagreement in a short doc

The fix is upstream: a short alignment doc before the agent runs. It covers the current state, where this is going, the decisions still open and the patterns to follow. Two hundred lines a human reads and corrects, while changing your mind is still cheap.

That doc is the cheapest place in the whole line to catch a wrong assumption. After the code exists, the same disagreement costs a rebuild.

Precise intent is the skill that does not compress

The teams pulling ahead, in my experience, are the ones who got good at being precise about intent before the line runs. That skill does not compress. No model writes your alignment for you, because the model does not know what you actually meant.

Where does your team’s disagreement actually surface now, in the doc or in the pull request?

Further reading

  1. 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. 2 min readShort post
  2. When code is cheap, the design decision is the expensive part When a full feature costs a few dollars to generate, throwing code away stops being waste and becomes the cheapest way to test an idea. The constraint moves from writing the code to deciding what survives. 1 min readShort post
  3. Review the short alignment doc, not the thousand-line plan The team that popularized research, plan, implement published what they got wrong. Read the code, and put human attention on the short doc before the plan, where a bad assumption is still cheap to fix. 2 min readShort post

All 23 posts on Specification and review

ClientsClient work

Scaling needs named owners

Coding agents scale across teams when named people own the platform, the team practice, the guardrails, and the measurement. Rollout & scale is where that ownership is built and handed to internal owners, in your stack.

Training on this topic: Agentic Engineering for Developers and QA
See Rollout & scale

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