Superpowers：让AI编程像老师傅带徒弟

TL;DR

Superpowers 解决的核心问题：AI写代码容易”拿起键盘就是干”，结果改一处崩三处。

它的解决方案：给AI装上”老师傅的工作流程”——先画图纸（设计）、再列清单（规划）、后动手（TDD实现）。

适合谁用：
– 用 Claude Code 写代码的开发者
– 受够了AI”聪明一时、翻车一世”的人
– 想让AI遵循专业开发流程的团队

一、问题：AI写代码为什么容易翻车

1.1 典型场景

你对AI说：”给这个函数加个缓存功能。”

没有Superpowers的AI：

✅ 2分钟写完代码
❌ 没写测试
❌ 没考虑边界条件
❌ 引入了新bug
❌ 你花30分钟调试

装了Superpowers的AI：

1. 先问你：缓存策略用LRU还是TTL？
2. 列出实现计划：改哪3个文件，预计影响范围
3. 先写失败的测试
4. 再写实现代码
5. 验证测试通过

1.2 根本原因

AI的天然弱点：
– 看到需求就想写代码（像拿到锤子就想砸钉子）
– 不会主动思考”这样改会影响哪里”
– 缺少”先测试后实现”的纪律

结果：短期效率高，长期债务多。

二、Superpowers是什么

2.1 一句话定义

Superpowers = 给AI编程装上”老师傅的工作流程”。

2.2 生活比喻

核心理念：流程不是束缚，是防止翻车的护栏。

三、Superpowers的5阶段工作流

3.1 阶段1：设计（Brainstorming）

目的：确保AI理解需求，而不是”自以为理解”。

AI会做什么：

1. 反问你需求细节（像苏格拉底式提问）
   "你说的缓存，是内存缓存还是Redis？"
   "缓存失效策略是什么？"

2. 列出3种设计方案
   方案A：简单LRU内存缓存
   方案B：Redis + TTL
   方案C：两层缓存（内存+Redis）

3. 分析每个方案的优缺点
   方案A：快，但重启丢失
   方案B：持久，但网络延迟
   方案C：最优，但复杂度高

4. 等你拍板再继续

为什么重要：防止AI理解偏差，省下后期返工时间。

3.2 阶段2：环境准备（Using Git Worktrees）

目的：隔离开发环境，主分支永远干净。

AI会做什么：

# 创建独立工作空间
git worktree add ../feature-cache feature/add-cache

# 在新分支开发
cd ../feature-cache

# 主分支不受影响

生活比喻：装修房子时在客厅搭脚手架，卧室照常住人。

3.3 阶段3：规划（Writing Plans）

目的：把大任务拆成2-5分钟的小任务。

AI生成的计划示例：

### Task 1: 创建缓存接口 (3分钟)
- 文件：src/cache/interface.ts
- 内容：定义 Cache 接口的 get/set/delete 方法
- 验证：TypeScript编译通过

### Task 2: 实现LRU缓存 (5分钟)
- 文件：src/cache/lru.ts
- 内容：用 Map + 双向链表实现
- 验证：单元测试通过

### Task 3: 集成到现有服务 (4分钟)
- 文件：src/services/user.ts
- 改动：在 getUser 前加缓存层
- 验证：集成测试通过

为什么重要：小任务容易验证，出错范围小。

3.4 阶段4：执行（两种模式）

模式A：并行子任务（Dispatching Parallel Agents）

适合场景：多个任务互不依赖。

AI的做法：

同时执行：
- Agent 1: 写缓存接口
- Agent 2: 写Redis客户端
- Agent 3: 更新文档

完成后合并

模式B：检查点批处理（Executing Plans）

适合场景：需要人工确认的关键节点。

AI的做法：

1. 执行前3个任务
2. 暂停，等你review
3. 你确认后继续执行后3个任务

3.5 阶段5：TDD实现（Test-Driven Development）

核心流程：RED → GREEN → REFACTOR

AI的工作节奏：

// Step 1: RED - 先写失败的测试
test('LRU cache should evict oldest item', () => {
  const cache = new LRUCache(2);
  cache.set('a', 1);
  cache.set('b', 2);
  cache.set('c', 3); // 应该淘汰 'a'
  expect(cache.get('a')).toBeUndefined(); // ❌ 测试失败
});

// Step 2: GREEN - 写最简单的实现让测试通过
class LRUCache {
  // ... 实现代码
}
// ✅ 测试通过

// Step 3: REFACTOR - 优化代码结构
// 提取公共方法、改进命名、删除重复代码

为什么重要：
– 先写测试 = 先定义”什么是对的”
– 后写代码 = 朝着目标前进
– 重构 = 保持代码整洁

四、Superpowers的12个核心技能

4.1 测试与质量（4个）

4.2 调试（1个）

调试流程示例：

1. 追踪（Tracing）：复现错误路径
2. 防御（Defense-in-depth）：加断言验证假设
3. 条件等待（Condition-based waiting）：定位时序问题
4. 根因修复（Root cause fix）：改代码而非绕过

4.3 协作开发（6个）

4.4 元技能（2个）

