Incremental Implementation
Deliver multi-file engineering changes through small, tested, reversible slices.
The skill explicitly promotes safe defaults, scope discipline, and rollback-friendly increments, with no evidence of malware, credential theft, or covert exfiltration. It does not explain user confirmation for commits or other external effects, sensitive-data handling, dependency security, or data-flow disclosure, so points are deducted.
The workflow is internally coherent and includes implementation, testing, verification, and stop-on-failure guidance. However, its commands and references to git-workflow-and-versioning and definition-of-done.md depend on the surrounding project environment; abnormal-input handling and reproducible execution evidence are absent, so the static score remains below 10.
The audience and scenarios for multi-file, large, and complex changes are clear, and simple single-file changes are explicitly excluded. Trigger boundaries remain broad, with no guidance for different languages, toolchains, projects without tests, Chinese-language use, or restricted-network environments, so points are deducted.
The document has a useful structure with overview, triggers, cycle, rules, checklists, and anti-rationalization guidance, while the README supplies installation information and the repository provides an MIT license. The selected skill lacks its own version, changelog, maintenance owner, or update path, and relies on unstated environment assumptions and external repository context.
Thin slices, verification gates, feature flags, and rollback guidance are directly actionable for multi-file engineering work, so the core value is plausible. Actual benefit depends on the agent executing project-specific commands and commits, and no representative output or static proof of completed key paths is supplied; the static ceiling therefore requires a conservative deduction.
The skill names auditable checks including tests, builds, type checking, linting, and descriptive commits, and repository CI validates overall structure and installation. The supplied CI and fixture do not test this skill's behavior, and there is no independent reproduction or third-party execution evidence, so only limited credit is warranted.
- “Commit” is mandatory for each increment, but user confirmation, branch policy, and safe handling of commit failures are unspecified; automated agents need an explicit boundary for external writes.
- The test, build, type-check, and lint commands are assumptions and may not exist; the skill should first detect available commands and report missing dependencies diagnostically.
- The skill references other skills and reference files whose contents are not included here, so standalone use may lack required context.
- There is no Chinese-language guidance, language-agnostic example set, or adaptation guidance for restricted-network environments.
What does this skill do, and when should you use it?
Incremental Implementation guides AI coding agents to break features, refactors, and other multi-file changes into thin vertical slices. Each slice completes one logical piece while keeping the project working and testable. The workflow is implement, test, verify, commit, then continue with the next slice. It also promotes simplicity, strict scope control, feature flags for incomplete work, safe defaults, and rollback-friendly changes.
Breaks multi-file work into vertical, contract-first, or risk-first slices; directs the agent to run the test suite or add a test after each slice; checks tests, builds, type checking, linting, and expected functionality; requires descriptive Git commits; and recommends disabled-by-default feature flags and minimal, focused modifications for incomplete or risky work.
- A developer is adding a feature across the database, API, and UI and wants each end-to-end slice to remain usable.
- A backend and frontend team needs to agree on an API contract before implementing in parallel.
- An engineer is refactoring existing code while keeping the project compilable and existing tests passing after every increment.
- A team is working with an uncertain or high-risk component such as a WebSocket connection and wants to validate it before building on it.
- A developer is tempted to write more than roughly 100 lines before running tests.
What are this skill's strengths and limitations?
- Provides a concrete implement-test-verify-commit loop.
- Offers vertical, contract-first, and risk-first slicing strategies.
- Sets explicit guidance for simplicity, scope discipline, safe defaults, feature flags, and reversibility.
- Includes checklists, red flags, and rebuttals to common reasons for skipping verification.
- It is an execution workflow, not a library, code generator, or domain-specific implementation.
- The required verification and commit gates can add operational overhead to each slice.
- The SKILL.md does not adapt commands to a specific project; its examples assume npm, TypeScript, and lint scripts are available.
- The supplied material provides no test results or platform-specific validation for this individual skill.
How do you install this skill?
This skill is part of the 24-skill addyosmani/agent-skills collection. Install the full collection with npx skills add addyosmani/agent-skills. To install this skill individually, use npx skills add addyosmani/agent-skills --skill incremental-implementation. The README does not document a complete platform-specific folder setup for installing only this skill.
How do you use this skill?
In a compatible coding agent, request a multi-file change in explicit increments. For example: Let's implement Task 3 incrementally. Start with just the database schema change and API endpoint. Don't touch the UI yet. After implementing, run npm test and npm run build. Require each slice to be implemented, tested, verified, and committed before moving on.
How does this skill compare with similar options?
The README names Superpowers and Matt Pocock's skills as alternatives and links to a comparison document, but the supplied material does not provide specific comparison conclusions for this skill.