Verification is the bottleneck, not generation

Generating a plausible pull request now takes an agent minutes. Deciding whether that pull request is actually correct still takes an engineer roughly as long as it always did. That mismatch — not model quality — is the current constraint on how fast a team can safely ship with agents.

The stage that got fast, and the one that didn't

In the figure, "generate" is drawn thin on purpose: it's the stage that changed. "Verify" is drawn wide because it didn't shrink to match — it's still tests, types, human review, and runtime checks, done at roughly the same pace as before. Anthropic's own engineering guidance on agents describes why this stage can't just be automated away: "human review remains crucial for ensuring solutions align with broader system requirements," even when the code itself passes automated checks (Building Effective Agents). Passing tests tells you the code does what the tests check. It doesn't tell you the tests check the right thing.

Where the four bands actually catch different failures

The four bands in the verify stage aren't redundant — each catches something the others miss. Types catch a class of bug before anything runs. Tests catch behavior the types can't express. Review catches things no test was written for, including "this is technically correct but not what we should be doing." Runtime checks catch what only shows up under real data and real load. An agent that only runs tests and calls itself done has covered one band out of four.

The same article names the guardrail

The mechanism the same Anthropic post points to for agentic coding specifically is feedback, not trust: "code solutions are verifiable through automated tests; agents can iterate on solutions using test results as feedback." That's a reason to lean on tests harder, not a reason to skip the review band — the post pairs that line directly with the caveat about human review above. Automated feedback makes generation faster to converge; it doesn't replace the check for whether the destination was the right one.

Budget your time at the wide stage, not the thin one

If verification is genuinely the bottleneck, then time spent making generation marginally faster — a better prompt, a slightly larger model — has a low ceiling on payoff. Time spent making the wide stage faster or more reliable — a stricter reviewer prompt, tests an agent can't quietly delete, a fast feedback loop that runs on every edit — pays off on every task that follows, not just the current one.

Try it today

1. Time your next agent task from prompt to merged PR, and note how much of that time was generation versus you checking the output.
2. Identify which of the four verification bands (tests, types, review, runtime) is currently weakest on your team, and fix that one first.
3. For one task this week, write down what "verified" means before you start — which checks must pass — instead of deciding after the fact.
4. Ask the agent to run its fastest checks (types, lint, unit tests) automatically after every edit, so failures surface before you ever look at the diff.
5. Keep the slow checks (full integration suite, human review) as a deliberate gate before merge, not something skipped under time pressure.

Where this breaks

Automated checks only catch what someone thought to encode — a comprehensive test suite still misses the requirement nobody wrote down. Widening the verify stage also has a real cost: more checks mean more time per task, which can quietly erase the speed gained from faster generation if nobody is watching the total. And a team that treats "tests pass" as equivalent to "verified" has just moved the false confidence from the agent to the CI badge.

Next: tests an agent can't game — because not every green check means what it looks like it means.