Stop trusting 'done' — verify it with check-if-done

Where this fits

You're at the end of a long pair‑programming session with an agent. It says "I've implemented the auth flow and all tests pass." You merge the PR, close the issue, and move on. Two days later, a user hits a 500 error because the agent's completion claim was based on its own memory of what it wrote, not on what actually runs. That gap — between finished‑looking and finished — is exactly what the check-if-done skill addresses. It forces the agent to compare its promise against the real code and to survive an actual command execution before you ever hear the word "done."

Why agents benefit

• Independent verification loop: The skill runs a probe script that checks whether the work is present and executable, not just whether the agent's summary matches its plan.
• Multi‑model cross‑checking: Several models independently compare the task description against the codebase, reducing the chance that one model's blind spot becomes a false positive.
• Execution‑based proof: Every completion claim has to survive a command that was actually run — not a hypothetical "if you run this, it should work."
• Structured todo discipline: It uses TodoWrite to track what was promised vs. what was verified, so nothing slips through because it wasn't explicitly listed.
• Context‑aware triggering: The skill activates on phrases like "is this done" or "did I finish," making it a natural guardrail at the end of any agent task.

Practical scenarios

Before a pull request

You've asked an agent to refactor a legacy module. Instead of trusting its "all green" report, the skill pulls up the original issue, greps for the files touched, and runs the test suite with the exact commands in the repo's CI config. If a test fails because the agent forgot to update a mock, you find out before the reviewer does.

End‑of‑session cleanup

After a long session with multiple sub‑tasks, the agent claims everything is complete. The skill iterates over the plan file, checks each item against the actual codebase, and flags anything that was only partially implemented — like a function that exists but is never called, or an API endpoint that returns a placeholder.

Debugging a "done" feature that isn't

A feature was marked done yesterday, but today it's broken. You ask the agent to check if it's really done. The skill re‑reads the original requirement, inspects the current code, and runs the exact command that would exercise the feature. It tells you precisely what changed or what was never wired up — turning a vague "it worked before" into a concrete diff.

Add it to your agent workflow

Install it with a single command:

npx skills add szarkans/multi --skill check-if-done

Then trigger it in your next session with a simple prompt:

We promised to implement the export feature per the plan in docs/export.md. Check if it's actually done.

The skill will locate its probe script, run the verification, and report back with a list of what passes and what fails — including the exact command it used.

Compare before adopting

Don't take the 4 stars at face value. Check how actively the repo is maintained — look at commit history and issue responses. Compare it with other verification skills that might rely on static analysis only. Also consider whether the skill's assumption of a Bash‑capable environment fits your agent's runtime (e.g., cloud‑sandboxed agents may not have shell access). Finally, evaluate how well it integrates with your existing todo workflow — the skill's use of TodoWrite is only useful if your agent already maintains a task list.

Why it is worth tracking

With only 4 stars and a single author, this is early‑stage — but the core idea is genuinely useful: forcing execution‑based verification rather than memory‑based self‑assessment. Watch for updates that add support for non‑Bash environments or more sophisticated command‑inference. If it gains traction (more stars, more contributors, active issue responses), it could become a standard guardrail in agent workflows. For now, it's a lightweight, pragmatic tool worth evaluating on a small project before you trust it on critical code.