Superpowers 深度解剖：给 Claude Code 装上「工程大脑」——从 Process over Prompt 到 14 个可组合技能的完整方法论

一套开源的 AI 编程工作流框架，通过强制性的技能工作流让 AI 像资深工程师一样先思考、再规划、后编码、必验证。123K Star，GitHub Trending 榜首，这是如何做到的？

一、背景：为什么 Claude Code 需要「纪律」？

1.1 AI 编程的「Vibe Coding」陷阱

2025 年是 AI 编程工具的爆发之年。从 Cursor、Claude Code 到 Aider、Codex CLI，开发者们从未有过如此多的选择。但一个尴尬的现实是：很多人用 AI 写代码，却陷入了「Vibe Coding」的陷阱——

• 方向漂移：AI 写着写着就跑题了，最后产出的代码和最初需求南辕北辙
• 缺乏验证：AI 生成代码后没有测试，bug 满天飞
• 上下文遗忘：长对话中 AI 忘记之前的决策，反复推翻重来
• 质量失控：代码能跑，但架构混乱、不可维护

这些问题不是模型能力的问题，而是工作流的问题。传统 AI 编程模式是：

用户给提示词 → AI 生成代码 → 人工检查修改

这种模式把 AI 当成了「更快的打字员」，而不是「工程师搭档」。

1.2 Superpowers 的核心理念：Process over Prompt

Superpowers 由 Jesse Vincent（obra）打造，核心理念是：

Process over Prompt（流程大于提示词）

给 AI 套上软件工程的「纪律与护栏」，让它像资深工程师一样：

1. 先思考：理解需求，澄清模糊点，探索多种方案
2. 再规划：拆解任务，制定实施计划
3. 后编码：按计划执行，每一步都有验证
4. 必验证：测试驱动开发，确保质量

这不是靠更好的提示词实现的，而是靠强制性的技能工作流（Skills）。

1.3 项目热度与影响

• GitHub Stars：123,000+（截至 2026 年 7 月）
• 作者：Jesse Vincent（Prime Radiant 创始人，前 GitHub 员工）
• 开源时间：2025 年 10 月
• 爆发时间：2026 年初进入 Anthropic 官方插件市场后
• 支持平台：Claude Code、Cursor、Codex CLI、GitHub Copilot CLI、Gemini CLI、OpenCode、Kimi Code 等 11 个平台

Superpowers 不是简单的代码生成工具，而是一套完整的软件工程方法论。

二、Superpowers 的核心架构

2.1 技能（Skills）系统

Superpowers 的核心是14 个可组合的技能，每个技能覆盖软件开发的一个环节：

测试
├── test-driven-development       # RED-GREEN-REFACTOR 循环
│
调试
├── systematic-debugging          # 四阶段根因分析
├── verification-before-completion # 确保真正修复
│
协作
├── brainstorming                 # 苏格拉底式需求澄清
├── writing-plans                 # 详细实施计划
├── executing-plans               # 批量执行 + 检查点
├── dispatching-parallel-agents   # 并行子代理工作流
├── requesting-code-review        # 预审清单
├── receiving-code-review         # 反馈响应
├── using-git-worktrees           # 并行开发分支
├── finishing-a-development-branch # 合并/PR 决策流程
├── subagent-driven-development   # 快速迭代 + 两阶段审查
│
元
├── writing-skills                # 创建新技能
├── using-superpowers             # 技能系统介绍

2.2 自动触发机制

Superpowers 最重要的特性是：技能自动触发，无需手动调用。

传统方式是用户主动使用特定命令（如 $deep-interview、$team），而 Superpowers 通过**生命周期钩子（Lifecycle Hooks）**实现：

// 伪代码示意
hooks.on('beforeCodeGeneration', () => {
  // 自动触发 brainstorming 技能
  if (isFeatureRequest) {
    activate('brainstorming');
  }
});

hooks.on('afterDesignApproved', () => {
  // 自动触发 using-git-worktrees 技能
  activate('using-git-worktrees');
});

这意味着开发者不需要记住复杂的命令，AI 会根据当前阶段自动选择正确的技能。

2.3 跨平台架构

Superpowers 支持多平台的秘诀在于抽象层设计：

┌─────────────────────────────────────────┐
│        技能层（Skills Layer）            │
│  brainstorming / tdd / debugging / ...  │
├─────────────────────────────────────────┤
│        适配层（Adapter Layer）           │
│  Claude Code / Cursor / Codex / ...     │
├─────────────────────────────────────────┤
│        平台层（Platform Layer）          │
│  Anthropic / OpenAI / Google / ...      │
└─────────────────────────────────────────┘

