incremental-implementation

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

Updated Sep 8, 2026
One-click install
npx skills add https://github.com/sasidhar4444/ai-receptionist --skill incremental-implementation-sasidhar4444
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/sasidhar4444/ai-receptionist/tree/main/agent-skills/skills/incremental-implementation
Command: npx skills add https://github.com/sasidhar4444/ai-receptionist --skill incremental-implementation-sasidhar4444

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large features implemented in one pass produce unreviewable diffs, hidden bugs, and broken builds. This Skill enforces a disciplined workflow where every change is delivered as a small, independently tested and committed slice, keeping the codebase working at every step. ## Core Features & Use Cases - Increment Cycle: A repeatable loop of implement, test, verify, commit, then move to the next slice, with a checklist covering tests, build, type checking, and linting. - Slicing Strategies: Guidance for vertical slices, contract-first slicing for parallel backend/frontend work, and risk-first slicing to de-risk uncertain components early. - Scope and Safety Rules: Enforces simplicity-first design, scope discipline, feature flags for incomplete work, safe defaults, and rollback-friendly commits. - Use Case: When building a multi-file CRUD feature, implement one operation (e.g., create) end-to-end with passing tests and a commit before starting the next operation, instead of writing all four at once. ## Quick Start Ask the agent to implement the next task from the plan incrementally, starting with only the database schema and API endpoint, running the test and build commands after each slice before touching the UI.

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 one complete path through the stack. Implement the smallest piece, run the test suite, verify the build, commit with a descriptive message, then move to the next slice.

What is a vertical slice in software development?▼

A vertical slice is one complete path through all layers of the stack, such as database, API, and UI for a single operation. For example, implementing task creation end-to-end before adding list, edit, and delete operations.

When should I use feature flags for incomplete work?▼

Use feature flags when a feature is not ready for users but you need to merge increments to the main branch. Gate the new code behind an environment variable so incomplete work stays hidden while slices land continuously.

When is incremental implementation not needed?▼

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.

Why should I avoid mixing refactors with feature commits?▼

Mixing refactors with features makes both harder to review and debug, and complicates rollback. Separate them into distinct commits so each change does one logical thing and can be reverted independently.