/task-decomposition
Breaks features into atomic, independently verifiable tasks. No task should take more than 4 hours. Unblocks parallel work and reduces integration risk.
$ npx -y skills add DevelopersGlobal/ai-agent-skills --skill task-decomposition --agent claude-codeHow it fires
How this skill gets triggered: by you, by Claude, or both.
- Fires itselfAuto-invocation. Claude auto-loads it when your prompt matches the work.
- You can call itInvoke it directly when you want it.
- Slash command
/task-decomposition
Context preview
The summary Claude sees to decide when to auto-load this skill.
Breaks features into atomic, independently verifiable tasks. No task should take more than 4 hours. Unblocks parallel work and reduces integration risk.
SKILL.md
task-decomposition.SKILL.mdname: task-decomposition
description: Breaks features into atomic, independently verifiable tasks. No task should take more than 4 hours. Unblocks parallel work and reduces integration risk.
category: plan
applies-to: [claude, gemini, cursor, copilot, any]
version: 1.0.0
Overview
Large tasks fail in large ways. Decomposed tasks fail in small, fixable ways. This skill breaks any feature or project into atomic tasks — each independently implementable, testable, and deployable.
When to Use
- Before starting any feature that takes more than half a day
- When a task feels overwhelming or unclear
- When multiple people need to work in parallel
Process
Step 1: Identify the Deliverable
1. State what "done" looks like for the whole feature. 2. List all the things that must be true when it's complete. 3. Identify dependencies: what must exist before any task can start?
**Verify:** You can state the full feature goal in 2 sentences.
Step 2: Decompose Into Atomic Tasks
4. Break the feature into tasks where each task:
- Can be completed in under 4 hours
- Has a single, clear output
- Can be verified independently
- Can be reverted without breaking other tasks
5. Each task should be: `[verb] [noun] so that [outcome]`
- ✅ "Add rate limiting to /api/login so that brute-force is prevented"
- ❌ "Work on the login security stuff"
**Verify:** Every task is under 4 hours. Every task has a clear verify condition.
Step 3: Order and Parallelism
6. Draw the dependency graph — what blocks what? 7. Identify tasks that can be done in parallel. 8. Sequence tasks so integration happens incrementally (not as one big bang at the end).
**Verify:** The dependency order is clear. No unnecessary sequential dependencies.
Step 4: Estimate and Adjust
9. For each task, estimate: best case / worst case / expected. 10. If any task's worst case > 1 day: decompose further. 11. Total estimate sanity check: does it add up to a reasonable timeline?
Common Rationalizations (and Rebuttals)
| Excuse | Rebuttal | |--------|----------| | "I'll figure it out as I go" | Decomposition takes 30 minutes. Rework from poor planning takes days. | | "It's too complex to break down" | Everything can be decomposed. Start with what you know, decompose the rest later. | | "The tasks are too granular" | Granular tasks ship continuously. Coarse tasks ship never. |
Verification
- [ ] Each task is under 4 hours
- [ ] Each task has a single verify condition
- [ ] Dependencies mapped — no circular dependencies
- [ ] Parallel work identified
References
- [goal-driven-execution skill](../goal-driven-execution/SKILL.md)
- [multi-agent-orchestration skill](../multi-agent-orchestration/SKILL.md)
Read more
name: task-decomposition description: Breaks features into atomic, independently verifiable tasks. No task should take more than 4 hours. Unblocks parallel work and reduces integration risk. category: plan applies-to: [claude, gemini, cursor, copilot, any] version: 1.0.0
Overview
Large tasks fail in large ways. Decomposed tasks fail in small, fixable ways. This skill breaks any feature or project into atomic tasks — each independently implementable, testable, and deployable.
When to Use
- Before starting any feature that takes more than half a day
- When a task feels overwhelming or unclear
- When multiple people need to work in parallel
Process
Step 1: Identify the Deliverable
1. State what "done" looks like for the whole feature. 2. List all the things that must be true when it's complete. 3. Identify dependencies: what must exist before any task can start?
**Verify:** You can state the full feature goal in 2 sentences.
Step 2: Decompose Into Atomic Tasks
4. Break the feature into tasks where each task:
- Can be completed in under 4 hours
- Has a single, clear output
- Can be verified independently
- Can be reverted without breaking other tasks
5. Each task should be: `[verb] [noun] so that [outcome]`
- ✅ "Add rate limiting to /api/login so that brute-force is prevented"
- ❌ "Work on the login security stuff"
**Verify:** Every task is under 4 hours. Every task has a clear verify condition.
Step 3: Order and Parallelism
6. Draw the dependency graph — what blocks what? 7. Identify tasks that can be done in parallel. 8. Sequence tasks so integration happens incrementally (not as one big bang at the end).
**Verify:** The dependency order is clear. No unnecessary sequential dependencies.
Step 4: Estimate and Adjust
9. For each task, estimate: best case / worst case / expected. 10. If any task's worst case > 1 day: decompose further. 11. Total estimate sanity check: does it add up to a reasonable timeline?
Common Rationalizations (and Rebuttals)
| Excuse | Rebuttal | |--------|----------| | "I'll figure it out as I go" | Decomposition takes 30 minutes. Rework from poor planning takes days. | | "It's too complex to break down" | Everything can be decomposed. Start with what you know, decompose the rest later. | | "The tasks are too granular" | Granular tasks ship continuously. Coarse tasks ship never. |
Verification
- [ ] Each task is under 4 hours
- [ ] Each task has a single verify condition
- [ ] Dependencies mapped — no circular dependencies
- [ ] Parallel work identified
References
- [goal-driven-execution skill](../goal-driven-execution/SKILL.md)
- [multi-agent-orchestration skill](../multi-agent-orchestration/SKILL.md)
AI agent skills for production grade applications
Other skills on ai-agent-skills.
- /ai-output-validation
Validates, parses, and sanitizes AI-generated outputs before they reach end users or downstream systems. Structured output enforcement, schema validation, and fallback handling.
Open skill - /api-design
Design stable, versioned, self-documenting APIs. Easy to use correctly, hard to use incorrectly. Apply Hyrum's Law from day one.
Open skill - /ci-cd-pipelines
Automated quality gates from commit to production. Every merge to main is potentially shippable. No manual steps in the deployment path.
Open skill - /code-explanation
Get layered, context-aware explanations of unfamiliar code. Understand what it does, why it was written that way, and how to work with it safely.
Open skill - /code-review
Structured code review focusing on correctness, security, and maintainability. Correctness before style. Every reviewer comment must be actionable.
Open skill - /context-loading
Load minimum necessary context into agent context windows. Prevents token bloat, reduces cost, and improves focus. Only load what the current task needs.
Open skill

