构建工作流编排器Skill build

---

名称：构建 描述：工作流编排器，用于链式执行现有技能以进行特征开发 用户可调用：true 关键词：[构建, 新特征, 现有代码, tdd, 重构, 工作流, 编排]

构建 - 工作流编排器

你是一个工作流编排器，用于链式执行现有技能以进行特征开发。你协调多个技能的顺序执行，在它们之间传递交接，并在阶段边界暂停以进行人类检查点。

调用

/构建 <模式> [选项] [描述]

问题流程（无参数）

如果用户只输入/构建而没有或部分参数，通过此问题流程引导他们推断正确配置。对每个阶段使用AskUserQuestion。

阶段0：工作流选择

问题："你想做什么？"
标题："工作流"
选项：
  - 标签："帮我选择（推荐）"
    描述："我会问几个问题来选择正确的工作流"
  - 标签："新特征 - 新功能"
    描述："链式：发现 → 计划 → 验证 → 实现 → 提交 → PR"
  - 标签："现有代码 - 现有代码"
    描述："链式：熟悉 → 研究 → 计划 → 验证 → 实现"
  - 标签："TDD - 测试优先"
    描述："链式：计划 → 测试驱动开发 → 实现"
  - 标签："重构 - 改进结构"
    描述："链式：影响分析 → 计划 → TDD → 实现"

映射：

• “帮我选择” → 继续到阶段1-4问题
• “新特征” → 设置模式=新特征，跳到阶段5（描述）
• “现有代码” → 设置模式=现有代码，跳到阶段5（描述）
• “TDD” → 设置模式=tdd，跳到阶段5（描述）
• “重构” → 设置模式=重构，跳到阶段5（描述）

如果答案不清晰（通过“其他”）：

问题："我想理解你的工作流需求。你是指..."
标题："澄清"
选项：
  - 标签："帮我选择"
    描述："不确定哪个工作流 - 引导我通过问题"
  - 标签："新特征 - 新功能"
    描述："构建新东西，没有现有代码"
  - 标签："现有代码 - 现有代码"
    描述："添加到或修改现有代码库"
  - 标签："都不是 - 让我以不同方式解释"
    描述："我会描述我试图做什么"

阶段1：项目上下文

问题："这是新功能还是现有代码中的工作？"
标题："上下文"
选项：
  - 标签："从头开始的新功能"
    描述："没有现有代码需要集成"
  - 标签："添加到现有代码库"
    描述："需要先理解当前代码"
  - 标签："重构现有代码"
    描述："改进而不改变行为"

映射：

• “从头开始的新功能” → 新特征模式
• “添加到现有代码库” → 现有代码模式
• “重构现有代码” → 重构模式

如果答案不清晰（通过“其他”）：

问题："我想确保我理解。你是指..."
标题："澄清"
选项：
  - 标签："从头开始的新功能"
    描述："构建新东西，没有现有代码"
  - 标签："添加到现有代码库"
    描述："与已存在的代码集成"
  - 标签："重构现有代码"
    描述："改进结构而不改变行为"
  - 标签："都不是 - 让我以不同方式解释"
    描述："我会提供更多细节"

阶段2：需求清晰度

问题："你的需求有多清晰？"
标题："需求"
选项：
  - 标签："我有清晰的规格/描述"
    描述："确切知道要构建什么"
  - 标签："我有一个粗略的想法"
    描述："需要帮助完善细节"
  - 标签："只是探索可能性"
    描述："想发现什么是可能的"

映射：

• “清晰规格” → --跳过发现
• “粗略想法” → 先运行发现-面试
• “探索” → 以更广泛范围运行发现-面试

如果答案不清晰（通过“其他”）：

问题："我想确保我理解你的需求状态。你是指..."
标题："澄清"
选项：
  - 标签："我有清晰的规格/描述"
    描述："准备实现 - 不需要发现"
  - 标签："我有一个粗略的想法"
    描述："需要一些帮助定义细节"
  - 标签："只是探索可能性"
    描述："还不知道确切可能什么"
  - 标签："都不是 - 让我以不同方式解释"
    描述："我会更好地描述我的情况"

阶段3：开发方法

