task-breakdown

Decompose complex requirements into independently executable task cards with strict DoD criteria.

35|10|Updated Dec 29, 2025
One-click install
npx skills add https://github.com/ttmouse/skills --skill task-breakdown-ttmouse
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: task-breakdown
Source: https://github.com/ttmouse/skills/tree/main/task-breakdown
Command: npx skills add https://github.com/ttmouse/skills --skill task-breakdown-ttmouse

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill tackles the challenge of large, unmanageable development tasks by breaking them down into small, independently executable, and demonstrable task cards, ensuring clarity and efficiency in project execution.

Core Features & Use Cases

  • Structured Task Decomposition: Transforms broad requirements into granular task cards adhering to strict principles like vertical slicing and single data change.
  • Enforced Standards: Ensures each task card meets specific criteria for completeness (DoD), scope, and validation.
  • Use Case: When presented with a large feature request like "Build a user management system," this Skill will output a series of task cards for user registration, login, profile updates, etc., each ready for implementation and verification.

Quick Start

Use the task-breakdown skill to break down the requirement "Create a blog post publishing feature."

Frequently Asked Questions about task-breakdown

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

FAQPage Schema
How do I break down complex software requirements into actionable task cards?

To break down complex software requirements, decompose them into minimal, independently executable, and demonstrable task cards. This ensures clarity and efficiency by enforcing vertical slicing, single data change, and strict Definition of Done criteria for each card.

What is vertical slicing in agile task decomposition?

Vertical slicing in task decomposition is an enforced principle that ensures each task card delivers a single, minimal, and independently demonstrable change. It guarantees every card is verifiable within a single turn and adheres to strict Definition of Done criteria.

Can I use this task decomposition approach for large unmanageable project management tasks?

Yes, you can use this task decomposition approach for large unmanageable project management tasks. It transforms broad feature requests into granular, independently executable task cards, ensuring each component is ready for implementation and verification.

What's the best way to ensure each agile task card is independently verifiable?

The best way to ensure each agile task card is independently verifiable is to enforce single data change and single entry point principles during task breakdown. This guarantees each card is demonstrable within a single turn and meets Definition of Done criteria.

Why does my task breakdown result in requirements that cannot be verified in a single turn?

Your task breakdown results in unverifiable requirements because they lack vertical slicing and single data change constraints. Decomposing tasks into minimal, independently executable cards with a single entry point ensures each is verifiable within a single turn.