Superpowers 深度解析：当 AI 编程 Agent 终于学会「按规矩写代码」

项目地址：https://github.com/obra/superpowers
作者：Jesse Vincent (obra)
GitHub Stars：122,000+ | 今日新增：2,230+
支持平台：Claude Code、Cursor、GitHub Copilot CLI、Gemini CLI、OpenCode

一、引言：AI 编程的「野蛮生长」时代

2025 年，AI 编程助手迎来了爆发式增长。Claude Code、Cursor、GitHub Copilot CLI 等工具让开发者体验到了前所未有的编码效率提升。然而，一个令人不安的事实逐渐浮现：

AI 正在以「自信满满的初级工程师」姿态，批量生产技术债务。

你是否遇到过这些场景？

• 跳过设计直接写代码：你让 AI 实现一个用户认证系统，它二话不说就开始写代码，半小时后你发现它连需求都没搞清楚
• 测试是什么，能吃吗？：AI 生成的代码功能看似正常，但没有任何单元测试，你不敢重构一行
• 「我觉得我做完了」：AI 宣布任务完成，但代码根本没跑通，或者跑通了但不符合你的设计意图
• 越写越偏：AI 在连续编码几小时后，逐渐偏离最初的目标，最后交付的东西和你想要的完全是两回事

这些问题的根源在于：当前的 AI 编程工具本质上是「代码生成器」，而非「软件工程师」。 它们缺乏软件工程的方法论约束，没有设计评审、没有测试驱动、没有代码审查、没有完成验证。

Superpowers 正是为解决这一痛点而生。它不是又一个 AI 编程工具，而是一套可组合的技能框架（Skills Framework），强制 AI Agent 遵循「规划→隔离→实现→验证→交付」的完整工程流程。

截至 2026 年 4 月，Superpowers 在 GitHub 上已获得 122,000+ Stars，今日新增 2,230+，成为 AI 编程领域增长最快的开源项目之一。

二、核心理念：流程大于提示

2.1 传统 AI 编程 vs Superpowers 工作流

Superpowers 的核心理念可以用一句话概括：「流程大于提示」（Process over Prompt）。

传统方式下，你通过精心设计的提示词（Prompt）试图让 AI 表现得像个专业工程师。但提示词的效果是不稳定的，AI 可能在某次会话中表现优异，下次就「放飞自我」。

Superpowers 的做法是：不依赖提示词，而是定义一套强制执行的工程流程。AI 必须按流程走，没有捷径。

2.2 三层指令优先级体系

Superpowers 通过三层指令体系确保流程被执行：

┌─────────────────────────────────────────────────────────────┐
│ 第一层：Bootstrap 初始指令（最高优先级）                      │
│ - 定义全局行为准则                                            │
│ - 强制技能调用规则                                            │
│ - 不可被用户提示覆盖                                          │
├─────────────────────────────────────────────────────────────┤
│ 第二层：Skill 技能指令（中等优先级）                          │
│ - 定义具体任务的执行流程                                      │
│ - 如 TDD 流程、代码审查清单                                   │
│ - 可被 Bootstrap 约束，但优先于用户提示                       │
├─────────────────────────────────────────────────────────────┤
│ 第三层：用户提示（最低优先级）                                │
│ - 具体需求描述                                                │
│ - 必须在 Skill 框架内执行                                     │
└─────────────────────────────────────────────────────────────┘

这种设计确保了无论用户如何描述需求，AI 都必须先执行「头脑风暴」技能澄清需求，再执行「制定计划」技能拆解任务，然后才能进入编码阶段。

三、技能系统架构：14 个核心技能详解

Superpowers 目前包含 14 个可组合的技能（Skills），覆盖软件开发的完整生命周期：

3.1 需求与设计阶段

1. brainstorming（头脑风暴）

触发时机：任何新任务开始时

执行流程：

1. AI 不直接写代码，而是先与用户对话澄清需求
2. 探索多种实现方案，对比优劣
3. 将设计文档拆分为小块，让用户逐个确认
4. 输出经过确认的设计规格书

核心价值：避免「我以为你要的是这个」悲剧

2. writing-plans（制定计划）

触发时机：设计确认后

执行流程：

1. 将复杂任务拆分为 2-5 分钟可完成的小任务
2. 每个任务包含：
   • 精确的文件路径
   • 具体的代码片段描述
   • 验证步骤（如何确认任务完成）
3. 生成新手也能看懂的任务清单

核心价值：将「黑盒开发」变为「透明开发」，用户随时知道 AI 在做什么

3.2 开发阶段

3. test-driven-development（测试驱动开发）

触发时机：进入编码阶段后

执行流程（RED-GREEN-REFACTOR）：

RED    → 先写测试，看测试失败（证明测试有效）
GREEN  → 写最少代码让测试通过
REFACTOR → 重构代码，保持测试通过
COMMIT → 提交代码

