More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Incremental Implementation: Thin Verified Slices

    1

    Ship big changes as thin slices that each end tested, green, committed, and revertable — with slicing patterns, a slice plan template, a quality rubric, and agent handoff rules.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Incremental Implementation: Thin Verified Slices

    Incremental Implementation: Thin Verified Slices

    Example session with this skill installed

    We need to add subscription billing to our app: checkout, a webhook that activates the plan, plan limits enforced on the API, and a billing page. It's a lot — plan the slices so we never sit on a big uncommitted pile.

    • Read your context and instructions
    • Compiled the incremental implementation

    SLICE PLAN — produced by the skill's protocol.

    Baseline: suite green on the untouched tree, 186 tests; checks = build + test + lint + types. Ordering pattern: risk first (the webhook is the unproven piece), then vertical.

    Slice 1 (risk spike, throwaway allowed): send test webhook events from the payment provider's CLI to a stub endpoint that logs payloads. Verify: signature verification passes on a real payload; event shapes for checkout-complete and subscription-cancelled recorded. This slice exists to fail cheap — if signature handling fights the framework, we learn it in an hour.

    Slice 2 (contract): Plan and Subscription types + the provider webhook payload schema, tests only against recorded payloads. No behavior change. Verify: suite green.

    Slice 3 (vertical): checkout — "Upgrade" button creates a checkout session and redirects; success page polls subscription status. Behind flag billingEnabled (default off, retirement date set: two releases after launch). Verify: new tests for session creation with a mocked provider; suite green; commit stands alone.

    Slice 4 (vertical): webhook handler activates/cancels the plan from verified events. Verify: replay recorded payloads in tests, including a duplicate event (idempotency) and an out-of-order cancel. Suite green.

    Slice 5 (vertical): API enforces plan limits, reading the subscription record only — no provider calls in the request path. Verify: tests at the limit boundary (exactly at limit allowed, one over rejected). Suite green.

    Slice 6 (vertical): billing page (current plan, invoices link, cancel flow). Verify: page tests + manual pass with flag on. Then flag flip for all accounts, retirement scheduled.

    Every slice reviewed in one sitting; slices 3–6 each revert cleanly because the flag keeps the unfinished surface invisible.

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

    About this skill

    The failure mode is familiar: five hundred lines written before the first test run, and when something breaks, five hundred suspects. This skill is the discipline that keeps the suspect list small — every change lands as a slice that compiles, passes the full suite, commits cleanly, and can be reverted without dragging anything else down. It opens with the slice contract and a standing rule (never start the next slice on a red or uncommitted tree), then a numbered protocol: baseline the untouched tree first so later failures are attributable, draft a one-line-per-slice plan, choose the ordering pattern, apply the simplicity gate, implement, run all the repo's checks, commit. Four slicing patterns cover the real situations: vertical slices (one full behavior at a time), contract slices (parallel streams agree the interface first), risk slices (the unproven assumption goes first as a cheap spike), and horizontal slices (layer-by-layer, only when the stack already exists). Scope fences name the leaks that bloat diffs — drive-by formatting, "while I'm here" cleanups — and feature flags get rules with teeth: default off, cheap to flip, retirement date and owner recorded, because a flag that survives three releases is permanent configuration with no tests. A complete worked example slices a team-workspaces feature for a solo-user SaaS and shows the payoff: a data-migration spike finds that 3% of legacy projects have a null owner before the migration is written against the opposite assumption. Leverage is built in — a slice plan template, a per-slice checklist, and a 0–2 rubric across working state, independence, size, and scope (5 or below of 8 means the slice was mis-cut). It closes with agent handoffs scoped slice-by-slice with explicit negative scope, edge cases (no test suite, untestable legacy code, two-phase migrations, 2 a.m. hotfixes), anti-patterns, and a pre-delivery gate.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Code Quality & Review.

    • It sequences work; it does not decide what to build or settle design questions — pair it with a spec for ambiguous features.
    • The discipline assumes a runnable check suite; with no tests at all, the first slice is building a minimal smoke harness, which the skill covers but cannot shortcut.
    • Slice sizes are judgment calls. The rubric catches mis-cut slices after the fact; it cannot size them perfectly in advance.

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

    Software
    Git

    Permissions

    Terminal / Shell
    Listed24 days ago
    Updated21 days ago

    What's inside

    Frequently Asked Questions

    As thin as leaves the system provably working: suite green, committable, revertable alone. In practice that's usually one behavior and a review that fits in one sitting. The rubric in the skill scores each slice on working state, independence, size, and scope — 5 or below out of 8 means it was probably two slices or half of one.

    Yes, but slice 1 changes: it's a smoke harness — one command that builds the project and checks the main path end to end. Without some definition of green, slicing has no floor to stand on, and the skill says so rather than pretending otherwise.

    Flags hide unfinished surfaces; they don't shrink the suspect list when something breaks. A 500-line commit behind a flag is still 500 suspects. The skill uses flags for the merging problem (trunk stays shippable) and slices for the diagnosis problem (small, verified, revertable steps).

    New in Code Quality & Review