Task Decomposition

Enable effective planning and execution by decomposing high-level objectives into manageable, testable sub-tasks.

When to Use

• Complex user requests with multiple components

• Multi-phase projects requiring coordination

• Tasks that could benefit from parallel execution

• When planning agent coordination strategies

Decomposition Framework

1. Requirements Analysis

Extract Information:

• Primary objective (what user wants to achieve)

• Implicit requirements (quality, performance, documentation)

• Constraints (time, resources, compatibility)

• Success criteria (how to measure completion)

Questions to Ask:

• What is the core goal?

• What are the sub-goals that contribute to the main goal?

• What are the dependencies between sub-goals?

• What could go wrong and how to prevent it?

2. Goal Hierarchy

Top-Down Decomposition:

Main Goal: [High-level objective] ├─ Sub-goal 1: [Component 1] │ ├─ Task 1.1: [Atomic action] │ └─ Task 1.2: [Atomic action] ├─ Sub-goal 2: [Component 2] │ ├─ Task 2.1: [Atomic action] │ └─ Task 2.2: [Atomic action] └─ Sub-goal 3: [Component 3] └─ Task 3.1: [Atomic action]

Atomic Task Criteria:

• Single, clear action

• Well-defined inputs and outputs

• Can be completed by one agent

• Testable/verifiable completion

• Time-bounded (estimable duration)

3. Dependency Mapping

Dependency Types:

Sequential Dependencies:

Task A → Task B → Task C (B requires A's output, C requires B's output)

Parallel Independent:

Task A ─┐ Task B ─┼─ [All can run simultaneously] Task C ─┘

Converging Dependencies:

Task A ─┐ Task B ─┼─> Task D (requires A, B, C) Task C ─┘

Resource Dependencies:

Task A (needs resource X) Task B (needs resource X) → Sequential or resource pooling required

4. Success Criteria Definition

For each task, define:

Input Requirements:

• What data/state is needed to start

• What resources must be available

• What preconditions must be met

Output Expectations:

• What artifacts will be produced

• What state changes will occur

• What metrics define success

Quality Standards:

• Performance requirements

• Code quality standards (from AGENTS.md)

• Testing requirements

• Documentation requirements

Decomposition Process

Step 1: Understand the Goal

User Request: [Original request]

Analysis:

• Primary Goal: [Main objective]
• Type: [Implementation/Debug/Refactor/Analysis]
• Domain: [Specific area of codebase]
• Complexity: [Simple/Medium/Complex]

Step 2: Identify Major Components

Break main goal into 3-7 major components:

Main Goal: Implement batch pattern update feature

Major Components:

1. Database layer (Turso + redb)
2. API layer (public interface)
3. Business logic (batch processing)
4. Testing (unit + integration)
5. Documentation (API docs + examples)

Step 3: Decompose Each Component

For each component, identify atomic tasks:

Component: Database layer

Tasks:

1. Design batch schema/structure

   • Input: Pattern data structures
   • Output: Schema definition
   • Success: Supports efficient batch operations

2. Implement Turso batch operations

   • Input: Schema, patterns array
   • Output: Batch insert/update functions
   • Success: Atomic transaction, proper error handling

3. Implement redb batch caching

   • Input: Schema, patterns array
   • Output: Batch cache update functions
   • Success: Fast writes, consistency maintained

Step 4: Map Dependencies

Dependency Graph:

[Design schema] ──┬──> [Implement Turso batch] ──┐ │ ├──> [Write tests] └──> [Implement redb batch] ───┘

[Write tests] ──> [Write documentation]

Step 5: Assign Priorities

Priority Levels:

• P0 (Critical): Must complete for goal achievement

• P1 (Important): Significantly improves quality/functionality

• P2 (Nice-to-have): Enhances but not essential

Prioritization Factors:

• Blocks other tasks (critical path)

• High user value

• Risk reduction (address unknowns early)

• Quick wins (early validation)

Step 6: Estimate Complexity

For each task:

Task: [Name]