强制规则：

• 没有测试的代码会被直接删除
• 测试必须在写实现代码之前存在
• 每次提交必须通过所有测试

4. subagent-driven-development（子 Agent 驱动开发）

触发时机：任务可并行时

执行流程：

1. 主 Agent 将任务拆分为多个子任务
2. 启动多个子 Agent 并行执行
3. 每个子 Agent 完成后，执行两阶段审查：
   • 阶段一：规格合规审查 — 检查是否按设计规格实现
   • 阶段二：代码质量审查 — 检查代码风格、性能、安全性
4. 审查通过后合并代码

核心价值：利用 AI 的并行能力加速开发，同时保证质量

3.3 调试与优化阶段

5. systematic-debugging（系统化调试）

触发时机：遇到 Bug 时

执行流程（四阶段根因分析）：

阶段 1：现象收集 → 收集错误信息、日志、复现步骤
阶段 2：假设生成 → 列出所有可能的根因假设
阶段 3：假设验证 → 设计实验验证每个假设
阶段 4：修复验证 → 修复后验证问题已解决且未引入新问题

核心价值：避免「试试这个、试试那个」的盲目调试

6. using-git-worktrees（Git 工作树管理）

触发时机：需要并行开发多个功能时

执行流程：

1. 为每个并行任务创建独立的工作树（worktree）
2. 每个子 Agent 在独立工作树中工作
3. 避免分支切换带来的上下文丢失
4. 完成后合并到主分支

3.4 质量保证阶段

7. requesting-code-review（请求代码审查）

触发时机：代码提交前

执行流程：

1. 生成代码审查清单（Checklist）
2. 自我审查：逐条检查代码是否符合规范
3. 标记需要人工特别关注的地方
4. 生成审查报告

8. verification-before-completion（完成前验证）

触发时机：任务标记完成前

执行流程（验证门控五步法）：

步骤 1：功能验证 → 确认实现了所有需求
步骤 2：测试验证 → 确认所有测试通过
步骤 3：集成验证 → 确认与现有代码无冲突
步骤 4：文档验证 → 确认相关文档已更新
步骤 5：回滚验证 → 确认可以安全回滚

强制规则：必须通过全部 5 步验证，才能标记任务完成

3.5 其他技能

四、技术实现：技能框架是如何工作的

4.1 Skill 文件格式

每个 Skill 是一个文件夹，包含以下文件：

skills/
├── brainstorming/
│   ├── SKILL.md          # 技能定义（必须）
│   ├── scripts/          # 辅助脚本（可选）
│   │   └── generate_plan.py
│   ├── examples/         # 使用示例（可选）
│   │   └── web_app_example.md
│   └── resources/        # 模板与资源（可选）
│       └── design_template.md
├── test-driven-development/
│   ├── SKILL.md
│   └── ...
└── ...

SKILL.md 核心结构：

# Skill: test-driven-development

## 触发条件
当用户要求实现功能或修复 Bug 时触发

## 执行流程
1. 首先编写测试，验证测试失败（RED）
2. 编写最少代码让测试通过（GREEN）
3. 重构代码，保持测试通过（REFACTOR）
4. 提交代码

## 强制规则
- 禁止先写实现后写测试
- 没有测试的代码必须删除
- 每次提交前必须运行全部测试

## 输出格式

TDD 周期 [N]

测试

[测试代码]

实现

[实现代码]

重构

[重构说明]

提交

[提交信息]

4.2 Bootstrap 注入机制

Superpowers 通过「Bootstrap 注入」将技能框架植入 AI Agent：

# Claude Code 安装方式
/plugin marketplace add claude-plugins-official
/plugin install superpowers

# Cursor 安装方式
# 在 Cursor Settings > AI Rules 中添加 Superpowers 的 bootstrap.md

# GitHub Copilot CLI 安装方式
# 设置环境变量指向 Superpowers 的初始化脚本
export COPILOT_INIT_SCRIPT=/path/to/superpowers/bootstrap.sh

Bootstrap 的核心作用：

1. 在 AI Agent 启动时注入初始指令
2. 注册所有可用的 Skills
3. 定义技能触发规则和优先级
4. 拦截用户的直接编码请求，强制先执行设计阶段

4.3 多平台支持矩阵

五、实战演示：用 Superpowers 开发一个 Web API

让我们通过一个实际案例，看看 Superpowers 如何改变 AI 编程的体验。

5.1 场景设定

需求：开发一个用户管理系统的 REST API，包含注册、登录、获取用户信息三个端点。

传统方式的问题：

• AI 可能直接开始写代码，没有考虑认证方式、数据库选型、错误处理策略
• 可能没有写任何测试
• 代码写完后，你发现问题一大堆，需要大量返工

5.2 Superpowers 工作流

