breakdown

Convert plan.md phases into implementation.md tasks with TASK-IDs and dependencies.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/swat9013/dotfiles --skill breakdown-swat9013
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: breakdown
Source: https://github.com/swat9013/dotfiles/tree/main/.claude-global/skills/breakdown
Command: npx skills add https://github.com/swat9013/dotfiles --skill breakdown-swat9013

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Converts high-level implementation plans in plan.md into a concrete, action-oriented implementation.md so engineering teams can execute without ambiguity, missed requirements, or inconsistent task granularity.

Core Features & Use Cases

  • Phase-to-task decomposition: Breaks plan.md phases into 1–2 hour, self-contained tasks with TASK-ID, title, estimate, type, purpose, implementation details, success criteria, and explicit dependencies.
  • Project-aware checks: Inspects CLAUDE.md, package.json, and Makefile to identify lint/test/build commands and inserts [NEEDS CLARIFICATION] where commands or constraints are missing.
  • Parallelization & review: Marks parallelizable tasks with P, generates implementation.md from a template, and delegates an automated quality review against seven review criteria to surface gaps and suggested fixes.
  • Use Case: Turn a product design plan into a developer-ready implementation plan that QA and CI can validate.

Quick Start

Use the breakdown command to convert the repository's plan.md into a detailed implementation.md with TASK-IDs, estimates, dependencies, and P-marked parallel tasks.

Frequently Asked Questions about breakdown

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

FAQPage Schema
How do I convert a plan.md file into executable development tasks?

To convert a plan.md file into executable development tasks, the breakdown Skill decomposes high-level phases into 1-2 hour self-contained tasks. It generates an implementation.md file containing TASK-IDs, time estimates, success criteria, dependencies, and parallelization flags for developers.

What is task decomposition for software project planning?

Task decomposition for software project planning is the process of breaking high-level implementation phases into granular, actionable tasks. This approach ensures engineering teams execute work without ambiguity by defining explicit dependencies and success criteria for each unit of work.

How do I identify lint, test, and build commands for my project tasks?

To identify lint, test, and build commands for project tasks, the breakdown Skill inspects project files like CLAUDE.md, package.json, and Makefile. It extracts these commands automatically and inserts [NEEDS CLARIFICATION] markers where constraints are missing.

Can I mark parallelizable tasks in my implementation plan?

Yes, you can mark parallelizable tasks in your implementation plan. The breakdown Skill automatically assigns P-mark parallelization flags to applicable tasks, allowing developers to identify and execute independent work streams concurrently to accelerate project delivery.

What's the best way to generate an implementation plan for CI validation?

The best way to generate an implementation plan for CI validation is to decompose project phases into tasks with explicit success criteria and dependencies. This ensures QA and CI pipelines can automatically validate each unit of work against defined project constraints.

Why does my project planning lack clear developer task dependencies?

Project planning often lacks clear developer task dependencies when high-level plans are not decomposed into granular units. Converting plan.md files into implementation.md ensures explicit dependencies and TASK-IDs are assigned to each 1-2 hour task.