Decompose
Break a task into ordered subtasks with dependenciesFrom its SKILL.md
npx -y skills add rioX432/ai-dev-templates --skill decomposeAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
2 things to look at
- no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
- 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
SKILL.md
4.7 KB, as published. Nobody here has run it
Task Decomposition
Break down a development task into small, executable subtasks with clear dependencies.
When to Use
- After investigation and dig phases are complete
- When the approach is confirmed and decisions are made
- Before starting the implementation loop
Input Requirements
You need these before decomposing:
- Investigation results (affected files, data flow, impact)
- Decision matrix from dig phase (resolved ambiguities)
- Confirmed approach
Decomposition Rules
Size
- Each task should take 5-30 minutes to implement
- If a task feels larger, split it further
Structure per Task
Each task must include:
- What: What to implement/change
- Where: Target file(s) with paths
- How: Specific implementation approach
- Why: Reason this change is needed
- Verify: How to confirm it works (test command, manual check, etc.)
Architecture-Based Ordering
Read CLAUDE.md to understand the project's architecture layers, then split by layer from inner to outer.
General pattern (adapt to project):
1. Core types — data classes, interfaces, enums
2. Business logic — use cases, services, domain rules
3. Infrastructure — repositories, API clients, DB
4. Presentation — UI components, view models, controllers
5. Tests — unit tests, integration tests
6. Cross-cutting — lint, formatting, CI checks
For KMP projects:
1. commonMain API — shared types, interfaces
2. expect/actual — platform abstractions
3. androidMain — Android-specific implementation
4. iosMain — iOS-specific implementation
5. Tests — commonTest, platform tests
6. Sample apps — androidApp, iosApp
7. Cross-cutting — detekt, explicitApi
For web projects:
1. Types/schemas — shared types, API contracts
2. Backend logic — API handlers, services
3. Frontend logic — state management, hooks
4. UI components — views, pages
5. Tests — unit, E2E
6. Cross-cutting — lint, build
Pairing Rules
- Type + mapper = 1 task: Data type and its transformation go together
- Implementation + test = 1 task: Never separate implementation from its test
- Cross-cutting checks = last task: After all implementations are done
Dependency Order
Set dependencies on tasks that require earlier ones:
- Core type tasks block implementation tasks
- Implementation tasks block test tasks
- All tasks block cross-cutting checks
TaskCreate Format
Use TaskCreate for each subtask:
subject: "Implement {What} in {Where}"
description: |
**What**: {description}
**Where**: {file path(s)}
**How**: {implementation approach}
**Why**: {reason}
**Verify**: {verification step}
activeForm: "Implementing {What}"
Output
After creating all tasks, show the full task list with dependencies:
| # | Layer | Description | Blocked By |
|---|-------|-------------|------------|
| 1 | Core | Define FooData data class | — |
| 2 | Logic | Implement FooService | #1 |
| 3 | Infra | Add FooRepository | #2 |
| 4 | UI | Add FooScreen component | #2, #3 |
| 5 | Test | Unit tests for FooService | #2 |
| 6 | Cross | Lint + format check | #3, #4 |
Ask user to confirm before starting implementation.
Codex Architecture Validation (Optional)
After generating the full task list, use Codex to validate the decomposition.
Load Codex
ToolSearch("select:mcp__codex__codex")
Call Codex (if available)
mcp__codex__codex(
prompt: "Validate this task decomposition for correctness and completeness:
## Task List
{full task table with dependencies}
## Project Architecture
{architecture layers from CLAUDE.md}
## Validation Checklist
1. **Layer ordering**: Are tasks ordered inner-to-outer (core → logic → infra → presentation → tests → cross-cutting)?
2. **Missing tasks**: Are there any steps that should exist between tasks? Any gaps?
3. **Dependency correctness**: Are all dependency edges correct? Any missing or unnecessary dependencies?
4. **Parallelization**: Which tasks could safely run in parallel (no shared state, no dependency)?
5. **Risk assessment**: Which tasks are highest-risk and might need extra verification?
Output: validated task list with any corrections, plus a list of parallelizable task groups."
)
If Codex suggests corrections:
- Apply the corrections to the task list
- Note what was changed and why
Fallback (Codex unavailable)
If ToolSearch fails to find Codex or the call errors:
- Skip validation — output the task list as-is (traditional flow)