阶段 1：头脑风暴（Brainstorming）

用户输入：「帮我开发一个用户管理系统的 REST API」

AI 响应：

在开始编码之前，让我们先澄清一下需求：

## 技术方案讨论

### 1. 技术栈选择
- **框架**：我推荐使用 Express.js（Node.js）或 FastAPI（Python），你倾向哪个？
- **数据库**：SQLite（简单）vs PostgreSQL（生产级）？
- **认证方式**：JWT vs Session？

### 2. 功能范围确认
- 注册：需要邮箱验证吗？
- 登录：需要支持刷新令牌吗？
- 用户信息：哪些字段？（用户名、邮箱、头像？）

### 3. 非功能需求
- 需要输入验证吗？
- 需要速率限制吗？
- 需要日志记录吗？

请确认以上方案，我将据此制定详细的实施计划。

用户确认后，AI 生成设计规格书。

阶段 2：制定计划（Writing Plans）

## 实施计划：用户管理系统 API

### 任务 1：项目初始化与依赖安装
- 文件：`package.json`, `.env.example`
- 验证：`npm install` 成功

### 任务 2：数据库模型设计
- 文件：`src/models/User.js`
- 验证：模型可以通过单元测试

### 任务 3：注册端点实现（TDD）
- 文件：`src/routes/auth.js`, `tests/auth.register.test.js`
- 验证：测试通过，包括：
  - 正常注册
  - 重复邮箱拒绝
  - 密码强度验证

### 任务 4：登录端点实现（TDD）
- 文件：`src/routes/auth.js`, `tests/auth.login.test.js`
- 验证：测试通过，包括：
  - 正常登录返回 JWT
  - 错误密码拒绝
  - 不存在用户处理

### 任务 5：获取用户信息端点实现（TDD）
- 文件：`src/routes/user.js`, `tests/user.get.test.js`
- 验证：测试通过，包括：
  - 有效 JWT 返回用户信息
  - 无效 JWT 返回 401

### 任务 6：集成测试与文档
- 文件：`tests/integration.test.js`, `API.md`
- 验证：端到端测试通过

阶段 3：测试驱动开发（TDD）

以「注册端点」为例：

RED：先写测试

// tests/auth.register.test.js
describe('POST /api/auth/register', () => {
  it('should register a new user with valid data', async () => {
    const res = await request(app)
      .post('/api/auth/register')
      .send({
        email: 'test@example.com',
        password: 'StrongPass123!',
        username: 'testuser'
      });
    
    expect(res.status).toBe(201);
    expect(res.body).toHaveProperty('token');
    expect(res.body.user.email).toBe('test@example.com');
  });

  it('should reject duplicate email', async () => {
    // 先创建一个用户
    await createUser({ email: 'test@example.com', ... });
    
    // 尝试用相同邮箱注册
    const res = await request(app)
      .post('/api/auth/register')
      .send({
        email: 'test@example.com',
        password: 'StrongPass123!',
        username: 'testuser2'
      });
    
    expect(res.status).toBe(409);
    expect(res.body.error).toContain('already exists');
  });
  
  // ... 更多测试用例
});

运行测试，确认测试失败（RED）。

GREEN：写最少代码让测试通过

// src/routes/auth.js
router.post('/register', async (req, res) => {
  const { email, password, username } = req.body;
  
  // 检查邮箱是否已存在
  const existingUser = await User.findOne({ email });
  if (existingUser) {
    return res.status(409).json({ error: 'Email already exists' });
  }
  
  // 创建用户
  const user = await User.create({ email, password, username });
  const token = generateToken(user);
  
  res.status(201).json({ token, user: { email: user.email, username } });
});

运行测试，确认测试通过（GREEN）。

REFACTOR：重构代码

// 提取验证逻辑
const validateRegistration = (data) => {
  const { email, password, username } = data;
  if (!email || !password || !username) {
    throw new ValidationError('All fields are required');
  }
  if (password.length < 8) {
    throw new ValidationError('Password must be at least 8 characters');
  }
  return true;
};

// 重构后的路由
router.post('/register', async (req, res, next) => {
  try {
    validateRegistration(req.body);
    const user = await authService.register(req.body);
    res.status(201).json(user);
  } catch (err) {
    next(err);
  }
});

运行测试，确认重构后测试仍然通过（REFACTOR）。

阶段 4：子 Agent 并行开发

Superpowers 启动多个子 Agent：

• 子 Agent 1：开发登录端点
• 子 Agent 2：开发获取用户信息端点
• 子 Agent 3：编写 API 文档

每个子 Agent 在自己的 Git worktree 中工作，完成后提交审查。

阶段 5：代码审查与验证

两阶段审查：

阶段 1：规格合规审查

