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.
Security Assessment
Detected risks:
About incremental-implementation
The incremental-implementation skill is designed to help developers deliver changes in manageable, small slices rather than attempting large-scale modifications all at once. It addresses the challenge of maintaining system stability and testability while implementing multi-file features or large code changes. By encouraging a disciplined approach where each change is functional, tested, and verified before moving on, this skill reduces the risk of introducing bugs and makes large features easier to maintain and integrate.
Key capabilities include structured execution through the increment cycle, which consists of implementing the smallest complete piece of functionality, running and writing tests, verifying correctness, committing changes, and then proceeding to the next slice. The skill supports multiple slicing strategies: vertical slices for end-to-end functionality, contract-first slices for parallel frontend and backend development, and risk-first slices to tackle the most uncertain components first. It also emphasizes simplicity and scope discipline, guiding developers to avoid premature abstractions and to focus only on the required parts of a task.
This skill is particularly useful for software engineers working on complex projects involving multiple files or layers of a system. Ideal use cases include building new features from a task breakdown, refactoring existing code, or implementing changes that span backend, API, and frontend layers. Target users are developers seeking a disciplined approach to coding that ensures incremental progress, minimizes risk, and maintains system integrity during development.
FAQ
When should I use incremental-implementation?
Use this skill for multi-file changes, building new features from a breakdown of tasks, or refactoring existing code. Avoid using it for small, single-function changes.
Can I use it for single-file changes?
It's generally unnecessary for small, contained changes where the scope is already minimal. The skill is designed for larger, multi-file tasks.
What strategies are supported for slicing?
It supports vertical slices (complete path through the stack), contract-first slicing (parallel frontend and backend development), and risk-first slicing (addressing riskiest parts first).
Does it require any specific testing framework?
The skill does not mandate a specific framework. It emphasizes running tests for each slice, writing new tests if necessary, and verifying that the system works before committing.
Are there rules for code simplicity and scope?
Yes, it encourages writing the simplest code that works, avoiding premature abstractions, and touching only what is required for the current task.
Install incremental-implementation
Quick Setup:
- Copy the skill folder to
.claude/skills/ - Claude will automatically detect and use the skill
Repository
addyosmani/agent-skills