More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Spec-Driven Dev Pack

    2

    Green tests that pin the wrong behavior, acceptance criteria nobody checked, a fix that quietly changes three other things.

    $29

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Spec-Driven Dev Pack

    Spec-Driven Dev Pack

    Example session with this skill installed

    Evaluate feature F03 of this repository.

    • Read your context and instructions
    • Compiled the spec-driven dev

    A real evaluator run on a Node.js project. Feature F03 (loyalty tiers) had an off-by-one at the gold threshold, and a green unit test was pinning the wrong value. The evaluator dispatched fix-runner, unit-test-writer and unit-test-validator on its own.

    Summary

    F03 is CLEAN after one correction round (1 of 3 attempts). The first pass failed: exactly 500 points gave silver instead of gold. One correction round fixed the code and the unit test that pinned the old value. The second pass is clean.

    Quality gates

    GateCommandResult
    tests-unitnpm run test:unit✓ 29 ran, 29 passed
    tests-integrationnpm run test:integration✓ 6 ran, 6 passed

    Environment: ✓ contract met (Node.js v22.15.0, needs 22.13 or newer; no service required).

    Observable criteria

    CriterionEvidence
    ✓ points-whole-unitspointsFor(19.99, 'standard') = 19; unit test "should earn one point for each whole unit of the total and nothing for its cents"
    ✓ points-gold-doublepointsFor(19.99, 'gold') = 38; unit test "should earn double the points for a gold customer"
    ✓ points-invalid-total-0.01, '19.99' and NaN each raise RangeError "total must be a non-negative number"; 3 unit tests
    ✓ tier-thresholds199 → standard, 200 → silver, 499 → silver, 500 → gold (first pass: 500 → silver; fixed in 26097b6, test rewritten in 010f76f)
    ✓ tier-earnedearnedTier run on records created and removed in a temporary database: orders 300 + 200 → gold, 300.5 + 200.99 → gold, 501 → gold (499.99 → silver). First pass gave silver at 500. No unit test covers it (no seam, see Findings)

    Correction round 1

    The first pass (attempt 0) had one cause: tierFor compared points > 500. That failed tier-thresholds and tier-earned, and the unit test "should return silver for exactly 500 points" pinned it; the writer's spec-mismatch note was confirmed against the contract. The report had 3 entries: 2 observable-criterion, 1 test waiting for the code fix.

    fix-runner changed > to >= and answered "correction applied". Only the paired test went red, at its assertion.
    2.

    unit-test-writer (correction mode) rewrote that test as "should return gold for exactly 500 points" and removed the note. Its runs: green 14/14; inverted 13 pass, 1 fail at the assertion; restored 14/14.
    3. unit-test-validator: PASS (0 critical, 0 major, 0 minor).

    CommitContent
    26097b6src/domain/loyalty.service.js (fix-runner's correction)
    010f76ftest/unit/loyalty.service.test.js, docs/F03-loyalty-tiers/unit-test.md
    21059cadocs/progress.json: F03 CLEAN, attempt 1

    Left uncommitted for you: nothing (working tree clean).

    Findings

    Logic with no unit test (no seam): earnedTier calls openDatabase('orders.sqlite') directly in src/domain/loyalty.service.js. Left without a test: the orders on record add up to a tier at the plain rate (criterion tier-earned); a customer with no orders; an order with an invalid total; the connection is closed, also when counting fails. tier-earned has evidence from running it by hand only, while the contract expected a unit test. Opening a seam is a design decision for you. Side observation: earnedTier opens orders.sqlite relative to the working directory and ignores the ORDERS_DB that src/server.js reads.

    Inputs the code answers by accident, which nothing defines: pointsFor(Infinity, 'standard') gives Infinity points; tierFor("600") gives gold (the string is compared as a number), while NaN and non-numeric strings give standard.

    No gate exceptions: GATES.md declares no allowlist gate, and the feature's commits change no gate config and add no inline disables.

    Next

    CLEAN → the feature is ready for the next stage.

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

    About this skill

    Your agent says the feature is done. Is it? Green tests that pin the wrong behavior, acceptance criteria nobody checked, a fix that quietly changes three other things. This pack replaces "trust me" with a written contract and an external evaluation that loops until the feature really meets it.

    Launch price: $29 for the first 10 buyers, then $49. One-time purchase, free updates.

    How it works

    SETUP (once per project)
      architecture-analyzer → deep-analyzer → gate-builder    (existing code)
      gate-builder                                            (new project)
    
    PER FEATURE
      prd-writer → spec-writer → implement-feature → evaluator
                                      │                  │ routes each failure:
                                      │ delegates tests  ├─ code → fix-runner
                                      ▼                  └─ test → test-writer → test-validator
                                 test-writer
    
    1. spec-writer turns your PRD into spec.md, plan.md and contract.md: the environment, the quality gates and the observable acceptance criteria. The contract is the single definition of "done".
    2. implement-feature builds the feature phase by phase, one commit per phase, hands each file's tests to the matching test writer, and reports against every criterion.
    3. evaluator checks the feature from the outside: it runs the gates, exercises each criterion, and does not accept a green test as evidence when that test pins the wrong value. Code failures go to fix-runner (the minimal fix, nothing else); test failures go back to the test writer and then to an independent validator. It loops until CLEAN, PENDING (a decision only a person can make) or ABORTED, and tells you exactly why.

    What makes it different

    • Contract-based, not vibes-based. Every criterion in contract.md needs evidence, from a test or from exercising the behavior, or the feature fails.
    • Writers and validators are separate skills. Unit, integration and e2e tests are written by one skill and audited by another against explicit rules, each violation tagged by severity.
    • Tests that can fail. Writers record a red run for every batch of tests, and the evaluator checks that a test asserts what the contract says, not what the code happens to do.
    • Smallest footprint. fix-runner changes only what was reported, the evaluator never edits code or tests, and every skill writes only what it owns.
    • Your project, your rules. gate-builder records your runner, commands, folders and data policy in GATES.md. No skill hard-codes a project's paths or tools.
    • Four languages. Unit and integration suites in JavaScript/TypeScript, Python, Go and Rust; Playwright e2e flows whatever the backend.
    • UI that follows your design rules. design-system applies your design doc, or a Material 3 baseline, and measures computed values in a real browser.

    The 16 skills

    SkillWhat it does
    architecture-analyzermaps an existing codebase: stack, entry points, modules, integrations
    deep-analyzeranalyzes every unit the architecture report lists, item by item
    gate-builderbuilds the quality gates (typecheck, lint, build, tests, architecture, dead code, visual, e2e) and writes GATES.md
    prd-writerwrites the product requirements document
    spec-writerper feature: spec, plan and the contract
    implement-featureimplements a feature against its contract and writes progress.json
    evaluatorevaluates a feature against its contract, owns the correction loop, routes each failure
    fix-runnerapplies the minimal code fix for a failed evaluation
    unit-test-writer / unit-test-validatorwrite unit tests, and audit them
    integration-test-writer / integration-test-validatorwrite integration tests through the real stack, and audit them
    e2e-test-writer / e2e-test-validatorwrite Playwright end-to-end flows, and audit them
    design-systemresolves which design rules bind a UI and checks them
    playwright-clidrives a real browser: smoke checks, screenshots, exploring a flow before testing it

    Requirements

    • Claude Code, or another agent that loads SKILL.md skills and can run shell commands and edit files.
    • Git and your project's own toolchain.
    • For UI and e2e work: Node.js. The agent installs playwright-cli by itself the first time a browser step needs it; back-end-only features never use the browser.

    Validated, not just written

    Every skill was run in fresh agent sessions against mini-projects in JavaScript, Python, Go and Rust, with planted bugs, planted rule-breaking tests and mutation checks that prove the written tests can fail. The demo below is the evaluator's output from one of those end-to-end runs.

    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.

    Validated end to end with Claude Code only. Unit and integration rules ship for JavaScript/TypeScript, Python, Go and Rust; other languages get the generic rules only. E2E suites must use Playwright (@playwright/test); other e2e runners are reported as not covered. Jest/Vitest module mocking and fake timers were not part of the validation projects. Most skills read your project's facts from GATES.md, so run gate-builder first.

    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 7 days ago

    Software
    GitPlaywright
    Optional
    Node.js@playwright/test for e2e test suitesplaywright-cli (installed by the agent)

    Start with gate-builder once per project: it records your test runner, commands and folders in GATES.md, which every other skill reads. The agent installs playwright-cli itself the first time a browser step needs it; back-end-only features never open a browser.

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Browser
    Network Access
    Environment Variables

    File Scopes

    docs/**
    GATES.md
    src/**
    tests/**

    Terminal: runs your project's gates, tests and git. Read/Write files: writes specs, contracts, code, tests and reports inside your repository; code changes land in small commits you can review or revert, and the scopes above are the usual layout (your GATES.md names the real folders). Browser: only for UI checks and e2e tests, through playwright-cli. Network: installing playwright-cli and reaching your local dev server. Environment variables: only the ones your GATES.md declares for test runs. The skills send nothing to any external service.

    Listed7 days ago

    What's inside

    Frequently Asked Questions

    16 skills in one pack: two codebase analyzers, a quality-gate builder, PRD and spec writers, the implementer, the evaluator and its fix runner, three test writer/validator pairs (unit, integration, Playwright e2e), a design-system skill and Microsoft's playwright-cli skill. They call each other by name, so each step of the flow starts from one prompt. One-time purchase, free updates.

    A single agent grades its own work. Here the acceptance criteria are written down first (contract.md), a separate evaluator checks the result against them, and tests are written by one skill and audited by another. A green test that pins the wrong value is caught, a code failure goes to a minimal fixer, and the loop stops at CLEAN, PENDING or ABORTED with the reason.

    Yes. architecture-analyzer and deep-analyzer map the code without changing it, and gate-builder builds the gates from what they find and records your runner, commands and folders in GATES.md. Unit and integration test rules cover JavaScript/TypeScript, Python, Go and Rust; any other language gets the generic rules.

    Only git and your project's own toolchain. For UI checks and e2e tests the agent uses Node.js and installs playwright-cli itself the first time it needs it; back-end-only features never open a browser. E2E suites use @playwright/test.

    No. The analyzers are read-only, fix-runner changes only what an evaluation reported, the evaluator never edits code or tests, and every code change lands in a small commit you can review or revert. Decisions only you can make, such as a gate exception, come back to you instead of being guessed.

    It is built and tested with Claude Code. It follows the SKILL.md standard, so other agents that load skills by name and can run shell commands and edit files should work, but only Claude Code is validated end to end.

    Yes. $29 is the launch price for the first 10 buyers; after that it becomes $49. It is a one-time purchase, and future updates are included.

    New in Testing & Debugging