incremental-implementation
/incremental-implementation
Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.
- Author
- jmxt3 ↗
- Repository
- gitscape.ai ↗
- Licence
- Apache-2.0
- Last repository change
- 17.07.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 17.07.2026, without references to retired models or APIs.
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
Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.
Original author description
Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.
How it works
- Overview
- When to Use
- The Increment Loop
- Feature Flags
- Safe Defaults
- Rollback-Friendly Changes
- Common Rationalizations
- Red Flags
- Verification
SKILL.md preview
---
name: incremental-implementation
description: Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.
---
# Incremental Implementation
## Overview
Ship thin vertical slices: implement, test, verify, commit — one task at a time. Never write a large batch of changes all at once. Each increment should leave the system in a working, deployable state. This protects against regressions, makes reviews easier, and provides clean rollback points.
## When to Use
- Any change touching more than one file
- Implementing a task from an existing plan
- When you're tempted to "just write it all out first and then test"
- Any feature that takes more than one focused session to implement
**When NOT to use:** Single-line typo fixes or isolated config changes with no behavior impact.
## The Increment Loop
For every task, follow this exact loop:
### 1. Read Before Writing
- Read the task's acceptance criteria
- Load the relevant existing code (the files this task touches)
- Identify the pattern being extended, not invented
- Confirm the approach matches the spec
**Stop if:** The approach differs significantly from the spec. Update the spec or plan first.
### 2. Write a Failing Test (RED)
Write a test that describes the expected behavior. The test **must fail** before you write any implementation code.
```python
# Example for a FastAPI endpoint
def test_export_skill_returns_zip():
"""Skill export endpoint should return a valid zip file."""
response = client.post("/api/skills/export", json={"repo": "owner/repo"})
assert response.status_code == 200
assert response.headers["content-type"] == "application/zip"
```
If the test passes before you write the implementation, the test is wrong. Fix it.
### 3. Implement the Minimum (GREEN)
Write only the code needed to make the test pass. No more, no less.
- Follow existing patterns in the codebase
- No premature abstractions
- No "while I'm here" refactors
- No adding features that aren't in the acceptance criteria
### 4. Run All Tests
```bash
pytest tests/ -v # full suite
pytest tests/ -k "test_name" # targeted run for the new test
```
All existing tests must pass. If they don't, fix the regression before proceeding.
### 5. Build Check
Ensure the project builds/compiles cleanly:
```bash
# Python: check imports resolve
python -c "from api.app import create_app"
# TypeScript/JS: type check
npx tsc --noEmit
```
### 6. Commit
One commit per task. Stage only the files that task touched:
```bash
git add api/app/path/to/changed_file.py tests/test_changed.py
git commit -m "feat(skills): add zip export endpoint for skill download
- POST /api/skills/export accepts {repo: string}
- Returns application/zip with SKILL.md and supporting files
- Validates repo exists before building archive
Closes #42"
```
**Never `git add -A` blindly** — it absorbs unrelated local work and breaks clean rollback.
### 7. Mark the Task Complete and Stop
Update the task list and stop. Do not immediately start the next task. Present the result for human review if the task was Medium or larger.
## Feature Flags
For high-risk changes that must be deployed before they are activated:
```python
# api/app/config.py
FEATURE_FLAGS = {
"skill_hd_tier": os.getenv("FF_SKILL_HD_TIER", "false").lower() == "true",
}
# Usage
if settings.FEATURE_FLAGS["skill_hd_tier"]:
return generate_hd_skill(repo)
else:
return generate_standard_skill(repo)
```
Deploy with `FF_SKILL_HD_TIER=false`, enable via env var when ready.
## Safe Defaults
When adding new behavior, default to the current behavior and opt into new behavior:
```python
# BAD: new behavior is default, breaks existing users
def generate_skill(repo, format="enhanced"):
...
# GOOD: existing behavior is default
def generate_skill(repo, format="standard"):
if format == "enhanced" and feature_flags.hd_tier:
return _generate_enhanced(repo)
return _generate_standard(repo)
```
## Rollback-Friendly Changes
Every commit should be revertable with `git revert` without taking down the system:
- Never combine schema changes with behavior changes in one commit
- Never remove a field that other services still read — add the replacement first, migrate, then remove
- Database migrations go in their own commit, run before the code that depends on them
## Common Rationalizations
| Rationalization | Reality |
|---|---|
| "I'll test at the end when it's all done" | By then, failures are hard to localize. Test each slice so failures are obvious. |
| "The test is trivial for this part" | Write it anyway. Trivial tests catch trivial regressions. |
| "I can see how it fits together — just let me write it all" | You'll produce a 400-line diff that no one can review, with a bug buried on line 312. |
| "Refactoring this first will make the feature easier" | Refactor in a separate commit before the feature. Never mix. |
## Red Flags
- A commit with more than ~200 lines changed (sign of too-big slices)
- A commit message with "WIP", "stuff", or "various changes"
- Implementation written before the test
- Committing `git add -A` without reviewing what's staged
- "It works on my machine" as the only verification
## Verification
After each increment:
- [ ] A failing test was written first
- [ ] The test now passes
- [ ] The full test suite passes (no regressions)
- [ ] The build is clean
- [ ] The commit is atomic (only files from this task)
- [ ] The commit message describes what and why
- [ ] The system is in a deployable state at this commit
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · jmxt3/gitscape.ai | 100 | Apache-2.0 |
| TerminalSkills/skills | 100 | Apache-2.0 |
| FrancoStino/opencode-skills-collection | 100 | MIT |
| lucasouzadev/agent-kit-skill | 100 | MIT |
| seaworld008/commonly-used-high-value-skills | 100 | MIT |
| zeative/satgas | 100 | AGPL-3.0 |
| sickn33/agentic-awesome-skills | 100 | MIT |
| usermahiro/opencodee | 100 | MIT |
| moberghr/mtk-agent-toolkit | 100 | MIT |
Database snapshot: 13.11.2026 · package version 357ba4f3022e (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
- 100inc-impl
Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step. - 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… - 100implementing-incrementally
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… - 100docs-incremental-update
Incrementally update Mintlify documentation (.mdx) from Python source changes only. Use when: (1) Python files referenced in doc_code_map frontmatter have changed, (2) a PR touches Python modules documented in docs/mintlify/key_modules/ or docs/mintlify/mcp/, (3) the user asks… - 100plan-first
Use for any coding task with more than about three steps or touching more than one file — new features, refactors, migrations, multi-file changes, or vague requests like "build X" or "add Y to the app". Read the code, write a short plan, then execute step by step with checks. - 100plan
Use when the task has more than 3 steps, changes ≥ 2 files, or is non-trivial after an interview — «спланируй», «напиши план», «декомпозируй», «с чего начать». Produce a numbered checklist of 3–10 atomic steps before any code/edit. Each step must be verifiable (e2e, lint,…