---
name: task-decomposition
description: Breaks down complex software, writing, or research tasks into small, atomic, independently completable units with dependency graphs and milestone breakdowns. Use when the user asks to plan a project, decompose a feature, create subtasks, split up work, or needs help organizing a large piece of work into a step-by-step plan. Triggered by phrases like "break down", "decompose", "where do I start", "too big", "split into tasks", "work breakdown", or "task list".
version: 1.0.0
triggers:
  - break down
  - decompose
  - split into tasks
  - too big
  - where to start
  - complex task
tags:
  - planning
  - decomposition
  - tasks
  - organization
difficulty: beginner
estimatedTime: 10
relatedSkills:
  - planning/design-first
  - planning/verification-gates
---

# Task Decomposition

You are breaking down a complex task into smaller, atomic units. Each unit should be independently completable and verifiable.

## Core Principle

**If a task feels too big, it is too big. Break it down until each piece is obvious.**

A well-decomposed task should take no more than a few hours to complete and have a clear definition of done. Aim for tasks that are small, independent, testable, and clearly scoped.

## Decomposition Techniques

### 1. Vertical Slicing

Break by user-visible functionality (each slice is deployable and testable independently):

```
Feature: User Registration
  Slice 1: Email/password signup — form, validation, account creation
  Slice 2: Email verification — send email, verify link, UI state
  Slice 3: Social login (OAuth) — Google button, OAuth flow, account link
```

### 2. Horizontal Layering

Break by system layer:

```
Feature: Order Processing
  Layer 1: Data Model       — entities, migrations
  Layer 2: Data Access      — repository, CRUD, queries
  Layer 3: Business Logic   — service, validation rules
  Layer 4: API Endpoints    — routes, error handling
  Layer 5: Frontend         — form, API client, loading/error states
```

### 3. Workflow Decomposition

Break by process steps:

```
Task: Checkout flow
  Step 1: Cart validation   — stock check, quantities, totals
  Step 2: Payment           — collect details, validate, process
  Step 3: Order creation    — record, payment link, inventory update
  Step 4: Confirmation      — email, success page, invoice
```

### 4. Component Decomposition

Break by UI or system component:

```
Task: Dashboard page
  Component 1: Header       — logo, nav, user menu
  Component 2: Stats cards  — revenue, orders, customers
  Component 3: Chart        — sales trend, data fetch/transform
  Component 4: Orders table — sort, pagination, row actions
```

> For more detailed worked examples of each technique, see `EXAMPLES.md`.

## Task Template

For each decomposed task, define:

```markdown
## Task: [Brief Title]

**Description:**
[What needs to be done in 1-2 sentences]

**Files to Create/Modify:**
- [ ] path/to/file1.ts
- [ ] path/to/file2.ts

**Steps:**
1. [First specific step]
2. [Second specific step]
3. [Third specific step]

**Done When:**
- [ ] [Success criterion 1]
- [ ] [Success criterion 2]
- [ ] Tests pass

**Dependencies:**
- Requires: [Other task if any]
- Blocks: [What this enables]
```

## Dependency Management

### Identify Dependencies

```
Task Graph:

[Data Model] ──┬──▶ [Repository]
               │
               └──▶ [API Types]
                        │
[Repository] ──────────▶ [Service]
                              │
[API Types] ──────────────────┤
                              ▼
                         [API Endpoints]
```

### Minimize Dependencies

- Prefer tasks that can run in parallel
- Use interfaces to decouple dependencies
- Start with foundational tasks first

### Order by Dependencies

```
Phase 1 (No dependencies):
- Task A: Data model
- Task B: API type definitions
- Task C: UI component skeletons

Phase 2 (Depends on Phase 1):
- Task D: Repository (needs A)
- Task E: API client (needs B)
- Task F: UI logic (needs C)

Phase 3 (Depends on Phase 2):
- Task G: Service (needs D)
- Task H: Connected UI (needs E, F)
```

## Decomposition Checklist

For each task, verify:

- [ ] **Atomic?** — Can be done without interruption
- [ ] **Clear?** — Scope is unambiguous
- [ ] **Testable?** — Know when it's done
- [ ] **Independent?** — Minimal dependencies
- [ ] **Small?** — Less than half a day

## Integration with Other Skills

- Use **design-first** to understand the full scope before decomposing
- Use **verification-gates** to define checkpoints between phases
- Use **testing/red-green-refactor** to implement each task