task-decomposition_skill

Overview

This skill transforms overwhelming development work into clear, actionable tasks so teams can estimate, plan, and deliver reliably. It focuses on cognitive limits, independent vertical slices, and concrete acceptance criteria to reduce scope creep and blockers. Use it to turn epics, vague tickets, or dependency-laden work into pieces that complete quickly and verifiably.

How this skill works

The skill inspects a task’s size, clarity, dependencies, and acceptance criteria, then recommends targeted interventions (vertical slice, walking skeleton, tracer bullet, or time-boxed spike). It applies rules of thumb: keep tasks under 2–3 days, limit concepts to working memory, and ensure each item is independently deployable and testable. It also suggests estimation techniques (Fibonacci, three-point) and practical fixes for common anti-patterns.

When to use it

• When a task feels too big to estimate or contains >7 concepts
• If you don’t know where to start or multiple starting points exist
• When work is blocked on external dependencies or coordination
• If scope keeps expanding or "almost done" never finishes
• Before creating issues from an epic or large feature

Best practices

• Slice vertically: aim for independently deployable user value
• Prefer small tasks under 2–3 days to maximize completion rate
• Define Given/When/Then acceptance criteria for every task
• Time-box spikes (max ~8 hours) with clear deliverables
• Break or mock dependencies (contracts, feature flags, abstractions)

Example use cases

• Break an epic into a series of vertical slices each delivering user-visible value
• Create a walking skeleton to get a minimal end-to-end deployment for a new subsystem
• Run a tracer-bullet proof-of-concept to validate integration choices in a day
• Convert a vague chore into an estimable task with explicit acceptance criteria
• Replace a blocked story with interface contracts and mocked dependencies so implementation can proceed