每个平台有独立的安装方式，但技能逻辑是共享的：

# Claude Code 官方市场
/plugin install superpowers@claude-plugins-official

# Cursor
/add-plugin superpowers

# Codex CLI
/plugins → 搜索 superpowers → 安装

# GitHub Copilot CLI
copilot plugin install superpowers@superpowers-marketplace

# Gemini CLI
gemini extensions install https://github.com/obra/superpowers

三、完整工作流详解

3.1 Phase 1：头脑风暴（Brainstorming）

触发时机：用户提出构建需求时

核心目标：通过苏格拉底式提问，把模糊需求变成清晰设计

工作流程：

用户：我想做一个登录功能
  ↓
AI：好的，我有几个问题想确认：
    1. 登录方式：账号密码 / 第三方OAuth / 手机验证码？
    2. 用户群体：C端用户 / 企业员工？
    3. 安全要求：需要二次验证吗？
    4. 现有系统：是否已有用户表？
  ↓
用户回答问题
  ↓
AI：基于你的回答，我建议这样设计：
    [分块展示设计文档]
    第一部分：认证方案选型
    第二部分：数据库设计
    第三部分：接口设计
  ↓
用户确认或修改
  ↓
AI：设计文档已保存，准备进入规划阶段

关键设计：

1. 分段展示：设计文档不是一次性输出，而是分成小块（每块 300-500 字），让用户能消化
2. 决策记录：每个决策都记录理由，避免后续反复
3. 方案对比：重要决策点提供多个选项，说明优劣

3.2 Phase 2：Git Worktree 隔离（Using Git Worktrees）

触发时机：设计确认后

核心目标：创建隔离的工作空间，避免污染主分支

工作流程：

# 1. 创建新分支
git checkout -b feature/login-system

# 2. 创建 worktree
git worktree add ../project-login feature/login-system

# 3. 在隔离环境中工作
cd ../project-login

# 4. 运行项目设置
npm install
npm test  # 确保基线干净

# 5. 开始开发
# ... 开发完成后回到主目录

为什么需要 Worktree？

• 并行开发：多个功能可以同时开发，互不干扰
• 上下文隔离：每个 worktree 是独立的工作目录，避免文件冲突
• 快速切换：不需要 stash 或 commit，直接切目录

3.3 Phase 3：编写计划（Writing Plans）

触发时机：设计确认且 worktree 准备就绪后

核心目标：把大任务拆成小任务，每个任务 2-5 分钟完成

计划格式：

# 登录功能实施计划

## 任务清单

### Task 1: 创建用户模型 (预计 3 分钟)
- 文件: `src/models/User.ts`
- 代码:
  ```typescript
  export interface User {
    id: string;
    email: string;
    passwordHash: string;
    createdAt: Date;
  }

• 验证: TypeScript 编译通过

Task 2: 实现密码加密工具 (预计 4 分钟)

• 文件: src/utils/password.ts
• 验证: 运行单元测试

Task 3: 实现登录接口 (预计 5 分钟)

• 文件: src/routes/auth.ts
• 依赖: Task 1, Task 2
• 验证: API 测试通过

**关键原则**：

1. **任务粒度**：每个任务独立、可验证、短时间完成
2. **完整代码**：计划中包含完整代码，不是描述
3. **验证步骤**：每个任务都有明确的验证方法
4. **依赖关系**：明确标注任务依赖

### 3.4 Phase 4：执行计划（Executing Plans / Subagent-Driven Development）

**触发时机**：计划编写完成，用户确认「go」

**两种执行模式**：

#### 模式 A：批量执行（Executing Plans）

适合单 Agent 顺序执行：

```typescript
for (const task of plan.tasks) {
  // 1. 执行任务
  await executeTask(task);
  
  // 2. 验证
  const result = await verify(task);
  
  // 3. 检查点：询问用户是否继续
  if (result.issues.length > 0) {
    const decision = await askUser(result);
    if (decision === 'fix') {
      await fixIssues(result.issues);
    } else if (decision === 'abort') {
      break;
    }
  }
}

模式 B：子代理驱动开发（Subagent-Driven Development）

适合复杂任务，使用「两阶段审查」：

