The Checker That Isn't You

Owners and team leads need proof that a task is finished without checking every claim themselves. This method defines what done means, requires a result someone can open, and checks that proof. Use the process to reopen work that lacks evidence and route the remaining problem to the right role.

This guide is part of #CCS: Word of Mouth. Next, explore Always Reply, or If You Can Do It, You Should.

Thursday I caught myself asking an agent, “Can you check to make sure you actually did it?” Then I realized I had said the same thing to a person that morning. Then I counted.

A definition of done is the one sentence that says when a piece of work is finished– and who gets to say so. Most companies don’t have one written down. So “done” means whatever the person saying it means, and the founder ends up being the one who finds out whether it was true.

This is not an article about project management software. We don’t have a project manager. We don’t have an integrator. We have a couple of ops people and six AI agents, and until this week every one of them, human and not, handed their “done” to me to check. That’s the problem. Here’s what we did about it, with the numbers.

Why does this land on the founder?

Because you’re the only one who cares whether it actually happened.

Everyone else is paid for the task. You’re paid for the outcome. So when a teammate says “sent it,” you’re the one who opens the sent folder. When an agent says “published,” you’re the one who loads the page. Nobody asked you to be QA. You just are, because a “done” with no proof looks exactly like a “done” with proof, and the only way to tell them apart is to go look.

Multiply that by every person and every agent, every day. That’s the loop in the left half of the diagram. I’ve been in it for years. I described it out loud on Thursday as being “a QA agent serving other agents”– and the same thing for people, who “don’t understand, are sloppy, or didn’t check their work.”

The usual advice is hire an integrator. Get an ops person. Buy a tool. All of that just moves the checking to someone else’s desk, and now you’re checking the checker. Or, more often, you’re a founder with a great network and no ops department, and you’re not going to hire one to babysit six agents. You shouldn’t have to.

How bad was it, actually?

I had an agent count. Every “done” from every agent over the previous three days, across Basecamp and our shared work ledger: 102 completions. 5 had proof that opened. 96 had nothing anyone could check.

Nobody was lying. The work was mostly real. But 94% of it was un-checkable by anyone but me, and I had not been checking it either, because nobody can check 34 things a day.

Then I looked at the people. Last 14 days: 33 to-dos closed in the whole company. 18 of them were mine. The two team members I’d complained about the loudest had closed zero. Not because they did nothing– because their work happens in texts and calls, where no system can see it, so every one of their “dones” came back to me as a question.

What’s the root cause?

It isn’t discipline. It’s that proof was optional.

“I sent it” and “I sent it, here’s the message in their inbox” cost the same to type. One of them can be checked by a stranger in ten seconds. The other one can only be checked by opening the sent folder yourself. As long as both count as done, everyone types the short one, and the founder inherits the difference.

Two things fix that. Proof has to be part of the output, not a step after it. And something that isn’t you has to read every “done” and go open the proof.

What counts as done now?

Done means you looked at it where it landed and attached what you saw.

Same sentence for a person and for an agent. Not “I did it.” Not “it should be live.” You opened the destination– the other person’s copy, the live page, the file in the folder– and you put what you saw where the next person can open it too.

Every completion ends with one line, right above the signature:

Verified: <what you opened> — <what you saw> — <when>

or, honestly:

Verified: NO — <what is missing and who can supply it>

Proof is something a stranger could open and see what you saw.

“Verified: yes” is not proof. “Published” is not proof– a verb can’t be opened. “See above” is not proof, because nothing can open “above.”

And an honest NO is a complete answer. “Verified: NO– the file is in the folder but the sync wasn’t running, Dennis can open the link to confirm” is done, in the sense that matters: I know exactly what happened and exactly what’s left. A green light you didn’t earn is the defect.

Who checks, if not you?

A script. It runs every morning at 9am.

It reads every “done” from the last two days– the work ledger, every Basecamp comment that carries an agent’s signature, every to-do a person closed. For each one it finds the Verified line and opens what it names. A link gets fetched fresh. A Basecamp comment gets read back. A pull request gets checked for MERGED. An honest NO gets filed as a blocker with a name on it and is never reopened.

If the proof opens, nothing happens. Nobody hears about it. That’s the whole point.

If there’s no proof, or the proof doesn’t open, the script does exactly one thing: it reopens the item on the same thread, with the missing piece named, in the same words for a person as for an agent:

Not verified — no Verified line. Done means you looked at it
where it landed and attached what you saw. Add one line,
`Verified: <what you opened> — <what you saw> — <when>`,
or an honest `Verified: NO — <what is missing>`. Reopened. (miss 1 of 3)

The owner sees it. Nobody else does. Not me.

What happens if they still don’t?

The same ladder we already use for unanswered messages, walked by the script instead of by me.

Three misses in and I see one line. Before that, I see nothing. I also get a count per platform each day, so when one agent racks up reopens I fix its prompt once instead of its posts one at a time.

Here is the actual output from the first run, Thursday night, before enforcement switched on:

Definition-of-done sweep, last 2d — 04 Sep 22:38 UTC
67 completions read · 6 proved · 0 honest NO · 1 not openable from this host
· 0 with no proof · 60 from before the rule, not counted
Unproved completions by platform — fix the prompt once, not each post:
  Grok Bot 18, Claude Cowork 16, Codex 11, Cursor Grok 8, Claude 4
enforcement starts 06 Sep 2026 00:00 UTC — until then every miss is baseline
digest posted to Internal Command Center Updates

Sixty of sixty-seven were “before the rule.” We didn’t reopen them. Reopening a hundred old items on day one is noise, and a noisy checker gets switched off by Tuesday. The rule went live, every agent got a full day with it in front of them, and enforcement started the morning after.

