- Home
- Skills
- Code Quality & Review
- Incremental Implementation: Thin Verified Slices
More screenshots
Works with the AI Agents you already use
Incremental Implementation: Thin Verified Slices
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
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
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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 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