五、如何安装和使用

5.1 安装（3步）

前提：已安装 Claude Code CLI

Step 1: 添加插件市场

/plugin marketplace add obra/superpowers-marketplace

Step 2: 安装插件

/plugin install superpowers@superpowers-marketplace

Step 3: 验证安装

/help
# 看到 /superpowers:* 相关命令即成功

5.2 使用示例

场景：给API添加认证功能

传统方式（没有Superpowers）：

你："加个JWT认证"
AI：duang一下写完200行代码
你：发现没考虑Token刷新，又花1小时改

Superpowers方式：

Step 1: AI触发 brainstorming 技能

AI: "我注意到这个任务需要设计决策，使用 brainstorming 技能。

问题1：认证方案选择？
  A. JWT (无状态，适合分布式)
  B. Session (有状态，需要Redis)
  C. OAuth2 (第三方登录)

问题2：Token存储位置？
  A. LocalStorage (易用但XSS风险)
  B. HttpOnly Cookie (安全但CSRF风险)
  C. Memory + Refresh Token (最安全但复杂)

问题3：Token有效期？
  A. 短期（15分钟Access + 7天Refresh）
  B. 长期（30天单Token）
"

你: "选A+B+A方案"

Step 2: AI触发 writing-plans 技能

### Task 1: 创建JWT工具类 (4分钟)
- 文件: src/auth/jwt.ts
- 依赖: jsonwebtoken库
- 验证: 单元测试生成/验证Token

### Task 2: 实现登录接口 (5分钟)
- 文件: src/routes/auth.ts
- 逻辑: 验证密码 → 生成Token → 设置Cookie
- 验证: 集成测试登录成功

### Task 3: 添加认证中间件 (3分钟)
- 文件: src/middleware/auth.ts
- 逻辑: 从Cookie读Token → 验证 → 注入user到req
- 验证: 测试保护路由返回401

### Task 4: 实现Token刷新 (4分钟)
- 文件: src/routes/refresh.ts
- 逻辑: 验证RefreshToken → 签发新AccessToken
- 验证: 测试过期Token可刷新

Step 3: AI触发 test-driven-development 技能

// AI先写失败测试
describe('JWT Authentication', () => {
  test('should generate valid token', () => {
    const token = jwt.sign({ userId: 1 });
    expect(jwt.verify(token)).toEqual({ userId: 1 }); // ❌
  });
});

// 再写实现
export const jwt = {
  sign: (payload) => jsonwebtoken.sign(payload, SECRET, { expiresIn: '15m' }),
  verify: (token) => jsonwebtoken.verify(token, SECRET)
};
// ✅ 测试通过

Step 4: AI触发 verification-before-completion 技能

# AI执行验证命令
npm test -- auth.test.ts  # ✅ 单元测试通过
npm run test:integration  # ✅ 集成测试通过
curl -X POST /api/login   # ✅ 手动验证可登录

AI: "所有验证通过，任务完成。"

5.3 关键理解

Superpowers不是可选建议，是强制流程：

❌ 错误理解："AI提示我用TDD，但我觉得不需要，跳过。"
✅ 正确理解："技能激活=必须遵循，这是防止翻车的护栏。"

技能触发规则：
– AI检测到任务匹配技能描述 → 自动激活
– 你可以手动调用：/superpowers:brainstorming
– 一旦激活，AI必须走完整个流程

六、设计哲学：为什么这样设计

6.1 四大支柱

6.2 为什么需要强制流程

AI的自由发挥 = 熵增：

Day 1: AI写代码很快
Day 7: 代码库一团乱麻
Day 30: 没人敢改代码

Superpowers的约束 = 熵减：

每次改动：
1. 有设计文档（为什么这么改）
2. 有任务计划（改了哪些文件）
3. 有测试覆盖（怎么验证对错）
4. 有代码审查（别人能看懂）

结果：代码库长期保持健康

6.3 与Linus Good Taste的共鸣

Linus的”好品味”代码原则：
– 消除特殊情况，而非增加if/else
– 设计让边界自然融入常规
– 三个以上分支立即重构

Superpowers的体现：
– brainstorming 阶段强制思考”能否用更简单的设计消除分支”
– test-driven-development 通过测试驱动设计，避免过度复杂
– systematic-debugging 要求找根因而非打补丁

案例：链表删除节点

坏品味（特殊情况处理）：

if (node == head) {
  head = node->next;
} else if (node->next == NULL) {
  prev->next = NULL;
} else {
  prev->next = node->next;
}

好品味（哨兵节点设计）：

node->prev->next = node->next; // 一行代码统一处理

Superpowers如何引导AI到好品味：

1. brainstorming阶段AI会问：
   “`
   “我注意到这个设计有3个分支处理删除：
2. 头节点删除
3. 尾节点删除
4. 中间节点删除

可否通过添加哨兵节点消除特殊情况？”
“`

1. writing-plans阶段AI会列出对比：
   “`markdown
   方案A：if/else处理3种情况（12行代码）
   方案B：哨兵节点设计（1行代码）

推荐方案B，理由：
– 消除边界特殊情况
– 代码简洁、易维护
– 符合Good Taste原则
“`

