Back to Details

task-decomposition

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

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
  • 包含多个组件的复杂用户请求
  • 需要协调的多阶段项目
  • 可从并行执行中获益的任务
  • 规划Agent协调策略时

Decomposition Framework

拆解框架

1. Requirements Analysis

1. 需求分析

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

2. 目标层级

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)
自上而下拆解:
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]
原子任务标准:
  • 单一、明确的动作
  • 输入输出定义清晰
  • 可由单个Agent完成
  • 完成情况可测试/验证
  • 有时间限制（可估算时长）

3. Dependency Mapping

3. 依赖关系映射

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
依赖类型:
顺序依赖:
Task A → Task B → Task C
(B requires A's output, C requires B's output)
并行独立:
Task A ─┐
Task B ─┼─ [All can run simultaneously]
Task C ─┘
汇聚依赖:
Task A ─┐
Task B ─┼─> Task D (requires A, B, C)
Task C ─┘
资源依赖:
Task A (needs resource X)
Task B (needs resource X)
→ Sequential or resource pooling required

4. Success Criteria Definition

4. 成功标准定义

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
为每个任务定义:
输入要求:
  • 启动所需的数据/状态
  • 必须可用的资源
  • 必须满足的前置条件
输出预期:
  • 将生成的工件
  • 将发生的状态变化
  • 定义成功的指标
质量标准:
  • 性能要求
  • 代码质量标准（来自AGENTS.md）
  • 测试要求
  • 文档要求

Decomposition Process

拆解流程

Step 1: Understand the Goal

步骤1：理解目标

markdown
User Request: [Original request]

Analysis:
- Primary Goal: [Main objective]
- Type: [Implementation/Debug/Refactor/Analysis]
- Domain: [Specific area of codebase]
- Complexity: [Simple/Medium/Complex]
markdown
用户请求: [原始请求]

分析:
- 核心目标: [主要目标]
- 类型: [实现/调试/重构/分析]
- 领域: [代码库的特定领域]
- 复杂度: [简单/中等/复杂]

Step 2: Identify Major Components

步骤2：识别主要组件

Break main goal into 3-7 major components:
markdown
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)
将主目标拆解为3-7个主要组件：
markdown
主目标: 实现批量模式更新功能

主要组件:
1. 数据库层 (Turso + redb)
2. API层 (公共接口)
3. 业务逻辑 (批量处理)
4. 测试 (单元测试 + 集成测试)
5. 文档 (API文档 + 示例)

Step 3: Decompose Each Component

步骤3：拆解每个组件

For each component, identify atomic tasks:
markdown
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
为每个组件识别原子任务：
markdown
组件: 数据库层

任务:
1. 设计批量模式/结构
   - 输入: 模式数据结构
   - 输出: 模式定义
   - 成功标准: 支持高效批量操作

2. 实现Turso批量操作
   - 输入: 模式、模式数组
   - 输出: 批量插入/更新函数
   - 成功标准: 原子事务、正确的错误处理

3. 实现redb批量缓存
   - 输入: 模式、模式数组
   - 输出: 批量缓存更新函数
   - 成功标准: 快速写入、保持一致性

Step 4: Map Dependencies

步骤4：映射依赖关系

markdown
Dependency Graph:

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

[Write tests] ──> [Write documentation]
markdown
依赖关系图:

[设计模式] ──┬──> [实现Turso批量操作] ──┐
                  │                               ├──> [编写测试]
                  └──> [实现redb批量缓存] ───┘

[编写测试] ──> [编写文档]

Step 5: Assign Priorities

步骤5：分配优先级

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)
优先级等级:
  • P0（关键）: 实现目标必须完成的任务
  • P1（重要）: 显著提升质量/功能的任务
  • P2（锦上添花）: 增强体验但非必需的任务
优先级考量因素:
  • 阻塞其他任务（关键路径）
  • 高用户价值
  • 风险降低（尽早解决未知问题）
  • 快速见效（早期验证）

Step 6: Estimate Complexity

步骤6：估算复杂度

For each task:
markdown
Task: [Name]
- Complexity: [Low/Medium/High]
- Effort: [Small/Medium/Large]
- Risk: [Low/Medium/High]
- Dependencies: [List]
为每个任务:
markdown
任务: [名称]
- 复杂度: [低/中/高]
- 工作量: [小/中/大]
- 风险: [低/中/高]
- 依赖项: [列表]

Decomposition Patterns

拆解模式

Pattern 1: Layer-Based Decomposition

模式1：基于分层的拆解

For architectural changes:
1. Data/Storage layer
2. Business logic layer
3. API/Interface layer
4. Testing layer
5. Documentation layer
针对架构变更：
1. 数据/存储层
2. 业务逻辑层
3. API/接口层
4. 测试层
5. 文档层

Pattern 2: Feature-Based Decomposition

