incremental-implementation

Implements .NET features in thin vertical slices with build and test verification between increments.

7|Updated Jan 11, 2026
One-click install
npx skills add https://github.com/peterblazejewicz/claude-plugins --skill incremental-implementation-peterblazejewicz
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/peterblazejewicz/claude-plugins/tree/main/plugins/dotnet-skills/skills/incremental-implementation
Command: npx skills add https://github.com/peterblazejewicz/claude-plugins --skill incremental-implementation-peterblazejewicz

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large .NET features implemented in one pass produce bugs that are hard to locate, commits that are painful to review, and broken builds between steps. This Skill enforces an incremental delivery discipline so every change lands in a working, tested state. ## Core Features & Use Cases - Thin Vertical Slices: Breaks features into end-to-end slices (EF Core entity, endpoint, view) verified with dotnet test and dotnet build -warnaserror after each step. - Slicing Strategies: Provides vertical, contract-first (DTOs + Swashbuckle + WebApplicationFactory), and risk-first slicing patterns for different project shapes. - Implementation Rules: Enforces simplicity-first design, scope discipline, feature flags via IOptions<FeatureOptions>, safe defaults with nullable reference types, and rollback-friendly commits. - Use Case: When adding full CRUD for tasks in an ASP.NET Core or Avalonia app, implement create, list, edit, and delete as four separately tested and committed slices instead of one large change. ## Quick Start Ask the agent to implement the next task from your plan incrementally, starting with just the EF Core entity and migration, running dotnet test and dotnet build -warnaserror before moving to the UI slice.

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 .NET feature incrementally?

Break the feature into thin vertical slices where each slice delivers working end-to-end functionality, such as one EF Core entity plus migration plus endpoint plus view. After each slice, run dotnet test and dotnet build -warnaserror, then commit before starting the next slice.

What is vertical slice development in ASP.NET Core?

Vertical slicing builds one complete path through the stack per increment, for example create-task with entity, migration, endpoint, and view, rather than building all backend layers first. Each slice leaves the system in a working, testable state.

When should I use feature flags in .NET development?

Use feature flags when a feature is incomplete but you need to merge increments to the main branch. Configure them with IOptions<FeatureOptions> bound to appsettings.json, which works identically in ASP.NET Core, Avalonia, and MAUI hosts.

Should library code use ConfigureAwait(false) in C#?

Yes, library slices consumed from WPF, WinForms, MAUI, or Avalonia UI-thread callers should add ConfigureAwait(false) on every public await, because those hosts capture SynchronizationContext and resuming on it can deadlock. ASP.NET Core has no sync context since .NET Core 2.1, so it is a no-op there.

When is incremental implementation not needed?

Skip it for single-file, single-method changes where the scope is already minimal. The discipline targets multi-file features, refactors, and any change where you would otherwise write more than roughly 100 lines before testing.

Why should EF Core migrations not be edited by hand?

Hand-editing a migration after it has been applied to a shared environment breaks rollback, because the generated Down method no longer matches the actual schema state. Always create a new migration with dotnet ef migrations add instead of modifying an applied one.