‹ 首页

task-decomposition

@developersglobal · 收录于 1 周前

Breaks features into atomic, independently verifiable tasks. No task should take more than 4 hours. Unblocks parallel work and reduces integration risk.

适合你,如果常因任务颗粒度太大导致进度不可控

/ 下载安装
task-decomposition.skill双击,或拖进 Claude 桌面版 / Cowork,即完成安装↓ .skill↓ .zip
用别的 agent?下载 .zip 解压,把文件夹放进它的技能目录
Claude Code~/.claude/skills/(项目级 .claude/skills/)
Codex CLI~/.codex/skills/
Cursor自动读取上面两处目录
其他工具见其文档的「skills」目录;两个下载是同一份文件,只是名字不同
/ 通过 npx 安装 校验哈希
npx oh-my-skill add developersglobal/ai-agent-skills/task-decomposition
/ 通过 bash 安装
curl -fsSL https://oh-my-skill.com/install.sh | bash -s -- developersglobal/ai-agent-skills/task-decomposition
/ 已经装过?验证本机副本,不用重装
npx oh-my-skill verify developersglobal/ai-agent-skills/task-decomposition
安装目标可用 --agent / --scope 或 --to 明确指定;省略时只会在唯一已存在的 agent 目录上自动选择,零命中或多命中会停止并提示。content_hash 缺失或不一致均拒装。
64GitHub stars
~609上下文体积 · 单文件
镜像托管

怎么用

技能原文 SKILL.md作者撰写 · MIT · f47f948
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
  1. Break the feature into tasks where each task:
  2. Can be completed in under 4 hours
  3. Has a single, clear output
  4. Can be verified independently
  5. Can be reverted without breaking other tasks
  6. Each task should be: [verb] [noun] so that [outcome]
  7. ✅ "Add rate limiting to /api/login so that brute-force is prevented"
  8. ❌ "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
  1. Draw the dependency graph — what blocks what?
  2. Identify tasks that can be done in parallel.
  3. 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
  1. For each task, estimate: best case / worst case / expected.
  2. If any task's worst case > 1 day: decompose further.
  3. 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)
按 MIT 许可原样转载,未经改动 · 在 GitHub 查看 →

评论

登录即可评论;带「已验证安装」的,是发布者名下有本店的安装或持有记录。