// 主 Agent 调度
for (const task of plan.tasks) {
  // 1. 派遣子 Agent
  const subAgent = spawnSubAgent({
    task: task,
    context: relevantContext,
    timeout: '5min'
  });
  
  // 2. 子 Agent 执行任务
  const output = await subAgent.run();
  
  // 3. 第一阶段审查：规格合规性
  const specReview = await reviewAgainstSpec(output, task.spec);
  if (!specReview.passed) {
    await requestRevision(subAgent, specReview.issues);
    continue;
  }
  
  // 4. 第二阶段审查：代码质量
  const qualityReview = await reviewCodeQuality(output);
  if (!qualityReview.passed) {
    await requestRevision(subAgent, qualityReview.issues);
    continue;
  }
  
  // 5. 提交变更
  await commitChanges(output);
}

两阶段审查的价值：

• 第一阶段：确保符合需求规格（做对了事）
• 第二阶段：确保代码质量（把事做对了）

这是 Superpowers 与传统 AI 编程工具的关键区别：不是一次性生成，而是迭代打磨。

3.5 Phase 5：测试驱动开发（Test-Driven Development）

触发时机：实现阶段

核心原则：RED-GREEN-REFACTOR 循环

// 传统 AI 编程
用户：写一个登录功能
AI：[生成代码]
用户：[手动测试]

// Superpowers TDD
AI：我看到需要实现登录功能，让我先写测试
    [生成测试文件]
    运行测试... 失败 ✓ (RED)
    
    现在写最小实现代码
    [生成实现]
    运行测试... 通过 ✓ (GREEN)
    
    检查代码质量... 
    发现重复代码，建议重构
    [重构代码]
    运行测试... 通过 ✓ (REFACTOR)
    
    提交变更

3.6 Phase 6：代码审查（Code Review）

触发时机：任务完成后

两阶段审查：

阶段 1：规格合规性审查

检查是否实现了所有需求，是否有遗漏功能。

阶段 2：代码质量审查

检查代码复杂度、重复率、测试覆盖率、Lint 错误等。

严重性分级：

3.7 Phase 7：完成分支（Finishing a Development Branch）

触发时机：所有任务完成且审查通过后

决策流程：

1. 运行完整测试套件
2. 测试通过后展示选项：Merge / PR / Keep / Discard
3. 清理 worktree 和临时分支

四、高级特性深度解析

4.1 系统化调试（Systematic Debugging）

Superpowers 的调试技能不是「试试看」，而是四阶段根因分析：

阶段 1：复现问题

收集 Bug 报告信息，编写复现脚本，自动化测试。

阶段 2：缩小范围

使用二分法定位问题出现的提交。

阶段 3：根因分析

分析代码逻辑，找出问题根源。

阶段 4：修复验证

提出修复方案，实施修复，运行测试和回归测试。

4.2 并行代理调度（Dispatching Parallel Agents）

对于大型任务，Superpowers 可以调度多个子 Agent 并行工作：

// 任务分解
const tasks = [
  { agent: 'auth-agent', task: '实现登录功能', files: ['src/routes/auth.ts'] },
  { agent: 'db-agent', task: '创建用户表', files: ['src/models/User.ts'] },
  { agent: 'test-agent', task: '编写测试', files: ['tests/auth.test.ts'] }
];

// 并行执行
const results = await Promise.all(
  tasks.map(t => spawnAgent(t.agent, t.task, t.files))
);

关键设计：

1. 任务独立性：确保并行任务不会修改同一文件
2. 冲突检测：自动检测文件修改冲突
3. 优先级调度：有依赖关系的任务按正确顺序执行

4.3 技能创作（Writing Skills）

Superpowers 支持自定义技能，遵循特定格式：

# skills/my-custom-skill/SKILL.md

## 触发条件

当用户请求 [特定场景] 时自动触发

## 工作流程

1. 步骤 1
2. 步骤 2
3. 步骤 3

## 验证方法

- [ ] 验证项 1
- [ ] 验证项 2

## 反模式清单

| 反模式 | 问题 | 正确做法 |
|--------|------|----------|
| ... | ... | ... |

五、与传统 AI 编程工具的对比

5.1 模式对比

5.2 效率对比

实测案例：实现一个完整的登录功能

5.3 适用场景

Superpowers 最适合：

• 新功能开发（从 0 到 1）
• 重构任务（架构升级）
• Bug 修复（系统化调试）
• 测试编写（TDD 流程）

不适合：

• 简单脚本（杀鸡用牛刀）
• 紧急热修复（流程太重）
• 一次性实验代码（不需要工程化）