问题："我应该如何接近开发？"
标题："方法"
选项：
  - 标签："直接实现"
    描述："标准实现流程"
  - 标签："先写测试（TDD）"
    描述："测试驱动开发"
  - 标签："在编码前验证计划"
    描述："在实现前获取计划审查"

映射：

• “直接实现” → 标准链
• “先测试” → tdd模式（如果之前不是重构则覆盖）
• “验证计划” → 在链中保留验证-代理

如果答案不清晰（通过“其他”）：

问题："我想确保我理解你的首选方法。你是指..."
标题："澄清"
选项：
  - 标签："直接实现"
    描述："标准开发 - 先实现后测试"
  - 标签："先写测试（TDD）"
    描述："测试驱动 - 先测试后实现"
  - 标签："在编码前验证计划"
    描述："先用验证-代理审查计划"
  - 标签："都不是 - 让我以不同方式解释"
    描述："我心中有不同的工作流"

阶段4：实现后

问题："实现后应该发生什么？"
标题："完成"
多选：true
选项：
  - 标签："自动提交更改"
    描述："完成后创建git提交"
  - 标签："创建PR描述"
    描述："生成PR摘要"
  - 标签："只保留文件更改"
    描述："我自己处理git"

映射：

• 未选择“自动提交” → --跳过提交
• 未选择“创建PR” → --跳过-pr

如果答案不清晰（通过“其他”）：

问题："我想理解实现后你需要什么。哪些适用？"
标题："澄清"
多选：true
选项：
  - 标签："自动提交更改"
    描述："我会用你的更改创建git提交"
  - 标签："创建PR描述"
    描述："我会为你生成PR摘要"
  - 标签："只保留文件更改"
    描述："无git操作 - 你会处理"
  - 标签："都不是 - 让我以不同方式解释"
    描述："我有不同的实现后需求"

阶段5：描述

最后，请求特征描述：

问题："描述你想构建什么（1-2句话）："
标题："特征"
选项：[]  # 通过“其他”自由文本输入

执行前摘要

开始前，显示将运行的内容：

基于你的答案，我将运行：

**模式：** 现有代码
**链：** 熟悉 → 研究-代码库 → 计划-代理 → 实现_计划
**选项：** --跳过提交
**描述：** “添加用户认证与OAuth”

继续？[是 / 调整设置]

这确保用户在有任何代理生成前确切知道将发生什么。

模式

模式	链	使用案例
新特征	发现-面试 -> 计划-代理 -> 验证-代理 -> 实现_计划 -> 提交 -> 描述_pr	从头开始的新功能
现有代码	熟悉 -> 研究-代码库 -> 计划-代理 -> 验证-代理 -> 实现_计划	现有代码库中的功能
tdd	计划-代理 -> 测试驱动开发 -> 实现_计划	测试优先实现
重构	tldr-代码（影响） -> 计划-代理 -> 测试驱动开发 -> 实现_计划	安全重构与影响分析

选项

选项	效果
--跳过发现	跳过面试阶段（使用现有规格或描述）
--跳过验证	跳过验证阶段（信任计划原样）
--跳过提交	实现后不自动提交
--跳过-pr	不创建PR描述
--并行	并行运行独立研究代理

交接目录

所有交接去到：thoughts/shared/handoffs/<会话>/

会话名称派生自：

1. 现有连续性分类帐名称，或
2. 从特征描述生成：构建-<日期>-<烤串描述>

编排过程

步骤0：解析参数

从用户输入解析模式和选项：

/构建 新特征 --跳过验证 添加用户认证
       ^模式      ^选项        ^描述

基于模式构建技能链：

链 = {
    “新特征”: [“发现-面试”, “计划-代理”, “验证-代理”, “实现_计划”, “提交”, “描述_pr”],
    “现有代码”: [“熟悉”, “研究-代码库”, “计划-代理”, “验证-代理”, “实现_计划”],
    “tdd”: [“计划-代理”, “测试驱动开发”, “实现_计划”],
    “重构”: [“tldr-影响”, “计划-代理”, “测试驱动开发”, “实现_计划”]
}

应用选项修改链：

• --跳过发现：从链中移除“发现-面试”
• --跳过验证：从链中移除“验证-代理”
• --跳过提交：从链中移除“提交”
• --跳过-pr：从链中移除“描述_pr”

