Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Test First Slices

    1

    Drives behavior with tests, one bounded slice at a time: prove red, make green, refactor under protection. No implementation until the red signal is trustworthy, and no simulated green when tests cannot run.

    $18

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Test First Slices

    Test First Slices

    Example session with this skill installed

    TDD the discount rule: 10% off orders over $100.

    • Read your context and instructions
    • Compiled the test first slices

    Illustrative example, synthetic data. File names, findings and outputs below are made up to show the shape of a real run. In actual use the skill reports only evidence supplied or verified in your environment and marks anything unavailable as UNVERIFIED.

    SLICE: order total > $100 gets 10% discount.
    RED EVIDENCE: test "applies 10% to $120 -> $108" fails (no discount logic); fails for the intended reason, not setup noise.
    IMPLEMENTED BEHAVIOR: applyDiscount(total) returns total*0.9 when total>100 else total.
    GREEN EVIDENCE: that test passes; boundary test "$100 -> no discount" added and passes.
    REFACTOR: extracted threshold/rate as named constants while green.
    NEXT SLICE / STOP: next slice = stacking with coupon codes (belongs to approved objective); or stop if out of scope.
    

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

    About this skill

    Test First Slices uses executable expectations to constrain behavior one stable slice at a time. It selects one observable behavior, writes or adjusts the expectation, confirms it fails for the intended missing behavior and not for setup noise, implements the smallest coherent behavior, and refactors only while the relevant suite stays green. When tests cannot run, it marks the slice blocked instead of simulating a green test.

    The problem it addresses

    The skill's completion criterion is a suite that protects behavior rather than mirroring implementation details. A slice counts as done only if a meaningful failing expectation came first, the slice ends green at the appropriate test layer, and the next slice stays inside the approved objective.

    How it works

    It runs five phases in order.

    1. Select one behavior: translate the next acceptance criterion into one observable outcome and choose the lowest test layer that proves it without coupling to internals.
    2. Prove red: write or adjust the expectation and run it, then confirm it fails for the intended missing behavior and not for syntax or setup noise. Gate: no implementation until the red signal is trustworthy.
    3. Make green: implement the smallest coherent production behavior that satisfies the expectation while respecting architecture, without hard-coding only to the test input.
    4. Refactor under protection: remove duplication or improve names and seams only while the relevant suite remains green, without widening the change to unrelated cleanup.
    5. Repeat or stop: take the next slice only if it belongs to the approved objective, and escalate if the new test exposes a missing product or architecture decision.

    Choosing the seam

    Pure or domain behavior gets a focused unit test. A module contract gets a component or integration test. An HTTP or API contract gets a request and response test. User-visible interaction uses browser or end-to-end tests only when lower seams cannot prove it.

    What you get back

    When explicitly reported, a six-field report: SLICE, RED EVIDENCE, IMPLEMENTED BEHAVIOR, GREEN EVIDENCE, REFACTOR and NEXT SLICE / STOP. The package includes a filled-in worked example for a discount rule: a failing test, the smallest implementation, a green test with a boundary case, a refactor that extracts named constants, and a next slice.

    Boundaries

    It is not for throwaway prototypes, pure visual polish, generated configuration, or environments with no meaningful automated seam. If the normal test runner or target environment is unavailable, it uses a smaller executable seam only when that proves the same behavior; otherwise the slice is marked blocked. It touches only the approved surface and never commits, pushes, deploys or installs anything on its own. Project governance documents, ADRs and approved specs outrank the skill, and it stops at its handoff boundary.

    How it differs from nearby work

    The ordering is the mechanism. Nothing is implemented before a trustworthy red signal, so it is not a pass that writes tests after the code. Each pass is one bounded slice inside the approved objective, so it is not a broad implementation pass, and a test that exposes a missing product or architecture decision is escalated instead of resolved silently.

    Evidence discipline

    Facts, inferences and unknowns are kept separate, and a passing narrow check counts as proof only of the surface it exercised. The skill never assumes a shell, Git, browser, network or MCP tool exists, verifies capability first, and never claims a tool ran when it did not.

    Validation scope

    The package is five text files: the process, a README, a worked example and two reference documents. It names no specific language, framework or test runner, and ships no executable scripts, test suite or benchmark results. This listing makes no claim about measured outcomes or host-specific testing.

    Test First Slices is for deterministic behavior with a stable observable seam. It is not meant for throwaway prototypes, pure visual polish, generated configuration or environments with no meaningful automated seam. It needs a way to run tests: without one the slice is marked blocked rather than passed. It guides one bounded slice at a time and does not guarantee model output or replace project-specific rules. The package ships no executable checks, benchmarks or language-specific test results, and a passing test proves only the behavior it exercises.

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

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Required: read access to the repository files, tests and test output under work; write access to add or adjust the expectation and implement the behavior under test; and a shell or test runner to run the expectations, because the red gate and green evidence depend on running them. Optional: browser or end-to-end tests, used only when lower seams cannot prove the behavior. Where no runner is available, the skill uses a smaller executable seam or marks the slice blocked. The package names no network access, environment variables or external services. The skill never commits, pushes, deploys or installs anything on its own.

    Listed17 days ago

    What's inside

    Frequently Asked Questions

    It drives a change through one bounded behavior slice at a time: select one observable behavior, prove a failing test, make it green with the smallest coherent change, then refactor while the suite stays green. When explicitly reported, it returns SLICE, RED EVIDENCE, IMPLEMENTED BEHAVIOR, GREEN EVIDENCE, REFACTOR and NEXT SLICE / STOP.

    The red gate says no implementation until the red signal is trustworthy: the test must fail for the intended missing behavior, not for syntax or setup noise. A test that was never seen failing does not show that it protects the behavior.

    The narrowest stable seam that proves the behavior without coupling to internals: a focused unit test for pure or domain behavior, a component or integration test for a module contract, a request and response test for an HTTP or API contract, and browser or end-to-end tests only when lower seams cannot prove it.

    It uses a smaller executable seam only when that proves the same behavior. Otherwise it marks the slice blocked instead of simulating a green test.

    No. It touches only the approved surface and never commits, pushes, deploys or installs anything on its own. Project governance documents and approved specs outrank the skill.

    New in Testing & Debugging