The worst failure mode of agentic coding is not a crash. It is the agent saying 'Done!' in a confident tone, having changed three files, and the thing it was actually asked to fix still broken. No error, no trace, nothing in red.

You only find out when you open the demo.

Why it happens

Agents are good at the shape of completion. They write the code, they run a test, the test exits zero, they declare victory. The trap is that the test they ran was already green before they started. They touched the surface area of the problem and reported back the status of a different check.

Nobody wrote the prompt that said 'prove the specific failure I gave you is gone.' So the agent proved something else and called it a day.

The cheap verifier

I stopped accepting 'done' the moment it appeared. The rule now: before I believe an agent, it has to hand back the exact artifact I would have checked if I were doing the task myself.

For a bug fix, that means the failing command before and after. The actual output, pasted back, not summarized. If it says 'I fixed the 500 on POST /orders,' it should show me the request and the response that now returns 201. If it can't produce that, it didn't do the thing — it did a plausible thing.

For a feature, that means the diff plus one running example. For a migration, the actual schema after applying it. None of these are fancy. They are just the thing a senior engineer would open first.

This works because it's local

The reason this is cheap to enforce: the artifact is usually already on the machine. A failing test output, a curl against localhost, a grep over the real files. You don't need an expensive replay harness; you need to refuse to take a self-report at face value and ask for the one screen you would have looked at anyway.

When the task is API-shaped, that one screen is the live endpoint run against the contract. We kept that local and asked the agent for it back, and the rate of imaginary completions dropped a lot. A pasted curl beats a paragraph.

What to change in your prompt

You don't need a long verification framework. Add one line at the end of the task:

"Before you say done, paste the exact command and output that proves the original failure no longer reproduces. If you cannot, say so."

That last sentence matters. It gives the agent permission to report that it is stuck, instead of manufacturing a tidy end to the run.

An agent that lies by omission, gently, is still an agent you can't trust. The fix isn't a smarter model. It's refusing to let self-report be the acceptance test.

What's the smallest thing you ask for back before believing an agent's 'done'?