Proof of Done: stop AI agents faking "done"

    1

    Sets up Proof of Done, an open-source check that sends AI coding agents back when they delete, skip or weaken tests, or claim the tests pass when they don't.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Proof of Done: stop AI agents faking "done"

    Example session with this skill installed

    Install Proof of Done in this Vitest project, check "all tests pass" claims, and add the pull request check with @dev-team as the owner.

    • Read your context and instructions
    • Compiled the proof of done

    Proof of Done is set up: the Claude Code hook, the claim check for Vitest, and the pull request check with @dev-team as code owner. Nothing is committed yet.

    What I ran

    $ npm install --save-dev proof-of-done
    $ npx proof-of-done install claude-code
    Installed Claude Code hooks (SessionStart, Stop) in .claude/settings.json
    Launcher: .claude/hooks/proof-of-done.mjs (checks Proof of Done's own files before every run)
    Claude Code will now be asked to fix tampered tests (deleted, skipped, emptied or faked) before it can finish.
    
    $ npx proof-of-done install github --owner @dev-team
    Created .github/workflows/proof-of-done.yml
    Added /.github/, /.claude/, /.proofofdone.yml to .github/CODEOWNERS
    
    $ npx proof-of-done verify
    ✓ PASS  no tampering detected
    

    Files

    FileWhat it does
    .claude/settings.jsonRegisters the SessionStart and Stop hooks
    .claude/hooks/proof-of-done.mjsLauncher that refuses to run a modified copy of Proof of Done
    .proofofdone.ymlTest command for checking "all tests pass" claims
    .github/workflows/proof-of-done.ymlPull request check
    .github/CODEOWNERSChanges to the checker need @dev-team's review
    
    # .proofofdone.yml
    version: 0
    tests:
      command: npx vitest run --reporter=junit --outputFile={junit}
      timeoutSeconds: 300
    
    
    # .github/workflows/proof-of-done.yml
    name: Proof of Done
    on:
      pull_request:
        types: [opened, synchronize, reopened, labeled, unlabeled]
    permissions:
      contents: read
    jobs:
      proof-of-done:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v4
          - uses: wasaybuilds/proof-of-done@v0
    

    Next steps (yours)

    1. Review and commit .claude/, .github/, .proofofdone.yml, package.json and package-lock.json.
    2. Start a new Claude Code session so the hooks apply.
    3. In GitHub → Settings → Branches, for your main branch:
      • require the proof-of-done status check
      • require review from Code Owners, dismiss stale approvals, require approval of the most recent push
      • don't allow bypassing these settings
    4. Code owners need write access, and the reviewer must not be the account your agent pushes from.
    5. After upgrading proof-of-done, run npx proof-of-done install claude-code again.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    AI coding agents sometimes "finish" by deleting the failing test, adding .skip, weakening an assertion until it passes, or saying "all tests pass" without running them. This skill sets up Proof of Done, an open-source (MIT) checker by the author of this skill. It compares your tests before and after a change. It never reads the agent's report, and no LLM is involved.

    What it catches

    • Deleted or skipped tests: whole files, single tests, .skip / xit / @pytest.mark.skip, a newly added .only
    • Removed or weakened assertions: toBe(120) → toBeDefined(), assertEqual → assertTrue, commented-out asserts
    • Assertions that can't fail: expect(true).toBe(true), assert True, asserts swallowed by try/catch
    • Edits to the guardrail itself: CI workflows, its config, its hooks
    • False "all tests pass" claims (optional): re-runs your tests and reads the JUnit XML report, never the console

    It doesn't punish refactors: renamed and moved tests are recognised, and changes the user explicitly asked for aren't blocked.

    What the skill sets up

    1. Claude Code hook: when the agent tries to finish, it's sent back with exactly what to restore.
    2. Claim check (optional): a .proofofdone.yml with your runner's JUnit command (Vitest, pytest, Jest, Mocha, Go via gotestsum).
    3. Pull request check: a GitHub Action, plus CODEOWNERS entries so changes to the checker need a human review.
    4. Verification: runs npx proof-of-done verify to confirm the setup.

    Why not just tell the agent not to cheat?

    Instructions are part of what the agent can ignore. Proof of Done runs outside the agent: in a hook, and as a required check on pull requests.

    Known limitations

    • Test parsing covers JavaScript, TypeScript and Python. The claim check works with any runner that writes JUnit XML.
    • The hook is for Claude Code. With other agents, the skill sets up the GitHub Action and the CLI.
    • An agent with every permission bypassed can disable local hooks. The required pull request check is the part it can't reach.
    • Hardcoded expected values aren't detected yet.
    • The skill installs the check; it doesn't replace it.

    Network use: the skill runs npm install / npx, which download the package from npm. Proof of Done itself makes no network calls.

    Requires Node.js 20+. Git repository must have at least one commit. "All tests pass" verification requires JUnit XML support from the test runner.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 2 days ago

    • Free with an Agensi account

    Requires

    GitHub
    Node.js
    Git
    proof-of-done
    vitest
    jest
    mocha

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Allowed Hosts

    api.github.com

    File Scopes

    .claude/**
    .proofofdone.yml
    .github/workflows/proof-of-done.yml
    .github/CODEOWNERS
    package.json
    package-lock.json

    Shell runs npm/npx and git. Network access downloads proof-of-done from npm. Files written: Claude Code hook settings and launcher, the Proof of Done config, the pull request workflow and CODEOWNERS entries

    Listed2 days ago

    What's inside

    Frequently Asked Questions

    This skill installs a deterministic CLI utility that creates a 'lock' on your test suite. It prevents agents from deleting tests, weakening assertions, or falsely reporting a successful test run to bypass your quality checks.

    It currently supports Vitest, pytest, Jest, Mocha, and Go test runners. It is specifically optimized for Claude Code via session hooks but works with any agent that has filesystem access and runs commands in your local terminal.

    The skill includes the Proof of Done CLI tool, a configuration template (.proofofdone.yml), local session hooks for real-time monitoring, and a pre-configured GitHub Action for CI/CD enforcement.

    No, this skill uses a non-LLM, deterministic approach. While prompts can be ignored or hallucinated away, this utility uses file-integrity checks and XML report verification that an agent cannot 'reason' its way out of.

    Setup involves running an initialization command to set up local hooks, defining your test runner in the YAML config, and adding the provided GitHub Action to your repository to block non-compliant PRs.

    The primary requirement is Node.js 20 or higher and an active Git repository. Your test runner must also be capable of outputting standard JUnit XML reports for the verification engine to read.

    New in Workflow Automation