Skip to content
Skills Library
Programming · Building & coding

incremental-implementation

/incremental-implementation

Use when executing an approved multi-file implementation to ensure each batch compiles, tests, and stays within the approved manifest.

Licence
MIT
Last repository change
22.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when executing an approved multi-file implementation to ensure each batch compiles, tests, and stays within the approved manifest.

Original author description

Use when executing an approved multi-file implementation to ensure each batch compiles, tests, and stays within the approved manifest.

How it works

  1. Overview
  2. When To Use
  3. Workflow
  4. Batch policy
  5. Rules
  6. Verification
Original SKILL.md headings · 85 lines, 875 words
SKILL.md preview
---
name: incremental-implementation
description: Use when executing an approved multi-file implementation to ensure each batch compiles, tests, and stays within the approved manifest.
type: skill
license: MIT
compatibility:
  - claude-code
  - codex
user-invocable: false
---

# Incremental Implementation

## Overview

Implement in thin slices. Each slice must compile, test, and remain explainable before moving on.

## When To Use

- Any approved multi-file implementation
- Refactors that still require verification
- Any task where the cost of late failure is high

### When NOT To Use

- Single-file, single-function changes already minimal enough for the fix workflow

## Workflow

1. Before each batch, re-read the shared references that batch's files match (`context-engineering` step 3).
2. Implement only the files listed for the batch, with the smallest correct change.
3. Write the tests in the same batch, failing first where the batch adds or fixes behavior (see **Batch policy** below).
4. Run the batch checkpoint using the build and test commands from the active tech stack skill's `## Build & Test Commands`.
5. **Capture analyzer output.** Write the build output to a log, then feed the log
   to the build diagnostics parser. (No `tee /dev/tty`: agent shells have no
   terminal, so it fails.) The parser ships with the plugin; resolve it
   plugin-first, then the project copy:
   ```bash
   # Example for .NET (adapt command from tech stack skill's Build & Test Commands):
   PBD="${CLAUDE_PLUGIN_ROOT}/hooks/parse-build-diagnostics.sh"; [ -f "$PBD" ] || PBD=hooks/parse-build-diagnostics.sh
   mkdir -p .mtk; rc=0; dotnet build > .mtk/build.log 2>&1 || rc=$?; tail -n 30 .mtk/build.log
   [ -f "$PBD" ] && bash "$PBD" --file .mtk/build.log > .mtk/analyzer-output.json; [ "$rc" -eq 0 ]
   ```
   Surface any critical analyzer findings immediately — they block the batch just like
   build failures. Warning-level findings carry forward to the pre-commit review.
   If the parser resolves nowhere, skip this step.
6. Read `.claude/references/pre-commit-review-list.md` if present and fix any violations immediately.
7. Mark the batch complete in `tasks/todo.md`. Record the per-batch gate decision and progress on the workflow artifact **in the same shell call as the checkpoint test run** — `<test cmd> && "$WFA" batch "$MTK_WF_UUID" gate phase_exit_gate pass --reason "batch <id> green" -- set results.batches_completed=<n> -- checkpoint --next "<next batch id: intent>" --verify "<test cmd> => <result>"` (`checkpoint` must be the LAST op; exit 3 means `--next` names a finished unit — fix it and re-run `checkpoint` alone; on red: `|| "$WFA" gate … fail …` to trigger remediation). A standalone bookkeeping turn is a wasted turn. Also checkpoint when a PR is opened, before waiting on a usage limit (`--wait-until <ISO>`), and when the context guard nudges. See `.claude/references/orchestration-gates.md`.
8. **Churn check:** After completing each batch, run `git diff --stat` and count net lines changed **since the last review** (intermediate or Phase 4), **excluding generated and mechanical files** — lockfiles, `*.Designer.cs`, `*.g.cs`, `*.generated.*`, EF migration snapshots, `*.min.js`/`*.min.css`, built bundle output (e.g. `wwwroot/dist/**`). Generated churn is not review load. Thresholds are `MTK_CHURN_REVIEW_LINES` (default **300**) and `MTK_CHURN_HALT_LINES` (default **500**); at rigor HIGH/MAX — the subagent path or the inline-MAX profile — the defaults **double** to 600/1000, because every batch there is already isolated and drift-checked and a full two-stage review is guaranteed at Phase 4, so the mid-run review is a safety net, not the primary review. If the count exceeds the review threshold, pause and trigger an early review checkpoint:
   - Run the pre-commit review list if present
   - Assess whether the scope is still within the approved manifest
   - If the count exceeds the halt threshold without a review, stop and run `compliance-reviewer` before continuing; the count resets after that review
   - This catches large unplanned changes mid-implementation rather than at the end