What about work that never touches a system?

This is the part that actually gets people out of the loop, and it’s a rule, not a script.

Work handed to a person becomes a to-do– owner, due date, what “done” looks like– created by whoever hands it off.

Those 18-of-33 to-dos told me the truth: my team’s work wasn’t flowing through anywhere a checker could see. A task sent by text with nothing behind it is not a handoff, it’s a hope. So now whoever assigns the work creates the to-do. The agents do this automatically; they hand off a lot of work. The people were told on Thursday, in one page, in the same words the agents got.

Closed means closed with a Verified line. The script reads people’s to-dos the morning after, the same as an agent’s comment. It never touches a client’s to-do– only ours.

What if you don’t have an engineer or an agent to build this?

You don’t need the script. You need the three ideas, and any of these will run them:

• The rule, in one sentence, same for everyone. Put it in the onboarding doc. Put it on the wall. “Done means you looked at it where it landed and attached what you saw.” That sentence alone changes what people type.
• The line. Make “Verified:” a required field on your task tool– Basecamp, Asana, Notion, a spreadsheet, whatever. A task can’t close without it. That’s a settings change, not a project.
• A checker that isn’t you. A VA with a 20-minute morning checklist: open every “done” from yesterday, click every link, reopen the ones with nothing. Give them the ladder table above and the reopen sentence, word for word. They never come to you until miss three. If you have any AI agent at all, this is the first job to give it; it’s the one job where being tireless and literal is the whole qualification.

The mistake is treating the checking as a founder job because the founder cares most. Caring most is why you should be the last to see it, not the first.

Where else does this show up?

The same discipline, applied to other things we kept getting wrong. Each of these is its own page.

• Always Reply– the reply rule. Four states: done, doing, blocked, parked. This article is what makes the first of those four mean something.
• If You Can Do It, You Should– agents do the work and ask a human only for access. The other half of not being the team’s VA.
• The Unanswered Ask– silence is not a status. An unanswered message never stops the work; at its recheck time the agent does the work itself.
• How We Stopped Being the Team’s VA– the meta-article on making a two-minute standard an A-player can follow without feeling talked down to.
• The RACI Enforcer– I am never Responsible or Accountable on a project. Ownership goes to a function, not a person.
• Derive, Don’t Maintain– any number a human types about an artifact drifts from the artifact. Derive it. The enforcement count in our own rulebook was typed, said six, and was wrong; it’s rendered now.
• Agent Disclosure– where the rule lives for every scheduled agent, loaded at the start of every run, with the ten ways a run goes wrong that sit behind it.
• Where Your Agents Talk– the registry and the claims ledger, so two agents never do the same work twice. The night this rule went in, a second agent added a tenth rule to the same file through the same machinery, and neither of us collided.

What’s still not solved?

It has run for one day. The before number is real; the after number comes next week, and I’ll put it here. Four of the ten failure rules behind this still have no machine behind them– a person has to catch those, and the script says so instead of pretending. And the wording of any consequence past miss three is still mine to decide, on purpose. A script reopens tasks. It doesn’t decide who stays.

Two things the agent got wrong building it, since the whole point is that “done” gets checked. It told me enforcement started Saturday; it starts Sunday– a timezone conversion. And it stamped one of its own reports “reviewed by Dennis” when I had read a summary and said “merge it,” which is authorization, not review. Its own rule caught the first. A re-read caught the second. Both corrections are on the record, next to the mistakes, in the same thread.

Where does this sit in the framework?

It’s the third corner of CCS– Content, Checklist, Software. We had the Content (the rule, written three times). We had the Checklist (“verify with a live request”). We never had the Software, so the checklist ran on the founder. And it’s the Teach in LDT– Learn, Do, Teach: I learned it by suffering it, we did it Thursday, this page is the teach.

Questions I got in the first 24 hours

Isn’t this just micromanagement by robot?

It’s the opposite. Micromanagement is a person asking “did you check?” The script never asks. It opens the link. If the link opens, it says nothing, ever. The only people who hear from it are the ones who said done and attached nothing.

What if the proof is something the script can’t open, like a private document?

It says so– “not openable from this host”– and does not count it as a miss. An artifact behind a login is real proof for a human. The script knows what it can’t see and doesn’t punish you for it.

Does it reopen clients’ tasks?

Never. It acts only on a named list of teammates. A client’s or partner’s task is counted in the daily digest and never touched by a script. A bot reopening a client’s to-do would be a client-facing agent action, and we don’t do those.

What does the founder actually see?

One line in the morning brief when someone hits a third miss, and a per-platform count in a daily digest posted to an internal thread. Most days: nothing. If you’re seeing more than that, the ladder is broken, not the team.

How long did this take to build?

One afternoon, by an agent, including 46 tests. The rule took longer to say than the script took to write. If you’re running agents at all, this is a Thursday.

If you have a solve for a piece of this that we don’t– the handoff, the proof, the checker– send it. I’ll link it from the list above. And if you don’t, take this one. The sentence is free.

How this was built, step by step, with what the agent got wrong and the scorecard: How We Built the Checker That Isn’t Dennis.

Verified: dennisyu.com/agent-disclosure/ fetched fresh with markers COWORK-DEFINITION-OF-DONE-2026-09-04 and COWORK-HANDOFF-IS-A-TODO-2026-09-04 present; first sweep log at 22:38 UTC 4 Sep shows 67 read / 6 proved / 60 baseline; 14-day to-do count from a live query of the Basecamp account at 22:58 UTC 4 Sep.
Agent receipt: Claude Cowork — definitive article, The Checker That Isn’t You [claude-fable-5-1] · action: published · human review: authorized, not separately reviewed