task-breakdown-phase

Break down implementation plans into 20-30 testable tasks with acceptance criteria.

Updated Oct 26, 2025
One-click install
npx skills add https://github.com/oxie/portfolio-cms-project --skill task-breakdown-phase-oxie
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: task-breakdown-phase
Source: https://github.com/oxie/portfolio-cms-project/tree/main/.claude/skills/task-breakdown-phase
Command: npx skills add https://github.com/oxie/portfolio-cms-project --skill task-breakdown-phase-oxie

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill transforms high-level implementation plans into concrete, right-sized, test-driven tasks with clear acceptance criteria and proper sequencing. It ensures that development work is manageable, testable, and aligned with TDD principles, preventing scope creep and unclear deliverables.

Core Features & Use Cases

  • Right-Sized Task Generation: Creates tasks typically 0.5-1 day in complexity, splitting larger ones and combining smaller ones for optimal manageability.
  • TDD-First Sequencing: Structures tasks to prioritize writing tests before implementation (RED → GREEN → REFACTOR), enforcing a test-driven approach.
  • Clear Acceptance Criteria: Defines measurable and testable criteria for each task, ensuring clarity on "done."
  • Dependency Mapping: Sequences tasks based on dependencies, identifying critical and parallel paths for efficient execution.
  • Use Case: A detailed implementation plan is ready. This skill helps break it down into a list of 20-30 actionable tasks, ensuring each has clear acceptance criteria and follows a test-first approach, ready for the implementation phase.

Quick Start

Break down the 'Student Progress Dashboard' implementation plan into 20-30 test-driven tasks, ensuring each has clear acceptance criteria.

Frequently Asked Questions about task-breakdown-phase

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

FAQPage Schema
How do I break down a feature into test-driven tasks with acceptance criteria?

Breaking down features into test-driven tasks involves decomposing your implementation plan into 20-30 right-sized tasks (0.5–1 day each), defining measurable acceptance criteria for each, and sequencing them to prioritize writing tests before code. This ensures clarity on completion and enforces TDD discipline from the start.

What's the best way to structure tasks for test-driven development?

Structure tasks following the RED → GREEN → REFACTOR cycle: write test cases first (RED phase), implement minimal code to pass tests (GREEN phase), then refactor for quality. This TDD-first sequencing prevents scope creep, ensures testability, and keeps tasks focused and manageable.

How do I define acceptance criteria for development tasks?

Acceptance criteria are measurable conditions that define when a task is complete. Extract them from your spec and plan by identifying testable behaviors, edge cases, and dependencies. Clear criteria prevent ambiguity, enable parallel work, and provide developers with explicit completion targets.

Can I use task breakdown for project planning before implementation starts?

Yes. Task breakdown is applied after high-level planning and architecture are defined. It transforms detailed implementation plans into concrete, sequenced work items with explicit dependencies and acceptance criteria, making your workflow-state and task list ready for the implementation phase.

What inputs do I need to break down tasks from my implementation plan?

You need your specification document (spec.md), detailed implementation plan (plan.md), and architecture definitions. The task-breakdown phase consumes these to generate a comprehensive tasks.md file and updated workflow-state.yaml with dependencies, criteria, and documentation.

Why should I map task dependencies before starting development?

Dependency mapping sequences tasks along critical and parallel paths, reducing bottlenecks and enabling concurrent work. It prevents developers from starting tasks blocked by prerequisites, accelerates delivery, and provides visibility into project risk and timeline.