9. After all batches, run the full test command from the tech stack and write an explicit behavioral diff.
10. **Append the `implement` section to the JSON handoff artifact** at
    `docs/specs/<date>-<slug>.json`. Schema:
    `.claude/schemas/handoff.schema.json`. Required keys:
    ```json
    "implement": {
      "actual_files": ["..."],         // git diff --name-only <base>...HEAD
      "completed_batches": ["B1","B2"],
      "deviations": [
        { "kind": "extra-file", "detail": "src/Helper.cs",
          "justification": "needed to unblock B2; spec did not anticipate" }
      ],
      "behavioral_diff": "..."
    }
    ```
    Be honest about deviations — `spec-drift-detection` will diff
    `change_manifest` against `actual_files` regardless. Run
    `bash scripts/validate-handoff.sh docs/specs/<date>-<slug>.json` to
    surface drift before handing off to review.

## Batch policy

- **Tests:** test level per the stack skill's `## Test Level Guidance`; never an in-memory provider to prove database semantics (constraints, transactions, query translation). A bug fix gets a test that failed before the fix.
- **Uncertain library behavior:** read the dependency's real exception/return surface from local source before trusting the call; surface whatever stays unverified.
- **Isolation at HIGH/MAX:** recommend a dedicated worktree before Phase 3 (Claude Code's native `EnterWorktree`, or `isolation: "worktree"` on implementer `Agent` calls) and pin the branch: record `git branch --show-current` at the gate and re-check it before every batch checkpoint. A branch switch in a shared checkout mid-run is a stop, not a warning.

## Rules

- Never touch a file outside the manifest without re-planning.
- Never defer all tests to the end.
- Never continue across batches on a failing build.
- New public behavior must be test-covered.
- Keep changes rollback-friendly and dependency-focused.
- Do not mix unrelated cleanup into implementation batches.

## Verification

- [ ] Each batch compiles and tests cleanly before the next begins
- [ ] Full solution tests pass at the end
- [ ] Behavioral diff is explicit and matches the request
- [ ] No files outside the approved manifest were touched without re-planning

Versions

RepositoryScoreLicence
This page · moberghr/mtk-agent-toolkit100MIT
TerminalSkills/skills100Apache-2.0
FrancoStino/opencode-skills-collection100MIT
lucasouzadev/agent-kit-skill100MIT
seaworld008/commonly-used-high-value-skills100MIT
zeative/satgas100AGPL-3.0
sickn33/agentic-awesome-skills100MIT
usermahiro/opencodee100MIT
hamzabellouch/agent-skills100MIT

Database snapshot: 13.11.2026 · package version 337c56ccf801 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100incremental-implementation-engineering
    Engineering practice: Incremental implementation — Build in thin vertical slices that each compile, pass tests and get committed, so you always have a working save point and any mistake costs one small revert. Use in any language or framework whenever this practice applies, and…
  • 90scope-check
    Checks that requested work stays inside the active spec boundary. Use when an implementation, refactor or bug fix could quietly grow past the approved story or solution.
  • 100executing-plans
    Executes a written implementation plan via per-batch sub-agent coordinators with verification and commits between batches. Use when a plan exists and the user wants it executed, or invokes /superpowers:executing-plans <plan-path>.
  • 90executing-plans
    Use when you have a written implementation plan to execute in a separate session with review checkpoints
  • 100incremental-development
    Guidelines for incremental development practices. Claude should use this skill when writing multiple similar files (tests, classes, configurations) to ensure each piece is verified before moving to the next.
  • 100agent-teams-simplify-and-harden
    Implementation + audit loop using parallel agent teams with structured simplify, harden, and document passes. Spawns implementation agents to do the work, then audit agents to find complexity, security gaps, and spec deviations, then loops until code compiles cleanly, all tests…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.