skills.rest
ankaboot-source
ankaboot-sourceOFFICIAL
Explore all skills by this author →
WebsiteGitHub

incremental-implementation

Implements multi-file code changes in tested, committed vertical slices.

2|Updated Jul 25, 2026
Search Tags:#refactoring#test-driven#code implementation#feature flags#incremental development#atomic commits#vertical slices
One-click install
npx skills add https://github.com/ankaboot-source/boucle --skill incremental-implementation-ankaboot-source
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/ankaboot-source/boucle/tree/main/.jcode/skills/incremental-implementation
Command: npx skills add https://github.com/ankaboot-source/boucle --skill incremental-implementation-ankaboot-source

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Large features implemented in one pass produce unreviewable diffs, hidden bugs, and broken builds. This Skill enforces a disciplined increment cycle — implement, test, verify, commit — so every change lands in a working, revertable state. ## Core Features & Use Cases - Increment Cycle: Each slice is implemented, tested against the repository's own test/build/lint commands, verified, and committed before moving on. - Slicing Strategies: Vertical slices, contract-first slicing for parallel backend/frontend work, and risk-first slicing to surface uncertainty early. - Scope and Simplicity Rules: Guards against scope creep, premature abstraction, mixed-concern commits, and broken intermediate states, with feature flags for incomplete work. - Use Case: When building a task management feature, deliver it as four slices — create, list, edit, delete — each fully tested and committed end-to-end rather than one 500-line changeset. ## Quick Start Implement this feature incrementally, starting with just the database schema and API endpoint, and run the test suite after each slice before committing.

Frequently Asked Questions about incremental-implementation

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement a large feature incrementally?▼

Break the feature into thin vertical slices where each slice delivers working end-to-end functionality. For each slice, implement the smallest complete piece, run the test suite, verify the build, commit with a descriptive message, then move to the next slice.

What is vertical slice development in software engineering?▼

Vertical slicing builds one complete path through the stack per increment, such as database plus API plus UI for a single operation. Each slice leaves the system in a working, testable state instead of completing one layer at a time.

When should I not use incremental implementation?▼

Skip it for single-file, single-function changes where the scope is already minimal. The overhead of slicing, per-increment verification, and separate commits adds no value when the entire change is small and atomic.

How do I merge incomplete features without breaking production?▼

Use feature flags to gate work-in-progress code behind an opt-in environment variable or configuration setting. This lets you merge small increments to the main branch while keeping incomplete functionality invisible to users.

Why should backend and frontend use contract-first development?▼

Contract-first slicing defines the API contract (types, interfaces, OpenAPI spec) before implementation, letting backend and frontend develop in parallel against the same agreement. Integration and end-to-end testing happen in a final slice.

Related Skills

Explore More Software Engineering Skills→
insightriotinsightriot
1

planning-and-task-breakdown

Decomposes specifications into small verifiable tasks with acceptance criteria and dependency ordering.

Official
Intermediate
gjallagjalla
1

prepare-for-review

Scan modified files for dead code and verify Definition of Done.

Official
Intermediate
sasidhar4444sasidhar4444

incremental-implementation

Implements code changes in thin, tested vertical slices with per-increment verification.

Community
Intermediate
tmchowtmchow
22

iterative:spike

Scope uncertain questions and build throwaway artifacts to validate ideas.

Community
Advanced