planning-and-task-breakdown

Decomposes .NET/C# specifications into ordered, verifiable tasks with dotnet CLI verification steps.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large or vaguely scoped .NET work leads to tangled implementations and rework when started without a written plan. This Skill turns a spec or clear requirements into small, verifiable tasks with explicit acceptance criteria, dependency ordering, and checkpoints. ## Core Features & Use Cases - Dependency-aware task ordering: Maps the dependency graph across EF Core entities, DTOs/contracts, endpoints, and UI bindings so foundations are built first across projects like MyApp.Core, MyApp.Infrastructure, and MyApp.Contracts. - Vertical slicing and sizing guidance: Encourages complete feature slices over horizontal layers, with an XS-to-XL sizing table and rules for when a task must be broken down further. - Verification built into every task: Each task carries acceptance criteria plus concrete checks such as dotnet test --filter, dotnet build -warnaserror, and dotnet format --verify-no-changes, with phase checkpoints. - Use Case: Given a spec for a task-management feature in a multi-project .NET solution, produce a phased implementation plan where each task (entity + migration + endpoint + UI) is independently testable and ordered by dependency. ## Quick Start Ask the agent to break your approved spec into an ordered implementation plan with acceptance criteria and dotnet verification commands for each task.

Frequently Asked Questions about planning-and-task-breakdown

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

FAQPage Schema
How do I break a large .NET feature into implementable tasks?

Map the dependency graph from EF Core entities through contracts to UI, then slice vertically so each task delivers one complete feature path. Give every task acceptance criteria and a verification step such as dotnet test --filter or dotnet build -warnaserror.

What is vertical slicing in software task planning?

Vertical slicing builds one complete feature path at a time (entity, migration, endpoint, UI) instead of building all layers horizontally. Each slice delivers working, testable functionality and keeps the system in a working state after every task.

How big should a task be for an AI coding agent?

Tasks of 1-5 files (sizes S and M) work best, such as one endpoint or one feature slice. Anything touching 5-8 files should be split further, and tasks spanning more than two projects in a solution are a red flag.

Which .NET tasks can be parallelized across multiple agents?

Independent feature slices, tests for finished features, and documentation are safe to parallelize. EF Core migrations, shared DbContext changes, and .csproj reference edits must stay sequential, while shared DTOs should be defined in a contracts project first.

When should I skip writing a task breakdown plan?

Skip planning for single-file changes with obvious scope or when the spec already contains well-defined tasks. For anything larger, a written plan surfaces hidden dependencies and survives context window limits across sessions.