task-breakdown

Annotates plan file structures with phases, waves, and parallelization classifications for execution ordering.

4|Updated Jul 30, 2026
One-click install
npx skills add https://github.com/gabriellst/codm --skill task-breakdown-gabriellst
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: task-breakdown
Source: https://github.com/gabriellst/codm/tree/main/.claude/skills/task-breakdown
Command: npx skills add https://github.com/gabriellst/codm --skill task-breakdown-gabriellst

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large implementation plans spanning many files and bounded contexts lack a clear execution order, causing agents to build artifacts in the wrong sequence, duplicate contract work, or fan out subagents with vague handoffs that drift from the agreed design. ## Core Features & Use Cases - Phase-Lane Overlay: Assigns every artifact in a plan's File Structure list to Phase 0 (Contract Lock), Phase 1 (Behavior Slices), or Phase 2 (Integration/QA) with wave labels and serial/parallel classifications. - Feature-Type Calibration: Classifies work into seven feature types (new feature, new endpoint, entity modification, frontend-only, etc.) so small changes skip unnecessary phases. - Handoff Sufficiency: Requires every non-serial task to carry a handoff with frozen inputs, deliverables, scope fences, gates, and discretion so fresh-context subagents can execute without re-deriving contracts. - Use Case: When /plan produces 10+ artifacts across 3+ bounded contexts, invoke this skill to generate a WavePlan with a critical path, parallelism matrix, and mermaid dependency graph embedded in the plan. ## Quick Start Ask the planner to run the task-breakdown overlay on the current plan's File Structure list to produce phases, waves, and a dependency graph.

Frequently Asked Questions about task-breakdown

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

FAQPage Schema
How do I order implementation tasks in a large feature plan?

Assign each artifact to a phase using a deterministic kind mapping: contracts and mocked controllers first, then vertical behavior slices, then integration and QA. Topo-sort within each phase using dependency edges to compute waves and the critical path.

When should a plan use a phase-lane breakdown instead of simple ordering?

Use the full phase-lane overlay when a plan produces ten or more artifacts or crosses three or more bounded contexts. For smaller plans of three to seven artifacts in one or two contexts, a simple inline topological sort is sufficient and cheaper.

What makes a subagent handoff safe for parallel task execution?

A safe handoff contains frozen inputs with exact identifiers from the contract phase, deliverables mapped to acceptance criteria, scope fences marking done and out-of-scope work, exact gate commands, and explicit discretion areas. Vague handoffs cause agents to re-derive shapes and drift.

Why should controllers be mocked before backend implementation?

Declaring controllers with mocked responses in the contract phase freezes the API shape and lets the SDK regenerate, so frontend and backend slices can fan out in parallel without waiting on each other. The mock is replaced with the real use case in a later phase.

When should the task-breakdown skill not be used?

Do not use it for deriving artifacts from a spec, writing TDD steps, implementing code, or making architectural decisions. It only owns the ordering layer and is skipped entirely for small plans below the artifact and context thresholds.