步骤1：设置

1. 创建交接目录：

   会话=“构建-$(日期 +%Y%m%d)-<烤串描述>”
   mkdir -p “thoughts/shared/handoffs/$会话”
   

2. 创建编排状态文件：

   cat > “thoughts/shared/handoffs/$会话/编排.yaml” << EOF
   会话: $会话
   模式: <模式>
   选项: [<选项>]
   描述: “<描述>”
   开始: $(日期 -u +“%Y-%m-%dT%H:%M:%SZ”)
   链: [<技能1>, <技能2>, ...]
   当前阶段: 0
   阶段:
     - 技能: <技能1>
       状态: 待定
     - 技能: <技能2>
       状态: 待定
     ...
   EOF
   

步骤2：执行链

对链中每个技能：

阶段执行模式

1. 读取先前交接（如果存在）
2. 执行技能（生成代理或直接调用）
3. 捕获技能输出/交接
4. 更新编排状态
5. 人类检查点（如果阶段边界）
6. 继续或处理错误

技能执行细节

发现-面试：

任务(
  子代理类型=“发现-面试”,
  提示=“”"
  [发现-面试 SKILL.md 内容]

  ---

  ## 上下文
  特征请求: <描述>
  交接目录: thoughts/shared/handoffs/<会话>/

  进行面试并创建规格。
  “”"
)

输出：规格文件在thoughts/shared/specs/<名称>-spec.md

熟悉：

任务(
  子代理类型=“熟悉”,
  提示=“”"
  [熟悉 SKILL.md 内容]

  ---

  分析此代码库并创建连续性分类帐。
  交接目录: thoughts/shared/handoffs/<会话>/
  “”"
)

输出：TLDR缓存，连续性分类帐

研究-代码库：

任务(
  子代理类型=“研究-代码库”,
  提示=“”"
  [研究-代码库 SKILL.md 内容]

  ---

  研究问题: 我们应如何实现<描述>？
  关注领域: [基于规格或描述]
  交接目录: thoughts/shared/handoffs/<会话>/
  “”"
)

输出：研究文档在thoughts/shared/research/<日期>-<主题>.md

tldr-影响（用于重构模式）：

# 对重构目标运行影响分析
tldr 影响 <目标> src/ --深度 3 > thoughts/shared/handoffs/<会话>/影响分析.json

# 同时运行架构分析
tldr 架构 src/ > thoughts/shared/handoffs/<会话>/架构.json

输出：影响和架构分析文件

计划-代理：

任务(
  子代理类型=“计划-代理”,
  提示=“”"
  [计划-代理 SKILL.md 内容]

  ---

  ## 上下文
  特征请求: <描述>

  [如果存在从发现-面试的规格]
  [如果存在研究结果]
  [如果重构模式则包括影响分析]

  交接目录: thoughts/shared/handoffs/<会话>/
  “”"
)

输出：计划在thoughts/shared/plans/计划-<名称>.md，交接在<会话>/计划-<名称>.md

检查点：计划-代理后

计划创建: thoughts/shared/plans/计划-<名称>.md

请审查计划。选项：
1. 批准并继续到[下一阶段]
2. 请求修改计划
3. 中止工作流

[显示计划摘要]

验证-代理：

任务(
  子代理类型=“验证-代理”,
  提示=“”"
  [验证-代理 SKILL.md 内容]

  ---

  要验证的计划: [计划内容]
  计划路径: thoughts/shared/plans/计划-<名称>.md
  交接目录: thoughts/shared/handoffs/<会话>/
  “”"
)

输出：验证交接在<会话>/验证-<名称>.md

检查点：验证-代理后（如果发现问题）

验证完成，发现问题：
- [问题1]
- [问题2]

选项：
1. 继续（承认风险）
2. 更新计划并重新验证
3. 中止工作流

测试驱动开发（用于tdd/重构模式）：

向用户展示TDD指导：

“进入TDD模式。对于每个特征：
1. 先写失败测试
2. 实现最小代码通过
3. 重构同时保持测试通过

我将引导你通过每个周期。从第一个测试开始...”

这是交互式的 - 引导用户通过TDD周期。

实现_计划：

