Task Decomposition Skill

Purpose

Break down complex tasks into actionable, atomic steps that can be executed by individual agents.

When to Use

• Receiving complex multi-step requests

• Planning new feature implementation

• Organizing large refactoring efforts

• Coordinating multi-agent workflows

Decomposition Framework

Step 1: Identify the Goal

goal_analysis: end_state: "What does success look like?" constraints: - Time/resource limitations - Technical requirements - Dependencies on external systems success_criteria: - Measurable outcomes - Acceptance conditions

Step 2: Break Down by Layer

Vertical Decomposition (by feature)

Feature Request ├── Component A │ ├── Task A1 │ └── Task A2 ├── Component B │ ├── Task B1 │ └── Task B2 └── Component C └── Task C1

Horizontal Decomposition (by phase)

1. Research Phase ├── Understand requirements └── Analyze existing code

2. Design Phase ├── Define interfaces └── Plan architecture

3. Implementation Phase ├── Build core functionality └── Add edge case handling

4. Validation Phase ├── Write tests └── Review code

Step 3: Ensure Atomicity

Each task should be:

• Single responsibility - Does one thing

• Completable - Has clear done criteria

• Assignable - Can be done by one agent

• Verifiable - Result can be checked

Bad (too vague):

• "Improve the API"
• "Make it faster"
• "Fix the bugs"

Good (atomic):

• "Add rate limiting to /api/users endpoint"
• "Add index to users.email column"
• "Fix null pointer in UserService.getUser()"

Step 4: Map Dependencies

dependencies: T1: [] # Can start immediately T2: [] # Can start immediately T3: [T1] # Needs T1 T4: [T1, T2] # Needs both T1 and T2 T5: [T3, T4] # Needs T3 and T4

critical_path: [T1, T3, T5] # Longest dependency chain parallel_groups:

• [T1, T2] # Can run together
• [T3, T4] # Can run after first group

Step 5: Assign to Agents

Task Type Best Agent

Research, fact-finding Researcher

Writing code Coder

Documentation Writer

Data analysis Analyst

Content harvesting Harvester

Code review Reviewer

Testing Tester

Infrastructure DevOps

Complexity Estimation

Factors

• Number of files affected

• New vs. modifying existing code

• External dependencies

• Testing requirements

• Documentation needs

Complexity Levels

Level Tasks Agents Time Estimate

Simple 1-3 1 Minutes

Moderate 4-10 1-2 Hours

Complex 11-25 2-4 Days

Very Complex 25+ 4+ Weeks

Templates

Feature Implementation

tasks:

• id: research description: "Research existing implementation and requirements" agent: researcher

• id: design description: "Design solution architecture" agent: planner depends_on: [research]

• id: implement description: "Implement the feature" agent: coder depends_on: [design]

• id: test description: "Write and run tests" agent: tester depends_on: [implement]

• id: review description: "Code review" agent: reviewer depends_on: [test]

• id: document description: "Update documentation" agent: writer depends_on: [implement]

Bug Fix

tasks:

• id: reproduce description: "Reproduce and understand the bug" agent: coder

• id: fix description: "Implement the fix" agent: coder depends_on: [reproduce]

• id: test description: "Add regression test" agent: tester depends_on: [fix]

• id: review description: "Review fix" agent: reviewer depends_on: [test]

Infrastructure Setup

tasks:

• id: requirements description: "Document infrastructure requirements" agent: devops

• id: provision description: "Create infrastructure resources" agent: devops depends_on: [requirements]

• id: configure description: "Configure services" agent: devops depends_on: [provision]

• id: validate description: "Validate setup works" agent: tester depends_on: [configure]

• id: document description: "Document infrastructure" agent: writer depends_on: [configure]

Anti-Patterns

Over-Decomposition

Breaking tasks too small creates coordination overhead.

• Bad: "Open file" → "Read line 1" → "Read line 2"...

• Good: "Parse configuration file"

Under-Decomposition

Tasks too large hide complexity and block parallelization.

• Bad: "Build the entire feature"

• Good: Break into research, design, implement, test, document

Missing Dependencies

Forgetting dependencies causes failures mid-execution.

• Always ask: "What must exist before this can start?"

Circular Dependencies

A depends on B B depends on C C depends on A ← Problem!

Solution: Identify shared component, extract as separate task

Checklist

Before finalizing decomposition:

• Each task has clear done criteria

• Dependencies are explicitly mapped

• No circular dependencies exist

• Parallel opportunities identified

• Appropriate agents assigned

• Complexity realistically estimated

• Validation/review tasks included