More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    The Oathkeeper: sealed checks, stop agents faking done

    1

    *Done means done, and it was written down before you started.* Coding agents say "done" when they are not, and sometimes make a failing test pass by weakening it.

    $14

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    The Oathkeeper: sealed checks, stop agents faking done

    The Oathkeeper: sealed checks, stop agents faking done

    Example session with this skill installed

    Add total_with_vat(prices, country) to cart.py (Spain 21%, Portugal 23%). Use the sealed acceptance gate: agree the checks with me first.

    • Read your context and instructions
    • Compiled the the oathkeeper

    Summary

    Done: total_with_vat is in cart.py and both sealed checks are green on HEAD. One of the checks was flagged WEAK by the baseline (it was already green before the work), so it does not prove the VAT change; the second check does.

    1. Acceptance list (you approved it before any code)

    Acceptance:
    - check: python3 -m unittest -q tests.test_cart
    - check: python3 -c "from cart import total_with_vat; assert total_with_vat([100], 'ES') == 121"
    - The receipt shows VAT on its own line
    

    2. Sealed and baselined

    $ python3 /tmp/gate.py seal acceptance.md
    sealed: 2 check(s), 1 manual, hash e0d9d426c01ac7e3
    
    $ python3 /tmp/gate.py baseline
    baseline on 030542a3
      pass     python3 -m unittest -q tests.test_cart  (0.0s)
      fail     python3 -c "from cart import total_with_vat; assert total_with_vat([100], 'ES') == 121"  (0.0s)
      manual   The receipt shows VAT on its own line
      WEAK: already passes before any work, so it proves nothing about it: python3 -m unittest -q tests.test_cart
    baseline recorded: 1/2 already green
    

    3. Built, then checked on the final commit

    $ python3 /tmp/gate.py run
    checks on 30610083
      pass     python3 -m unittest -q tests.test_cart  (0.0s)
      pass     python3 -c "from cart import total_with_vat; assert total_with_vat([100], 'ES') == 121"  (0.0s)
      manual   The receipt shows VAT on its own line
    2/2 green
    

    4. What a shortcut looks like (same repo, later)

    An attempt to loosen the sealed check from == 121 to >= 0:

    $ python3 /tmp/gate.py run
    REFUSED: .acceptance/contract.json was edited after it was sealed.
    Only a human changes the contract: `gate.py reseal <file> --by "<their words>"`.
    

    And a test whose assertEqual was replaced by pass shows up in the PR block:

    CheckResultTime
    python3 -m unittest -q tests.test_cartpass (weak: green before the work)0.0s
    python3 -c "from cart import total_with_vat; ..."pass0.0s

    Test files changed since the seal

    • tests/test_cart.py +1 -1, assertions -1 +0 (1 assertion line(s) removed, 0 added: check nothing was weakened)

    Next steps

    • Confirm the manual criterion (VAT on its own receipt line) yourself.
    • Paste the output of gate.py report into the PR description.

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

    About this skill

    Done means done, and it was written down before you started.

    Coding agents say "done" when they are not, and sometimes make a failing test pass by weakening it. This skill changes the order of work: you and your agent agree on what "done" means as commands, those commands are locked before any code, and "done" means those exact commands are green on the final commit.

    What it does

    • Agrees the definition of done first. The agent drafts an acceptance.md with runnable checks (check: <command>) and manual criteria, and waits for your yes before anything is sealed.
    • Seals it in your repo. One Python script writes .acceptance/contract.json with a hash. You commit it, so every later change to the contract shows in git history.
    • Flags weak checks. A baseline run before any work marks checks that already pass: they prove nothing about the change.
    • Refuses an edited contract. If the sealed file is changed, the checks will not run until a human approves a reseal, and the reseal records who approved it.
    • Shows weakened tests. The report lists every test file changed since the seal, with assertion lines removed and added.
    • Ends with evidence. gate.py report prints a Markdown block for the PR: the contract hash, each check's result on HEAD, weak checks, manual criteria still to confirm, contract history and test file changes.

    How it works

    1. Draft the acceptance list with the agent, approve it.
    2. seal, commit, baseline.
    3. The agent builds; run shows what is still red.
    4. An independent review of the diff (a sub-agent where your agent supports one, otherwise a second pass labelled as such).
    5. run on the final commit, report into the PR.

    What you get

    • SKILL.md: the workflow and the rules the agent follows.
    • scripts/gate.py: one file, Python 3.8+ standard library, about 13 KB. It runs git and your project's own check commands. No network calls, nothing leaves your machine.
    • references/writing-checks.md: strong vs weak checks for JavaScript/TypeScript, Python, Java, Go and HTTP APIs.
    • references/examples.md and report-example.md: two real recorded runs, including a weakened test and an edited contract being caught.

    Honest limits

    • It makes shortcuts visible, it cannot make them impossible: an agent that ignores the skill can still skip it. The evidence block and git history are what keep it honest.
    • It needs an agent that can run shell commands, plus git and python3.
    • Checks that need a running server need you (or a small script in the repo) to start it.

    Where it comes from

    This is the acceptance gate from guild, the multi-agent coding workflow I use every day, where every task seals its checks before any code. Taken out as one standalone script so it works in any repo, without guild.

    The full story: I turned my AI coding agents into an RPG guild (Medium) and the LinkedIn post.


    Part of The Guild, agent skills by Sesisnando Neto: The Quartermaster (quests and decisions), The Tracker (root-cause proof), The Archivist (memory hygiene), The Lorekeeper (repo principles from history), The Inspector (QA validation).

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Testing & Debugging.

    Makes shortcuts visible, cannot make them impossible: an agent that ignores the skill can skip it. Needs an agent with shell access, git and Python 3.8+. Checks that need a running server need it started first. Windows only through Git Bash or WSL.

    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 buying a skill.

    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

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed today

    Software
    GitPython 3.8+Bash (macOS, Linux, WSL)tscNode.jsvitesteslint

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    File Scopes

    .acceptance/**

    The script writes only to .acceptance/ in your repo and acceptance.md is drafted with you. Terminal runs git and the check commands you approved. The script itself makes no network calls; a check you approve may call your own local server (for example curl localhost).

    Listedtoday

    What's inside

    Frequently Asked Questions

    It can try, but it shows. An edited contract is refused until you approve a reseal (and the reseal records who approved it). A test that lost assertions is listed in the PR evidence block, and every change to the contract is in git history. The skill makes shortcuts visible; it does not lock your agent out of your repo.

    Any agent that can run shell commands in your project: Claude Code, Codex CLI, Cursor in agent mode, Gemini CLI and similar. It does not work in chat-only clients such as claude.ai on the web or ChatGPT on the web, because the script has to run in your repo.

    One Python file, standard library only. It runs git and the check commands you approved, and writes only to .acceptance/ at the root of your repo (the contract you commit, plus a local run log it ignores in git). It makes no network calls and sends nothing anywhere.

    The agent stops and asks you. If you agree, it updates acceptance.md and runs reseal with your words quoted (--by "..."). The report then shows the old hash, the new one and who approved the change, so a reviewer sees the definition of done moved.

    A check that already passes before any work, like running a test suite that was green yesterday. It proves nothing about the new change. The baseline run flags these, and references/writing-checks.md shows stronger ones for JavaScript/TypeScript, Python, Java, Go and HTTP APIs.

    No. It gives your reviewer and your CI a clear contract and evidence to check against. It asks the agent for an independent review of the diff (a sub-agent where supported, otherwise a second pass labelled as such), but a human still decides and merges.

    New in Testing & Debugging