Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Finish the Job

    1

    For unattended coding: the agent keeps going until the project's own checks are green and says "done" only with evidence.

    $7

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Finish the Job

    Finish the Job

    Example session with this skill installed

    Finish the CSV import with tests — I am going out and will check tonight. Do not stop at a draft.

    • Read your context and instructions
    • Compiled the finish the job

    Evidence — scripts/done_check.py (real runs)

    Python project (an MCP server):

      PASS    lint       .venv/bin/python -m ruff check .   (0.1s)
      PASS    typecheck  .venv/bin/python -m mypy src       (1.4s)
      PASS    test       .venv/bin/python -m pytest -q      (5.7s)
    VERDICT: DONE
    

    TypeScript / three.js project:

      PASS    typecheck  npx --no-install tsc -b --noEmit   (7.8s)
      PASS    lint       npm run --silent lint              (13.5s)
      PASS    test       npm run --silent test              (21.7s)
    VERDICT: DONE
    

    Note the tsc -b: that repo has a solution-style tsconfig, where plain tsc --noEmit checks nothing and "passes" in 0.4 s. The checker detects this.

    If something is left behind

      Leftovers in the uncommitted diff:
        app.ts:2: console.log: console.log(a)
        app.ts:3: focused test: it.only('x', () => {})
        app.ts:4: new TODO: // TODO later
    VERDICT: NOT DONE
    

    Report to you

    Branch auto/csv-import, 4 commits, all checks green, no leftovers. Decision taken: empty rows are skipped and counted in the summary — change it if you prefer. Not pushed; merge after your review.

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

    About this skill

    Stop coming back to half-finished code and "let me know if this works" messages. When you hand off a task to an agent and step away, this skill ensures the job actually reaches a verified, committed state. It replaces passive code generation with a disciplined loop that defines completion criteria up front and refuses to stop until every check passes.

    What it does

    • Automatic verification runs a bundled audit tool to check tests, linting, types, and build status.
    • Diff auditing scans for leftovers like console.log, debugger, .only test flags, and new TODOs.
    • Branch management creates isolated task branches and commits in small, incremental green steps.
    • E2E validation mandates end-to-end testing for UI changes to catch runtime crashes unit tests miss.
    • Autonomous decision-making chooses sensible paths for minor implementation details to avoid stalling.

    How it works

    1. Define Done by establishing concrete, checkable conditions and test requirements before coding.
    2. Implement and Test in small cycles, running the done_check.py tool after every change.
    3. Audit and Review the final diff for code quality, security, and debugging leftovers.
    4. Report Evidence by providing a summary of the branch name, test results, and implementation choices.

    Frameworks & tools

    The skill uses a bundled Python audit script that auto-detects npm, yarn, pnpm, pytest, mypy, ruff, cargo, go, and make. It integrates with git for branch and commit management.

    Why this beats prompting it yourself

    Generic prompts often lead to "lazy" agents that provide code snippets without verifying if they actually compile or pass tests. This skill enforces a strict verification loop and uses a specialized script to catch common human and AI mistakes, such as leaving debug prints or skipping test suites.

    Use cases

    • Completing a feature implementation while the developer is in a meeting or away.
    • Turning a rough bug fix into a verified, lint-clean commit on a branch, ready for your review.
    • Handling tedious refactors that require running wide-ranging type checks and tests.
    • Ensuring autonomous agents don't push broken builds or "should work" code to the repo.

    Known limitations

    Does not support pushing code or deploying to production environments without manual review. Requires a local Python environment to run the audit script.

    Never pushes, opens pull requests or deploys — you review first. Needs Python 3.9+ for the checker and git. Only finds checks the project defines (package.json scripts, pyproject tools, cargo, go, make); a project without tests can never be reported as done. UI changes still need a browser walk-through.

    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

    Money-back guarantee

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

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Requires

    Python 3.9+
    Git
    Project test tools
    Project lint tools
    Project build tools
    Python

    Permissions

    Terminal / Shell
    Browser
    Read Files
    Write Files

    Terminal runs your project's own checks through scripts/done_check.py. Read/Write Files: the code the agent implements. Browser: only for walking through UI changes. No network access needed by the checker; nothing is pushed or deployed.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill is designed to work with any AI agent capable of executing shell commands and local scripts, particularly those based on AutoGPT, OpenDevin, or custom LangChain implementations.

    The skill includes the core autonomous logic, the 'done_check.py' audit script, and a set of instructions that teach your agent how to use the verification loop to reach a committed state.

    No, this skill is designed to operate within a local repository. While it manages branches and commits, it does not have the authority to push to remote repositories or trigger CI/CD pipelines without your explicit manual oversight.

    The bundled audit script automatically detects and supports common ecosystems including JavaScript/TypeScript (npm, yarn, pnpm), Python (pytest, ruff, mypy), Rust (cargo), Go, and projects using Makefiles.

    Setup is minimal; you simply need a local Python environment to run the audit script and a Git-initialized project for the agent to manage branches and commits.

    Unlike generic prompts that might only generate code, this skill enforces a strict 'Refuse to Stop' loop that mandates successful test runs and diff audits before the agent considers the task complete.

    New in Testing & Debugging