decompose
Break a problem into atomic, testable subproblems. Use when facing complex tasks, unclear requirements, or planning implementation strategy.
When & Why to Use This Skill
This Claude skill enables systematic problem decomposition by breaking complex tasks into atomic, testable subproblems. It streamlines project planning and implementation strategies by identifying logical boundaries, mapping dependencies, and creating actionable TODO lists, ensuring clear requirements and efficient execution for developers and project managers.
Use Cases
- Software Architecture Planning: Decomposing a large-scale system requirement into independent, testable modules and defining their integration order.
- Complex Bug Resolution: Breaking down a multi-layered system failure into smaller, isolated test cases to identify the root cause systematically.
- Project Roadmap Development: Transforming vague business requirements into a structured TODO list with clearly defined dependencies and parallelization opportunities.
- Technical Documentation Strategy: Splitting a comprehensive documentation project into atomic sections based on functional boundaries for collaborative writing.
| name | decompose |
|---|---|
| description | Break a problem into atomic, testable subproblems. Use when facing complex tasks, unclear requirements, or planning implementation strategy. |
| allowed-tools | ["read_file", "update_plan"] |
| short-description | Decompose problems systematically |
Problem Decomposition
Read these references:
references/decomposition.md- Problem breakdown strategies~/.config/agent/core/task-management.md- Creating TODO lists from decomposition~/.config/agent/core/methodology.md- Integration with problem-solving framework
Instructions
Decompose problems into atomic, testable subproblems per references:
Decomposition Steps
Understand the whole problem
- Read all requirements and constraints
- Identify inputs, outputs, and transformations
- Note dependencies and assumptions
Identify natural boundaries
- Where can the problem be split?
- What are the logical units?
- Which parts are independent?
Break into subproblems
- Each subproblem should be:
- Atomic: Single, clear responsibility
- Testable: Can be verified independently
- Self-contained: Minimal external dependencies
- Name each subproblem clearly
- Each subproblem should be:
Map dependencies
- Which subproblems depend on others?
- What's the dependency graph?
- Which must be done sequentially?
Identify parallelization opportunities
- Which subproblems are independent?
- What can run concurrently?
- How can we maximize throughput?
Create TODO List
Per task-management.md, create a TODO list with:
- Each subproblem as an atomic task
- Dependencies clearly noted
- Parallelization opportunities marked
- Execution order specified
Example Output
TODO List for Problem X:
1. [pending] Subproblem A (no dependencies)
2. [pending] Subproblem B (no dependencies) [can parallelize with A]
3. [pending] Subproblem C (depends on A, B)
4. [pending] Subproblem D (depends on C)
Arguments
Problem to decompose: ${ARGUMENTS}