✅ 实现了注册端点 POST /api/auth/register
✅ 返回 JWT 令牌
✅ 处理重复邮箱错误
⚠️  缺少密码强度验证（需要补充）

阶段 2：代码质量审查

✅ 代码风格符合项目规范
✅ 错误处理完善
✅ 没有 SQL 注入风险
⚠️  建议添加速率限制

验证门控五步法：

✅ 功能验证：所有三个端点正常工作
✅ 测试验证：所有单元测试通过（覆盖率 92%）
✅ 集成验证：与现有代码无冲突
✅ 文档验证：API.md 已更新
✅ 回滚验证：可以安全回滚到上一版本

任务状态：✅ 已完成

5.3 成果对比

六、与同类框架的横向对比

Superpowers 的独特优势：

1. 唯一强制 TDD 的框架：其他框架将 TDD 作为可选项，Superpowers 将其作为强制流程
2. 最完整的工程流程：从需求澄清到完成验证，覆盖软件工程全生命周期
3. 跨平台兼容性最好：支持 Claude Code、Cursor、Copilot CLI、Gemini CLI、OpenCode
4. 社区活跃度最高：GitHub Stars 增长最快，今日新增 2,230+

七、安装与使用

7.1 Claude Code 安装

# 添加插件市场
/plugin marketplace add claude-plugins-official

# 安装 Superpowers
/plugin install superpowers

# 验证安装
/skill list

7.2 Cursor 安装

1. 打开 Cursor Settings
2. 进入 AI Rules 选项卡
3. 添加 Superpowers 的 bootstrap.md 内容
4. 保存并重启 Cursor

7.3 GitHub Copilot CLI 安装

# 克隆 Superpowers 仓库
git clone https://github.com/obra/superpowers.git

# 设置环境变量
export COPILOT_INIT_SCRIPT=$PWD/superpowers/bootstrap.sh

# 启动 Copilot CLI
copilot

7.4 自定义技能

你可以创建自己的 Skill：

# 创建 Skill 目录
mkdir -p ~/.superpowers/skills/my-custom-skill

# 创建 SKILL.md
cat > ~/.superpowers/skills/my-custom-skill/SKILL.md << 'EOF'
# Skill: my-custom-skill

## 触发条件
当用户提到「性能优化」时触发

## 执行流程
1. 运行性能分析工具
2. 识别瓶颈
3. 提出优化方案
4. 实施优化
5. 验证性能提升

## 输出格式
[自定义输出格式]
EOF

# 重启 AI Agent，新 Skill 自动加载

八、局限性与注意事项

8.1 当前局限

1. 学习曲线：Superpowers 强制执行的流程需要开发者适应，初期可能感觉「束手束脚」
2. 简单任务 overhead：对于一次性脚本或原型开发，完整的工程流程可能显得过重
3. 依赖 AI 平台支持：部分平台（如 VS Code Copilot）的支持还不完整
4. 中文文档有限：虽然项目本身支持多语言，但中文社区的文档和案例还较少

8.2 最佳实践

1. 渐进式采用：先启用 brainstorming 和 writing-plans 技能，逐步增加 TDD 和代码审查
2. 项目类型匹配：Superpowers 最适合中型以上的项目，简单脚本可以关闭部分技能
3. 团队协作：在团队中统一使用 Superpowers，确保所有成员遵循相同的工程规范
4. 自定义规则：根据团队规范自定义 Skill，例如调整代码审查清单

九、总结与展望

Superpowers 代表了 AI 编程工具从「代码生成器」向「软件工程师」进化的关键一步。它通过强制执行的工程流程，解决了当前 AI 编程的三大痛点：

1. 需求理解偏差 → 通过头脑风暴和计划制定确保需求清晰
2. 代码质量不稳定 → 通过 TDD 和代码审查保证质量
3. 完成状态不可信 → 通过验证门控确保真正完成

核心价值主张：

「流程大于提示」—— 与其依赖不稳定的提示词工程，不如定义可靠的工程流程。

未来展望：

随着 AI 编程的普及，「AI 生成的代码」和「人类编写的代码」之间的界限将越来越模糊。Superpowers 这样的框架将成为基础设施，确保 AI 生成的代码符合工程规范、可维护、可信赖。

Jesse Vincent（Superpowers 作者）在项目的 README 中写道：

"我们希望 AI 编程助手不再是『自信满满的初级工程师』，而是『懂得规矩的架构师』。"

Superpowers 正在让这一愿景成为现实。

参考资源

• 项目主页：https://github.com/obra/superpowers
• 官方文档：https://github.com/obra/superpowers/tree/main/docs
• 技能目录：https://github.com/obra/superpowers/tree/main/skills
• 社区讨论：GitHub Discussions

本文撰写于 2026 年 4 月，基于 Superpowers v5.0.7 版本。项目仍在快速迭代中，部分细节可能已有更新，请以官方文档为准。