模式2：基于功能的拆解

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
针对新功能：
1. 核心功能 (MVP)
2. 错误处理与边缘情况
3. 性能优化
4. 与现有系统集成
5. 测试与验证
6. 文档与示例

Pattern 3: Phase-Based Decomposition

模式3：基于阶段的拆解

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
针对大型项目：
阶段1: 研究与设计
阶段2: 基础与基础设施
阶段3: 核心实现
阶段4: 集成与测试
阶段5: 优化与打磨
阶段6: 文档与发布

Pattern 4: Problem-Solution Decomposition

模式4：基于问题-解决方案的拆解

For debugging/fixing:
1. Reproduce issue
2. Diagnose root cause
3. Design solution
4. Implement fix
5. Verify fix
6. Prevent regression (tests)
针对调试/修复：
1. 复现问题
2. 诊断根本原因
3. 设计解决方案
4. 实施修复
5. 验证修复
6. 防止回归（测试）

Example Decompositions

示例拆解

Example 1: Simple Task

示例1：简单任务

markdown
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
markdown
请求: "修复模式提取中失败的测试"

分析: 简单、聚焦的任务

拆解:
1. 运行测试以观察失败情况
2. 确定失败原因
3. 应用修复
4. 验证测试通过
5. 检查是否存在类似问题

依赖关系: 顺序执行 (1→2→3→4→5)
复杂度: 低
策略: 单个Agent，顺序执行

Example 2: Medium Task

示例2：中等任务

markdown
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
markdown
请求: "为剧集检索添加缓存"

分析: 中等复杂度，多组件

拆解:
1. 设计缓存策略
2. 实现缓存层
3. 与检索功能集成
4. 添加测试
5. 衡量性能

依赖关系:
- 1 → 2 → 3 (顺序)
- 4 依赖于3
- 5 依赖于3

策略: 顺序执行 + 并行测试

Example 3: Complex Task

示例3：复杂任务

markdown
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
markdown
请求: "重构存储层以支持多种后端"

分析: 高复杂度，架构变更

主要组件:
1. 存储抽象层
2. Turso后端实现
3. redb后端实现
4. 后端工厂与配置
5. 迁移工具
6. 测试基础设施
7. 文档

策略: 多阶段混合执行
协调: GOAP Agent + 多个专业Agent

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
✓ 每个任务都是原子化且可执行的 ✓ 依赖关系明确识别 ✓ 成功标准可衡量 ✓ 复杂度估算合理 ✓ 覆盖所有需求 ✓ 没有过大的任务（>4小时工作量） ✓ 识别出并行执行的机会

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

与GOAP Agent的集成

The GOAP agent uses task decomposition as its first phase:
  1. Receive user request
  2. Apply decomposition framework (this skill)
  3. Create execution plan (agent-coordination skill)
  4. Execute with monitoring (parallel-execution skill)
  5. Report results
GOAP Agent将任务拆解作为第一阶段：
  1. 接收用户请求
  2. 应用拆解框架（本技能）
  3. 创建执行计划（Agent协调技能）
  4. 执行与监控（并行执行技能）
  5. 汇报结果

Tips for Effective Decomposition

高效拆解的技巧

1. Start with Why

1. 从“为什么”开始

  • Understand the true goal behind the request
  • Identify implicit requirements
  • Consider broader context
  • 理解请求背后的真实目标
  • 识别隐含需求
  • 考虑更广泛的上下文

2. Think Top-Down

2. 自上而下思考

  • Start with high-level components
  • Decompose each component separately
  • Stop at appropriate granularity
  • 从高层组件开始
  • 单独拆解每个组件
  • 在合适的粒度停止

3. Consider the User

3. 以用户为中心

  • What value does each task provide?
  • Can tasks be reordered for faster feedback?
  • What's the minimum viable solution?
  • 每个任务能提供什么价值？
  • 任务是否可以重新排序以获得更快的反馈？
  • 最小可行解决方案是什么？

4. Plan for Quality

4. 为质量做规划

  • Include testing tasks
  • Include documentation tasks
  • Include review/validation tasks
  • 包含测试任务
  • 包含文档任务
  • 包含评审/验证任务

5. Anticipate Issues

5. 预判问题

  • What could go wrong?
  • What are the unknowns?
  • Where are the risks?
  • 可能会出现什么问题？
  • 未知因素有哪些？
  • 风险点在哪里？

6. Enable Parallelization

6. 支持并行化

  • 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.
优秀的任务拆解是高效规划与协调的基础。通过将复杂目标拆解为原子化、定义清晰且具有明确依赖关系的任务，你可以实现：
  • 最优执行策略（并行/顺序）
  • 明确的成功标准与验证方式
  • 高效的Agent协调
  • 更好的进度跟踪
  • 更高质量的成果
在任何复杂任务规划工作流中，将该技能作为第一步使用。