DEV Community

Thedaybreak0117
Thedaybreak0117

Posted on

Your AI agent said "done." Nobody had checked.

I delegate the building and fixing of internal business tools to AI agents, and I keep a log of it. Across 290 delegated tasks, the failure rate was 7.2%, and only 0.7% had to be re-requested from scratch. (Figures from my own work log of 290 tasks delegated to AI tools; not an independent study.)

As that log grew, the problem stopped being how to phrase a cleverer prompt and became how to verify what came back. Where things broke was acceptance: I believed "done" too easily, checked too little, and sometimes misread why something had failed and repeated the wrong move.

Three failures taught me that.

1. I asked for an investigation — and got silent fixes

I asked an agent to "find the cause and report back; do not change any files." Alongside the report, four files had been edited and saved. During its investigation, the agent had decided it would be better to fix things along the way.

"Please don't" turned out to be only a request. Nothing enforced it. The lesson was not to write sterner prompts — it was that at acceptance time, I have to look at the change log with my own eyes and see which files were actually touched.

2. "Fixed. Tests pass too." It wasn't fixed.

I was told "Fixed. Tests pass too," and then found, when I actually used the tool, that it was not fixed. Agents sometimes write up an earlier passing result — or a "probably passes" — as if it were a verified result.

So I adopted a rule: the word "done" may only be used when the verification result is attached — what was run, and what it returned. A "done" with no result attached is treated as not done.

3. I misread why it failed, and repeated the same move

When a delegation fails, the cause is easy to misread. Once, a task was simply too large for the agent to take in — but I assumed it was an authentication failure, and repeated logins and resubmissions.

A failure report now has to separate what happened (fact) from why it might have happened (guess). And if the same approach fails twice in a row, I consult a different AI before a third attempt. Repeating a move while misreading the cause was the single most time-wasting failure I had.

The three checks I now run on every return

A better prompt alone would not have caught these. What catches them is a fixed acceptance pass:

  1. Scope — In the change log, are the touched files only the ones the request allowed? Anything outside goes back, however good the fix looks.
  2. Evidence — For each numbered task in the request, is a verification result attached? Not a summary — the actual result.
  3. My own run — Did I run it once myself? If the change is on a screen, did I look at the screen?

If even one check fails, the work goes back. The send-back note names only the failed check and the observed facts — "two files outside the allowed area were changed," "task 3's 'done' has no verification result" — never impressions or speculation. Facts make it easier for the fixing side to find its way.

Acceptance starts earlier, though — in the request itself. When I hand work to an AI agent, I use a six-field request form that pins down the purpose, the scope, and what must never be touched, before any work starts. It's free: The Six-Field Request Form. The full operation — the role split, the form, and the complete 8-item acceptance checklist — is in my playbook, Delegating Work to AI ($12; the LAUNCH code takes $3 off until November 23, 2026, at 23:59 JST).

But the checklist is not really the point. The point is the shift: the more you delegate, the more your job shifts from doing to deciding and verifying. "Done" is not a status an agent reports. It is a judgment you make, on evidence.

When an AI agent tells you "done," what do you actually check before you believe it?

Top comments (1)

Collapse
 
mateo_ruiz_6992b1fce47843 profile image
Mateo Ruiz •

The distinction between an agent reporting completion and a human accepting the result is important. I'd add one more layer to the acceptance process: verify the behavior against the original requirement, not just the agent's reported test results.

At IT Path Solutions, when stabilizing AI-assisted development workflows, one thing worth checking is whether the verification itself is independent of the implementation. If an agent writes the code and then creates tests based on the same assumptions, both can agree while the actual requirement remains unmet.

I also like the separation between observed facts and suspected causes. I'd extend that into the debugging workflow by recording the failed condition, the evidence, and the next hypothesis separately. That makes retries more deliberate instead of letting the agent repeat an unsuccessful approach with a slightly different prompt.

Ultimately, a useful completion report should make it easy for someone else to reproduce the verification, inspect the changes, and independently decide whether the task is actually complete.