The demo is always the same. A task that would have taken a day gets described in two paragraphs, the agent reads the repository, proposes a plan, and forty minutes later there is a diff. Tests pass. The code is idiomatic - more idiomatic than what I would have written at 6pm. It feels like leverage.

Three weeks later something in that diff is quietly wrong, and the test suite that was supposed to catch it does not, because the test was written from the same misunderstanding as the code. Nothing about this is surprising in hindsight. It is surprising how long it takes to notice.

I keep coming back to one sentence: the cost of producing code collapsed, and the cost of establishing that code is correct did not. Everything difficult about agentic development is downstream of that gap.

Why review stops working

Human code review worked because effort and correctness were loosely correlated. A rushed change looked rushed. An unfamiliar pattern looked unfamiliar. Reviewers were pattern-matching on the shape of the author's effort as much as on the logic.

Agent code breaks that signal completely. It is uniformly confident, uniformly formatted, and uniformly plausible - plausibility is literally what the model was trained to produce. There is no tell. A subtle logic error and a correct implementation arrive in the same prose, with the same cheerful summary at the end, and the same test file that passes either way.

So review has to shift from "does this look off?" to "what would have to be true for this to be wrong, and did I check it?" That is a much more expensive question, and it does not scale by reading harder.

The four failure modes I keep seeing

The tautological test. The agent writes the implementation, then writes a test that asserts what the implementation does. The suite is green and the specification was never encoded anywhere. This is the most common failure by a wide margin, and the hardest to spot, because the tests look good - they have arrange/act/assert, they cover the happy path and two edge cases, they are even readable.

Satisfying the test instead of the requirement. Given a failing test, an agent will find the cheapest change that turns it green. Usually that is the right change. Sometimes it is a special-case branch, a loosened assertion, or a narrowed input range. The agent is not cheating; it is optimising the objective it was given.

Silent scope creep. "While I was in there I also extracted a helper and renamed two functions." Each step is defensible, the aggregate is unreviewable, and the diff no longer matches the task description that justified it.

Confident deletion. Removing a guard or a fallback that looks redundant when you cannot see the incident it came from. This is the one that reaches production.

What actually helps

Write the acceptance criteria before the agent starts

Not a ticket description - something executable. A failing test, a script that reproduces the bug, a fixture with known-good output. If I cannot write the thing that will prove success, I do not understand the task well enough to delegate it yet, and neither does the agent.

Review the plan, not only the diff

A plan is cheap to read and cheap to correct. A 600-line diff is neither. When I gate on the plan, most of the expensive review happens before any code exists, and the diff review becomes a check that the plan was followed rather than a reverse-engineering exercise.

Grade the tests

The question is not "do tests pass" but "would these tests fail if the code were wrong". Two cheap probes:

  • Revert the implementation to the previous version and confirm the new tests fail. If they pass, they are not testing the change.
  • Break something deliberately - invert a condition, drop a guard - and confirm a test notices.

An agent can do both of these itself, which is the useful part: it turns "trust me" into a mechanical check with an artifact attached.

Keep the diff small enough to hold in your head

This is unfashionable because it constrains throughput, which is exactly what people bought the agent for. But a diff I cannot hold in my head is a diff I am rubber-stamping, and rubber-stamping with extra steps is not review.

The uncomfortable conclusion

Delegation without verification is not delegation, it is guessing faster. The teams that get value from agents are not the ones with the best models - models converge, and prices fall. They are the ones that got serious about verification: specifications that exist before implementation, tests that can fail, review scoped to something a human can actually check.

That work is unglamorous, it does not demo well, and it is the entire job now.