1. test-driven-development阶段测试覆盖边界：
   typescript
test('delete head node', () => { /* 验证哨兵设计 */ });
test('delete tail node', () => { /* 验证哨兵设计 */ });
test('delete middle node', () => { /* 验证哨兵设计 */ });

七、适合谁用

7.1 必备条件

7.2 典型用户画像

✅ 适合的人：
– 独立开发者：一个人维护多个项目，需要代码质量保障
– 技术Leader：希望团队AI助手遵循统一开发规范
– 开源维护者：需要AI生成的代码符合项目风格
– 学习者：想通过AI学习专业开发流程

❌ 不适合的人：
– 写一次性脚本（杀鸡用牛刀）
– 完全不懂编程（流程假设你理解基本概念）
– 追求极致速度（流程会慢一点，但质量高）

八、常见问题

Q1: Superpowers会让AI变慢吗？

A: 单次任务会慢一点，但长期更快。

对比：

没有Superpowers:
  写代码 2分钟 + 调试30分钟 + 返工1小时 = 92分钟

有Superpowers:
  设计5分钟 + 规划3分钟 + TDD实现15分钟 + 验证2分钟 = 25分钟

Q2: 能只用部分技能吗？

A: 可以，但建议完整使用。

理由：技能之间有依赖关系。

brainstorming → writing-plans → test-driven-development
（设计）       （规划）         （实现）

跳过设计直接规划 = 方向可能错
跳过规划直接实现 = 容易遗漏
跳过TDD直接写代码 = 回到老问题

Q3: 如何自定义技能？

A: 使用 writing-skills 技能创建。

示例：创建”前端设计”技能

/superpowers:writing-skills

AI会引导你：
1. 定义技能触发条件
2. 设计技能工作流程
3. 编写技能文档
4. 测试技能可用性

Q4: 与GitHub Copilot有什么区别？

对比：

结论：Copilot是”打字助手”，Superpowers是”项目经理”。

Q5: 开源吗？商业项目能用吗？

A: MIT协议，完全开源，商业项目随意用。

许可证详情：
– 可自由使用、修改、分发
– 可用于商业项目
– 无需支付费用
– 作者Jesse Vincent接受GitHub赞助支持开源工作

九、实战建议

9.1 新手入门路径

Week 1: 熟悉基础技能（3个）

1. using-superpowers: 了解框架理念
2. brainstorming: 学会需求澄清
3. test-driven-development: 掌握TDD流程

Week 2: 完整流程体验（1个小项目）

选择一个真实需求（如：添加用户登录功能）
走完完整5阶段：设计→环境→规划→执行→TDD

Week 3: 进阶技能（3个）

1. systematic-debugging: 系统化调试
2. dispatching-parallel-agents: 并行开发
3. requesting-code-review: 代码审查

9.2 团队推广策略

阶段1：小范围试点

1. 选1-2个愿意尝鲜的开发者
2. 在非关键项目试用1周
3. 收集反馈，调整工作流

阶段2：建立最佳实践

1. 总结常用技能组合（如：新功能开发=brainstorming+writing-plans+TDD）
2. 创建团队自定义技能（如：符合公司代码规范的检查技能）
3. 编写内部使用文档

阶段3：全团队推广

1. 技术分享：演示Superpowers的价值
2. 配对编程：老手带新手体验流程
3. Code Review：检查是否遵循技能流程

9.3 避坑指南

十、未来展望

10.1 技术趋势

AI编程助手的演进方向：

2023: 代码补全（Copilot时代）
2024: 对话式编程（Claude Code时代）
2025: 流程化编程（Superpowers时代）← 我们在这里
2026: ？自适应流程（AI根据项目特点定制流程）

10.2 Superpowers的进化空间

可能的新技能：
– performance-profiling: 性能分析流程
– security-review: 安全漏洞检查流程
– api-design: RESTful API设计流程
– database-migration: 数据库迁移流程

可能的新功能：
– 技能市场：社区贡献的自定义技能
– 流程模板：针对不同语言/框架的预设流程
– 度量仪表盘：跟踪流程遵循率和代码质量指标

十一、总结

核心价值

Superpowers = 把”老师傅的工作纪律”装进AI大脑。

它不是让AI写得更快，而是让AI写得更对。

三个关键认知

1. 流程不是束缚，是护栏
   新手觉得TDD慢，老手知道它省时间。

2. 短期慢一点，长期快很多
   设计5分钟防止返工1小时。

3. AI需要纪律，人类也需要
   Superpowers约束AI，也提醒你遵循最佳实践。

立即开始

# 3条命令，2分钟安装
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace
/help

# 找个小需求，体验完整流程
# 你会发现AI变成了靠谱的老师傅

参考链接
– GitHub仓库：https://github.com/obra/superpowers
– Claude Code官网：https://claude.ai/claude-code
– 作者Jesse Vincent：https://github.com/obra
– MIT开源协议：https://opensource.org/licenses/MIT

订阅更新
关注本站获取更多AI开发工具教程：https://www.80aj.com/