One-click install
npx skills add https://github.com/thangchung/agent-engineering-experiment --skill inc-impl-thangchung
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: inc-impl
Source: https://github.com/thangchung/agent-engineering-experiment/tree/main/foundry-agentfx/.github/skills/inc-impl
Command: npx skills add https://github.com/thangchung/agent-engineering-experiment --skill inc-impl-thangchung

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large features and multi-file changes often fail because too much code is written before anything is tested, making bugs hard to locate and rollbacks painful. This Skill enforces an incremental implementation discipline so every change lands in small, verified, reversible steps. ## Core Features & Use Cases - Increment Cycle: Implements one thin slice at a time, then tests, verifies, and commits before moving to the next slice. - Slicing Strategies: Provides vertical slicing, contract-first slicing for parallel backend/frontend work, and risk-first slicing to de-risk uncertain components early. - Scope and Simplicity Rules: Enforces one logical change per commit, keeps the build green between slices, uses feature flags for incomplete work, and prevents out-of-scope refactoring. - Use Case: When building a task management feature, implement create-task end-to-end first (DB, API, UI), verify tests pass and commit, then add list, edit, and delete as separate committed slices. ## Quick Start Ask the agent to implement the feature incrementally, starting with just the database schema and API endpoint, running tests and the build before moving to the UI slice.

Frequently Asked Questions about inc-impl

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

FAQPage Schema
How do I implement a large feature without breaking the build?▼

Break the feature into thin vertical slices where each slice delivers working end-to-end functionality. After each slice, run the test suite and build, verify the result, and commit before starting the next slice so the codebase never sits in a broken state.

What is vertical slice development in software engineering?▼

Vertical slicing builds one complete path through the entire stack per increment, such as database plus API plus UI for a single operation. Each slice leaves the system working and testable, unlike horizontal layering which completes one layer before starting the next.

When should I use feature flags for incomplete work?▼

Use feature flags whenever a feature is not ready for users but its increments need to merge to the main branch. Gate the new code behind an opt-in flag that defaults to off, so incomplete work stays invisible while small commits keep flowing.

When is incremental implementation not necessary?▼

Skip the increment cycle for single-file, single-function changes where the scope is already minimal. The discipline targets multi-file changes, new features from task breakdowns, and any work exceeding roughly one hundred lines before testing.

Why should refactors be committed separately from features?▼

Mixing refactors with feature changes makes both harder to review and debug, and complicates rollbacks. Commit each logical change separately so a broken feature can be reverted without losing unrelated cleanup work.