Skip to content
Skills Library
Programming · Building & coding

incremental-implementation

/incremental-implementation

Use when implementing a multi-file change, building a feature from a breakdown, or writing a large amount of code. Not for a single settled ticket: use work.

Licence
Apache-2.0
Last repository change
28.09.2026

Assessment and security

90/ 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.
Content25 / 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
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

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

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Use when implementing a multi-file change, building a feature from a breakdown, or writing a large amount of code. Not for a single settled ticket: use work.

Original author description

Use when implementing a multi-file change, building a feature from a breakdown, or writing a large amount of code. Not for a single settled ticket: use work.

How it works

  1. Contract
  2. Inputs
  3. Procedure
  4. Failure and recovery
  5. Output
Original SKILL.md headings · 44 lines, 555 words
SKILL.md preview
---
name: incremental-implementation
description: 'Use when implementing a multi-file change, building a feature from a breakdown, or writing a large amount of code. Not for a single settled ticket: use work.'
---

# Incremental implementation

## Contract

| Field | Bound contract |
|---|---|
| Trigger | Implementing any multi-file change, building a new feature from a breakdown, refactoring, or when about to write more than a small amount of code at once. |
| Authority | Reversible local: writes only named local artifacts; rollback is version control (revert of each slice commit). No remote mutation. |
| Side effect | Sequence of tested, committed slices, possibly behind feature flags. |
| Done | Each slice was individually tested and committed, the full suite passes, the build is clean, and the feature works end-to-end without uncommitted changes. |

## Inputs

- Plan or breakdown (required): ordered list of atomic changes that together deliver the feature or refactor. Each item must name the files it touches and the observable behavior it adds or changes.
- Existing test suite (required): the project's current test runner and passing baseline.
- Feature flag mechanism (optional): if the project uses feature flags, the flag name and gating surface for the new behavior.

## Procedure

1. Read the plan. Confirm each item is independently compilable and testable. If an item cannot be tested in isolation, split it further before proceeding.
2. For each plan item, in order:
   a. Implement the change across the named files. Keep the slice as thin as possible: one behavior, one concern, one testable contract.
   b. If a feature flag is in scope, gate the new behavior behind it so the system remains correct with the flag off.
   c. Run the affected tests. If the project has a fast targeted test command, use it; otherwise run the full suite.
   d. Confirm the build is clean: no new warnings, no type errors, no lint regressions on touched files.
   e. Commit the slice with a message that names the behavior added or changed. Do not bundle unrelated changes.
3. After all slices are committed, run the full test suite once more to confirm no cross-slice interaction introduced a regression.
4. Verify end-to-end: exercise the feature or refactor path manually or via integration test to confirm the complete behavior works.
5. If a feature flag was used, confirm the flag-on and flag-off paths both pass. Leave the flag in place unless the plan explicitly calls for its removal in a later slice.

## Failure and recovery
- Slice fails tests: stop. Fix the current slice before starting the next. Do not skip ahead or commit a broken state.
- Build breaks on a slice: stop. Revert the last commit if the fix is not immediate. Re-implement the slice with the narrower scope that keeps the build green.
- Cross-slice regression detected in step 3: bisect by reverting the most recent slice commit and re-running. Identify the conflicting slice and reconcile before re-committing.
- **Plan item cannot be split into a testable slice**: mark it blocked. Do not proceed to dependent items. Report the blocker and the minimum prerequisite needed.
- Partial result rule: committed slices that passed their own tests are retained. Only the failing or conflicting slice is reverted or reworked.

## Output
- A sequence of commits, each passing its own tests and the build.
- A clean working tree with no uncommitted changes.
- A passing full test suite.
- A confirmed end-to-end behavior for the feature or refactor.
Files in this package (2)
  • SKILL.md 3 KB
  • agents/openai.yaml 1 KB

Versions

RepositoryScoreLicence
This page · OutlineDriven/outline-driven-development90Apache-2.0
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
moberghr/mtk-agent-toolkit100MIT

Database snapshot: 13.11.2026 · package version ff8517ce5b8b (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

  • 100work
    Use when implementing from a plan, spec, clear build request, or settled ticket, orchestrated or standalone. Don''t use for open-ended debugging (figure-it-out), exploration, or read-only research.
  • 100incremental-migration
    Use when migrating APIs, libraries, or patterns across a large codebase and a single mega-commit would be too risky to review or merge.
  • 100mukhon-incremental-dev
    Delivers changes incrementally in thin, verifiable slices. Use when implementing any feature or change that touches more than one file, or when picking up the next task from a plan. Use when rolling a change out behind a feature flag, when you're about to write a large amount of…
  • 95feature-implementation
    Implement runnable features from clarified requirements, technical plans, and tasks, validating behavior through risk-appropriate checks, incremental failing tests for business logic, and actual execution, and resolving faults encountered during development. Use for incremental…
  • 100full-stack-orchestration-full-stack-feature
    Coordinate database, backend, frontend, testing, and deployment work for a complete feature. Use when implementing changes that span multiple application layers.
  • 100planning-implementations
    Use when a feature, refactor, or multi-file change needs to be designed before coding. Triggers: plan X, design the implementation, how should we build X, create an implementation plan.

Feedback and reports

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