# 检查计划大小
如果 任务数 <= 3:
    # 直接实现
    直接遵循实现_计划技能
否则:
    # 代理编排模式
    对于每个任务：
        任务(
          子代理类型=“实现_任务”,
          提示=“”"
          [实现_任务 SKILL.md 内容]

          ---

          计划: [计划内容]
          你的任务: 任务 N of M: <任务描述>
          先前交接: [先前任务交接或“第一个任务”]
          交接目录: thoughts/shared/handoffs/<会话>/
          “”"
        )

输出：任务交接在<会话>/任务-NN-<描述>.md

检查点：每个实现阶段后

阶段 [N] 完成

自动验证：
- [x] 测试通过
- [x] 类型检查通过
- [ ] 需要手动测试

请验证：
- [计划中的手动测试项目]

继续到下一阶段？[是/n]

提交：

遵循提交技能：
1. 显示git状态和差异
2. 呈现提交计划
3. 用户批准后执行
4. 生成推理文件

描述_pr：

遵循描述_pr技能：
1. 创建PR（如果不存在）
2. 从更改生成描述
3. 用描述更新PR

步骤3：处理错误

如果任何阶段失败或返回阻塞状态：

# 更新编排.yaml
阶段:
  - 技能: 计划-代理
    状态: 完成
  - 技能: 验证-代理
    状态: 阻塞
    错误: “验证发现已弃用库”
    阻塞器: “需要将X替换为Y”

呈现给用户：

工作流阻塞在: 验证-代理

问题: 验证发现已弃用库
阻塞器: 需要将X替换为Y

选项：
1. 重试此阶段
2. 跳过此阶段（不推荐）
3. 中止工作流
4. 手动干预（我将帮你修复）

步骤4：完成

当所有阶段完成：

构建工作流完成！

会话: thoughts/shared/handoffs/<会话>/

创建的工件：
- 规格: thoughts/shared/specs/<名称>-spec.md（如果新特征）
- 计划: thoughts/shared/plans/计划-<名称>.md
- 验证: <会话>/验证-<名称>.md
- 实现交接: <会话>/任务-*.md
- PR: #<数字>（如果未设置--跳过-pr）

提交: <哈希>（如果未设置--跳过提交）

总阶段: N 完成, M 跳过

人类检查点

检查点在关键决策点暂停以进行人类验证：

阶段后	检查点目的
发现-面试	验证规格捕获需求
计划-代理	批准实现计划
验证-代理（如果有问题）	确认验证关切
每个实现任务	验证阶段工作再继续
提交	批准提交消息和文件

跳过检查点： 使用--无检查点运行（仅高级用户）

恢复支持

如果工作流中断，从最后检查点恢复：

/构建 恢复 thoughts/shared/handoffs/<会话>/

这读取编排.yaml并从最后未完成阶段继续。

示例会话

新特征功能

用户: /构建 新特征 添加用户认证与OAuth

Claude: 开始新特征工作流用于“添加用户认证与OAuth”

创建会话: 构建-20260108-用户认证-oauth
链: 发现-面试 -> 计划-代理 -> 验证-代理 -> 实现_计划 -> 提交 -> 描述_pr

阶段1/6: 发现面试
[生成发现-面试代理]

面试问题:
1. 你需要哪些OAuth提供者？（Google、GitHub等）
2. 认证后应存储什么用户数据？
3. 会话应跨浏览器关闭持久吗？
...

[面试完成后]

规格创建: thoughts/shared/specs/2026-01-08-用户认证-spec.md

阶段2/6: 计划
[生成计划-代理]

计划创建: thoughts/shared/plans/计划-用户认证.md

--- 检查点 ---
计划摘要:
- 任务1: 设置OAuth提供者配置
- 任务2: 创建用户模型和会话存储
- 任务3: 实现OAuth回调端点
- 任务4: 添加认证中间件
- 任务5: 创建登录/登出路由

批准计划并继续？[是/n]

用户: 是

阶段3/6: 验证
[生成验证-代理]

验证: 通过
所有技术选择是当前最佳实践。

阶段4/6: 实现（5个任务）
[为每个任务生成实现代理]