• Complexity: [Low/Medium/High]
• Effort: [Small/Medium/Large]
• Risk: [Low/Medium/High]
• Dependencies: [List]

Decomposition Patterns

Pattern 1: Layer-Based Decomposition

For architectural changes:

1. Data/Storage layer
2. Business logic layer
3. API/Interface layer
4. Testing layer
5. Documentation layer

Pattern 2: Feature-Based Decomposition

For new features:

1. Core functionality (MVP)
2. Error handling & edge cases
3. Performance optimization
4. Integration with existing system
5. Testing & validation
6. Documentation & examples

Pattern 3: Phase-Based Decomposition

For large projects:

Phase 1: Research & Design Phase 2: Foundation & Infrastructure Phase 3: Core Implementation Phase 4: Integration & Testing Phase 5: Optimization & Polish Phase 6: Documentation & Release

Pattern 4: Problem-Solution Decomposition

For debugging/fixing:

1. Reproduce issue
2. Diagnose root cause
3. Design solution
4. Implement fix
5. Verify fix
6. Prevent regression (tests)

Example Decompositions

Example 1: Simple Task

Request: "Fix failing test in pattern extraction"

Analysis: Simple, focused task

Decomposition:

1. Run test to observe failure
2. Identify failure cause
3. Apply fix
4. Verify test passes
5. Check for similar issues

Dependencies: Sequential (1→2→3→4→5) Complexity: Low Strategy: Single agent, sequential execution

Example 2: Medium Task

Request: "Add caching to episode retrieval"

Analysis: Medium complexity, multiple components

Decomposition:

1. Design cache strategy
2. Implement cache layer
3. Integrate with retrieval
4. Add tests
5. Measure performance

Dependencies:

• 1 → 2 → 3 (sequential)
• 4 depends on 3
• 5 depends on 3

Strategy: Sequential with parallel testing

Example 3: Complex Task

Request: "Refactor storage layer to support multiple backends"

Analysis: High complexity, architectural change

Major Components:

1. Storage abstraction layer
2. Turso backend implementation
3. redb backend implementation
4. Backend factory & configuration
5. Migration utilities
6. Testing infrastructure
7. Documentation

Strategy: Multi-phase hybrid execution Coordination: GOAP agent + multiple specialized agents

Quality Checklist

Good Decomposition Characteristics

✓ Each task is atomic and actionable ✓ Dependencies are clearly identified ✓ Success criteria are measurable ✓ Complexity is appropriately estimated ✓ All requirements are covered ✓ No task is too large (>4 hours work) ✓ Parallelization opportunities identified

Common Pitfalls

✗ Tasks too large or vague ✗ Missing dependencies ✗ Unclear success criteria ✗ Over-decomposition (too granular) ✗ Missing quality/testing tasks ✗ No consideration for error handling ✗ Forgetting documentation tasks

Integration with GOAP Agent

The GOAP agent uses task decomposition as its first phase:

• Receive user request

• Apply decomposition framework (this skill)

• Create execution plan (agent-coordination skill)

• Execute with monitoring (parallel-execution skill)

• Report results

Tips for Effective Decomposition

1. Start with Why

• Understand the true goal behind the request

• Identify implicit requirements

• Consider broader context

2. Think Top-Down

• Start with high-level components

• Decompose each component separately

• Stop at appropriate granularity

3. Consider the User

• What value does each task provide?

• Can tasks be reordered for faster feedback?

• What's the minimum viable solution?

4. Plan for Quality

• Include testing tasks

• Include documentation tasks

• Include review/validation tasks

5. Anticipate Issues

• What could go wrong?

• What are the unknowns?

• Where are the risks?

6. Enable Parallelization

• Identify truly independent tasks

• Break dependencies where possible

• Consider resource constraints

Summary

Good task decomposition is the foundation of effective planning and coordination. By breaking complex goals into atomic, well-defined tasks with clear dependencies, you enable:

• Optimal execution strategies (parallel/sequential)

• Clear success criteria and validation

• Effective agent coordination

• Better progress tracking

• Higher quality outcomes

Use this skill as the first step in any complex task planning workflow.