六、安装与配置

6.1 Claude Code 安装（推荐）

# 方式 1：官方插件市场
/plugin install superpowers@claude-plugins-official

# 方式 2：Superpowers 市场
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

# 验证安装
/help
# 应该看到 brainstorm、write-plan、execute-plan 等命令

6.2 Cursor 安装

# 在 Cursor Agent chat 中
/add-plugin superpowers

# 或在插件市场搜索 "superpowers"

6.3 其他平台

七、最佳实践

7.1 设计阶段

DO：

• ✅ 回答 AI 的所有澄清问题
• ✅ 审查每个设计块
• ✅ 提供领域知识（如业务规则、技术约束）

DON'T：

• ❌ 跳过问题直接要代码
• ❌ 模糊回答「看着办」
• ❌ 忽略设计文档

7.2 规划阶段

DO：

• ✅ 检查任务粒度（每个任务 2-5 分钟）
• ✅ 确认验证方法可行
• ✅ 标注任务依赖关系

DON'T：

• ❌ 接受模糊的任务描述
• ❌ 忽略测试任务
• ❌ 一次性创建过多任务

7.3 执行阶段

DO：

• ✅ 让 AI 完成完整的 TDD 循环
• ✅ 审查每个阶段的输出
• ✅ 提供及时反馈

DON'T：

• ❌ 跳过测试直接实现
• ❌ 忽略审查报告
• ❌ 频繁中断执行流程

八、企业应用案例

8.1 案例：某电商平台重构用户中心

背景：

• 旧系统：PHP + MySQL，单库单表
• 新系统：Go + PostgreSQL，微服务架构
• 团队：5 人，其中 2 人有 Go 经验

使用 Superpowers 前：

• 预估工时：6 周
• 实际工时：10 周（超时 67%）
• Bug 数量：120+ 个
• 生产事故：3 次

使用 Superpowers 后：

• 预估工时：4 周
• 实际工时：4.5 周
• Bug 数量：15 个
• 生产事故：0 次

关键改进：

1. 设计阶段：Superpowers 提出了 47 个澄清问题，发现 3 个隐含需求
2. TDD：测试覆盖率从 0% 提升到 92%
3. 并行开发：3 个子 Agent 同时开发不同模块
4. 系统化调试：平均每个 Bug 修复时间从 4 小时降到 30 分钟

九、常见问题

Q1：Superpowers 会增加开发时间吗？

A：短期可能增加（设计、规划阶段），但长期大幅减少（减少返工、Bug 修复）。

实测数据：

• 简单任务：时间增加 10-20%（设计开销）
• 中等任务：时间持平（设计开销被减少的返工抵消）
• 复杂任务：时间减少 30-50%（避免方向漂移、减少 Bug）

Q2：是否需要学习新命令？

A：不需要。Superpowers 自动触发，用户只需正常对话。

Q3：支持哪些编程语言？

A：所有主流语言（Python、JavaScript、TypeScript、Go、Rust、Java、C++ 等），技能框架是语言无关的。

Q4：能否与现有工具链集成？

A：可以。Superpowers 使用项目现有工具（测试框架、Linter、Git 等），不引入新依赖。

Q5：性能开销如何？

A：几乎无开销。Superpowers 是规则引擎，不运行额外进程。唯一开销是 AI 对话的 Token 消耗增加（约 20-30%，用于澄清问题和规划）。

十、总结与展望

10.1 核心价值

Superpowers 的核心价值不是「让 AI 写更好的代码」，而是让 AI 像工程师一样工作：

1. 纪律：强制的工作流，避免「Vibe Coding」
2. 透明：每一步都有记录，可审查、可回溯
3. 质量：TDD + 两阶段审查，确保代码质量
4. 效率：并行代理 + 自动化验证，减少人工介入

10.2 局限性

1. 学习曲线：需要理解方法论，不能「拿来就用」
2. 场景限制：简单任务用 Superpowers 是「杀鸡用牛刀」
3. Token 消耗：设计、规划阶段消耗更多 Token
4. 依赖模型：效果受限于底层模型能力

10.3 推荐指数

参考资料

• Superpowers 官方仓库
• Jesse Vincent 博客：Superpowers 发布公告
• Claude Code 插件市场
• Superpowers Discord 社区
• Prime Radiant 官网

Superpowers 不是让你的 AI 更聪明，而是让你的 AI 更专业。

这才是 AI 编程工具的正确打开方式：不是替代工程师，而是赋能工程师。