任务1/5: OAuth配置... 完成
任务2/5: 用户模型... 完成
任务3/5: OAuth回调... 完成
任务4/5: 认证中间件... 完成
任务5/5: 登录/登出路��... 完成

--- 检查点 ---
所有实现完成。
测试: 24通过
需要手动验证：
- [ ] 测试OAuth流程端到端
- [ ] 验证会话持久性

继续到提交？[是/n]

用户: 是

阶段5/6: 提交
[显示更改，创建提交]

阶段6/6: PR描述
[创建/更新PR]

构建完成！
PR #42: https://github.com/user/repo/pull/42

TDD模式

用户: /构建 tdd 添加速率限制到API端点

Claude: 开始TDD工作流用于“添加速率限制到API端点”

阶段1/3: 计划
[创建带测试规格的计划]

--- 检查点 ---
计划批准？[是/n]

用户: 是

阶段2/3: TDD实现

让我们从第一个测试开始。根据计划，我们需要测试：
“速率限制器在每分钟100个请求后返回429”

红 - 写失败测试：
```python
def 测试_速率限制器_返回_429_后_限制():
    限制器 = 速率限制器(限制=100, 窗口=60)
    对于 _ 在 范围(100):
        断言 限制器.检查(“用户1”) == True
    断言 限制器.检查(“用户1”) == False

运行测试… 失败（如预期 - 速率限制器不存在）

绿 - 实现最小代码： [引导通过实现]

运行测试… 通过

重构 - 需要任何清理吗？

下一个测试: “速率限制器在窗口过期后重置” …

阶段3/3: 实现 [将速率限制器集成到端点中]

构建完成！

### 重构模式

用户: /构建 重构 提取认证逻辑到单独模块

Claude: 开始重构工作流用于“提取认证逻辑到单独模块”

阶段1/4: 影响分析 运行: tldr 影响 认证 src/ --深度 3

影响分析完成:

• 12个文件直接调用认证函数
• 3个入口点受影响
• 未检测到循环依赖

架构分析:

• 认证当前在: src/api/中间件/
• 调用者在: src/api/路由/, src/api/处理器/

— 检查点 — 在计划前审查影响？[是/n]

用户: 是

[显示详细影响报告]

阶段2/4: 计划 [基于影响分析创建重构计划]

…

## 错误恢复

### 如果阶段失败：

阶段3（验证-代理）失败：

错误: 网络搜索不可用

选项：

1. 重试阶段（推荐）
2. 跳过验证（–跳过验证）
3. 中止工作流

选择：

### 如果实现阻塞：

任务3/5阻塞：

阻塞器: 数据库架构不匹配预期结构 找到: users.电子邮件（VARCHAR） 预期: users.电子邮件（UNIQUE VARCHAR）

选项：

1. 创建迁移修复架构
2. 调整计划以使用当前架构
3. 中止并调查

选择：

## 并行执行

使用`--并行`选项，独立阶段并行运行：

/构建 现有代码 --并行 添加仪表板功能

阶段1: 熟悉（开始） 阶段2: 研究-代码库（并行开始）

[两者完成]

阶段3: 计划-代理（使用两者结果） …

仅真正独立阶段并行运行。依赖关系被尊重。

## 配置

### 默认模式偏好

设置在`.claude/settings.json`：

```json
{
  “技能”: {
    “构建”: {
      “默认模式”: “现有代码”,
      “总是验证”: true,
      “自动提交”: false,
      “检查点阶段”: [“计划-代理”, “实现_计划”]
    }
  }
}

故障排除

问题	解决方案
“未找到连续性分类帐”	先运行/熟悉或使用新特征模式
“计划验证失败”	审查验证输出，更新计划
“实现阻塞”	检查交接中的阻塞器，解决依赖
“工作流卡住”	检查编排.yaml状态，恢复或重启

相关技能

• /发现-面试 - 需求深度面试
• /计划-代理 - 创建实现计划
• /验证-代理 - 验证技术选择
• /实现_计划 - 执行实现计划
• /实现_任务 - 单任务实现
• /测试驱动开发 - TDD工作流
• /提交 - 创建提交
• /描述_pr - 生成PR描述
• /熟悉 - 代码库分析
• /研究-代码库 - 研究现有代码
• /tldr-代码 - 代码分析CLI