Superpowers 深度解析：让 AI 编程助手"懂工程"的 Agent Skills 框架——从 TDD 到系统化调试的完整工作流实战
摘要：Superpowers 不是另一个 AI 编码工具，而是一套完整的软件开发方法论。它通过 14 个可组合的 Agent Skills，将专业的软件工程实践（TDD、代码审查、系统化调试）注入到 Claude Code、Cursor 等 AI 编程助手中。本文将深入剖析其架构设计、技能体系、工作流程，并通过实际代码示例展示如何让 AI 像资深工程师一样思考和执行。
一、引言：AI 编程的"最后一公里"问题
1.1 当前 AI 编程助手的困境
在 2026 年，AI 编程助手已经能够生成大量代码，但开发者普遍面临一个核心问题：AI 生成的代码往往缺乏工程纪律。
传统的 AI 编程对话通常是这样的：
开发者: "帮我实现一个用户认证模块"
AI: [直接生成 200 行代码]
开发者: "这段代码有 bug，登录失败..."
AI: [修补一处，引入新 bug]
...
这种模式下，AI 只是一个"快速代码生成器"，而不是一个"遵循工程纪律的开发伙伴"。
1.2 Superpowers 的破局之道
Superpowers 由 Jesse Vincent（obra）打造，其核心哲学是：
"Process over Prompt"（流程大于提示词）
它不试图让模型变得更"聪明"，而是给 AI 套上软件工程的"纪律与护栏"，让它像资深工程师一样：
- 先思考 → 头脑风暴（brainstorming）
- 再规划 → 编写设计文档和实施计划
- 后编码 → 严格遵循 TDD 流程
- 必验证 → 代码审查 + 系统化调试
- 持续迭代 → 基于反馈优化
截至 2026 年 4 月，Superpowers 已在 GitHub 获得超过 123,000 Star，成为 AI 辅助编程领域最炙手可热的项目之一。
二、核心架构：三层设计哲学
2.1 架构概览
Superpowers 的架构分为三层：
┌─────────────────────────────────────────────────┐
│ 平台适配层 (Platform Adapters) │
│ Claude Code / Cursor / Codex / OpenClaw ... │
└─────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────┐
│ 技能库 (Skills Library) │
│ 14 个可组合技能：brainstorming, tdd, debug... │
└─────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────┐
│ 会话钩子 (Session Hooks) │
│ pre-task, post-task, on-failure, on-success │
└─────────────────────────────────────────────────┘
2.2 会话钩子机制
Superpowers 通过拦截 AI 编程助手的关键决策点来注入工程流程：
// hooks.json 示例（简化版）
{
"hooks": {
"PreToolUse": [{
"matcher": "Edit|Write|NotebookEdit",
"hooks": [{
"type": "command",
"command": "npx superpowers-skills @writing-plans verify-plan"
}]
}],
"PostToolUse": [{
"matcher": "Edit|Write",
"hooks": [{
"type": "command",
"command": "npx superpowers-skills @test-driven-development run-tests"
}]
}]
}
}
关键设计点：
- PreToolUse 钩子：在 AI 准备修改代码前，强制检查是否已有设计计划
- PostToolUse 钩子：代码修改后，自动触发测试验证
- 可组合性：多个技能可以串联，形成完整工作流
2.3 平台适配层详解
Superpowers 支持多种 AI 编程平台，适配方式各有不同：
| 平台 | 安装方式 | 钩子机制 | 技能调用方式 |
|---|---|---|---|
| Claude Code | 插件市场 /plugin install | hooks.json → SessionStart | 自动触发 |
| Cursor | 配置文件 | .cursorrules | 手动 @skill 调用 |
| Codex | CLI 集成 | 自定义 wrapper | npx superpowers-skills |
| OpenClaw | Skills 目录 | SKILL.md 注入 | 自动识别 |
Claude Code 集成示例：
# 安装 Superpowers 到 Claude Code
claude plugin install superpowers
# 或使用 npm 全局安装
npm install -g superpowers-skills
npx superpowers-skills install claude-code
安装后，每次启动 Claude Code 会话时，会自动加载 skills/bash-tool-please/、skills/brainstorming/ 等技能。
三、技能体系：14 个技能如何分工合作
Superpowers 的技能分为四大类，每个技能都是一个独立的 Markdown 指令文件：
3.1 规划类技能（Planning Skills）
brainstorming（头脑风暴）
# skills/brainstorming/SKILL.md
You are a senior software architect conducting a brainstorming session.
## Process:
1. **Understand Requirements**: Ask clarifying questions about:
- Functional requirements (what it should do)
- Non-functional requirements (performance, security, scalability)
- Constraints (tech stack, team skills, deadlines)
2. **Explore Alternatives**: For each requirement, propose 2-3 approaches:
- Approach A: [description] → Pros: ... Cons: ...
- Approach B: [description] → Pros: ... Cons: ...
3. **Recommend Solution**: Based on analysis, recommend the best approach with rationale.
## Output Format:
- Use Mermaid diagrams for architecture visualization
- Create comparison tables for alternatives
- Document decision log with reasons
实战示例：
开发者: "我需要一个异步任务队列系统"
AI (brainstorming skill 激活):
让我先理解需求：
1. 功能需求：
- 支持任务入队、执行、重试
- 任务状态追踪（pending/running/done/failed）
- 优先级支持
2. 技术方案对比：
| 方案 | 实现方式 | 优点 | 缺点 |
|------|---------|------|------|
| A: Redis + Bull | 使用 Bull 库 | 成熟稳定、自带重试 | 依赖 Redis |
| B: 数据库轮询 | PostgreSQL | 无额外依赖 | 性能较差 |
| C: RabbitMQ | 消息队列 | 高吞吐 | 运维复杂 |
推荐：方案 A（Bull）
理由：你的项目已使用 Redis，Bull 提供完整的任务管理 API...
writing-plans（编写实施计划）
这个技能将头脑风暴的输出转化为可执行的任务列表：
# skills/writing-plans/SKILL.md
## Plan Structure:
1. **Phase 1: Setup** (预计 1h)
- [ ] 1.1 安装依赖: `npm install bull redis`
- [ ] 1.2 创建 `src/queue/` 目录结构
2. **Phase 2: Core Implementation** (预计 3h)
- [ ] 2.1 定义 Task interface (TDD: 先写测试)
- [ ] 2.2 实现 QueueService (TDD: 先写测试)
- [ ] 2.3 实现 Worker (TDD: 先写测试)
3. **Phase 3: Integration & Testing** (预计 2h)
- [ ] 3.1 集成测试
- [ ] 3.2 性能测试
关键特性：每个任务都标注预计时间，且强制 TDD 流程。
3.2 开发类技能（Development Skills）
test-driven-development（TDD 技能）
这是 Superpowers 最核心的技能之一，强制 AI 遵循"红-绿-重构"循环：
# skills/test-driven-development/SKILL.md
## TDD Cycle (严格遵循):
1. **RED**: Write a failing test
2. **GREEN**: Write minimal code to pass the test
3. **REFACTOR**: Improve code while keeping tests green
## Rules:
- NEVER write implementation code without a failing test first
- NEVER refactor without passing tests
- Keep tests atomic and focused
- Use descriptive test names: `should_X_when_Y`
## Example Workflow:
User: "实现一个栈数据结构"
AI Action:
1. [RED] 写测试：
```javascript
describe('Stack', () => {
it('should push elements', () => {
const stack = new Stack();
stack.push(1);
expect(stack.size()).toBe(1);
});
});
[GREEN] 最小实现：
class Stack { constructor() { this.items = []; } push(item) { this.items.push(item); } size() { return this.items.length; } }[REFACTOR] 优化（保持测试通过）
**实战技巧**：TDD 技能会自动检测 AI 是否"跳步"，如果 AI 试图直接写实现代码，技能会拦截并提示：
⚠️ TDD Violation Detected!
你正试图跳过测试直接写实现。请先写一个失败的测试。
#### **writing-code（编写代码）**
这个技能不是简单的"生成代码"，而是遵循严格的编码规范：
```markdown
# skills/writing-code/SKILL.md
## Code Quality Standards:
1. **TypeScript First**: Always use TypeScript with strict mode
2. **Error Handling**: Every async function must have try-catch
3. **Logging**: Use structured logging (not console.log)
4. **Documentation**: JSDoc for public APIs
## Example:
/**
* Processes a payment transaction
* @param {PaymentRequest} request - The payment request
* @returns {Promise<PaymentResult>} The payment result
* @throws {PaymentError} If payment fails
*/
async function processPayment(request: PaymentRequest): Promise<PaymentResult> {
try {
logger.info('Processing payment', { orderId: request.orderId });
// Implementation...
} catch (error) {
logger.error('Payment failed', { error, request });
throw new PaymentError('Payment processing failed', { cause: error });
}
}
3.3 验证类技能（Verification Skills）
code-review（代码审查）
代码审查技能模拟资深工程师的审查流程：
# skills/code-review/SKILL.md
## Review Checklist:
### Security:
- [ ] SQL injection risks?
- [ ] XSS vulnerabilities?
- [ ] Authentication/Authorization checks?
### Performance:
- [ ] N+1 query problems?
- [ ] Unnecessary re-renders?
- [ ] Memory leaks?
### Maintainability:
- [ ] Single Responsibility Principle?
- [ ] Clear naming?
- [ ] Adequate test coverage?
## Output Format:
### 🔴 Critical Issues (必须修复)
### 🟡 Warnings (建议修复)
### 🟢 Suggestions (可选优化)
实战案例：
// AI 生成的代码
function getUser(id) {
const user = db.query(`SELECT * FROM users WHERE id = ${id}`);
return user;
}
// code-review 技能输出：
### 🔴 Critical Issues
1. **SQL Injection Vulnerability**
```typescript
// Bad
db.query(`SELECT * FROM users WHERE id = ${id}`)
// Good
db.query('SELECT * FROM users WHERE id = ?', [id])
🟡 Warnings
- Missing Error Handling
- Function doesn't handle database connection errors
- Consider adding try-catch block
#### **systematic-debugging（系统化调试）**
这是 Superpowers 的"杀手级"技能，它将调试从"随机试错"变成"科学方法"：
```markdown
# skills/systematic-debugging/SKILL.md
## Debugging Methodology:
1. **Reproduce**: Create a minimal reproduction case
2. **Isolate**: Identify the smallest unit causing the issue
3. **Hypothesize**: Form 2-3 hypotheses about root cause
4. **Test**: Design experiments to validate/invalidate hypotheses
5. **Fix**: Apply targeted fix
6. **Verify**: Ensure fix works and doesn't break existing functionality
## Never:
- Use console.log debugging randomly
- Make multiple changes at once
- Skip writing a regression test after fixing
实战演示：
问题: "用户登录后偶尔出现 401 错误"
AI (systematic-debugging 激活):
## Step 1: Reproduce
让我创建一个最小化复现：
```javascript
// repro.js
async function repro() {
const token = await login('user', 'pass');
// 模拟并发请求
await Promise.all([
api.get('/profile', { headers: { Authorization: `Bearer ${token}` } }),
api.get('/settings', { headers: { Authorization: `Bearer ${token}` } }),
]);
}
Step 2: Isolate
通过日志发现：token 在并发请求时被刷新，导致旧 token 失效。
Step 3: Hypothesize
H1: Token 刷新逻辑有竞态条件
H2: 服务器时钟不同步导致 token 提前过期
H3: 缓存层返回了过期 token
Step 4: Test
[编写测试验证 H1]
it('should handle concurrent token refresh', async () => {
const refreshPromise = Promise.all([
auth.refreshToken(),
auth.refreshToken(),
auth.refreshToken()
]);
const tokens = await refreshPromise;
// 检查是否生成了多个不同的 token
expect(new Set(tokens).size).toBe(1); // 应该只生成一次
});
Step 5: Fix
// 添加 token 刷新锁
class AuthService {
private refreshPromise: Promise<string> | null = null;
async getToken() {
if (this.refreshPromise) {
return this.refreshPromise; // 等待进行中的刷新
}
this.refreshPromise = this.doRefresh();
try {
return await this.refreshPromise;
} finally {
this.refreshPromise = null;
}
}
}
Step 6: Verify
添加回归测试，确保问题不再发生。
### 3.4 Meta 类技能（Meta Skills）
#### **writing-skills（编写技能）**
这个技能允许 AI 自己编写新的 Superpowers 技能：
```markdown
# skills/writing-skills/SKILL.md
## Skill Structure:
skills/
my-new-skill/
SKILL.md # 技能指令（Markdown）
examples/ # 示例代码
example1.test.ts
example1.ts
README.md # 人类可读的说明
## SKILL.md Template:
```markdown
---
name: my-new-skill
description: What this skill does
---
# My New Skill
## When to use:
- Situation A
- Situation B
## Instructions:
1. Step 1...
2. Step 2...
## Examples:
\```typescript
// Example code
\```
Anti-patterns to avoid:
- Don't create skills that are too broad
- Don't duplicate existing skills
- Do include concrete examples
#### **using-superpowers（使用指南）**
这个技能帮助用户（和 AI）理解如何组合使用其他技能：
```markdown
# skills/using-superpowers/SKILL.md
## Common Workflows:
### Workflow 1: New Feature Development
1. brainstorming (明确需求)
2. writing-plans (制定计划)
3. test-driven-development (TDD 循环)
4. code-review (代码审查)
5. systematic-debugging (如有 bug)
### Workflow 2: Bug Fix
1. systematic-debugging (定位问题)
2. test-driven-development (写回归测试 + 修复)
3. code-review (审查修复)
### Workflow 3: Refactoring
1. writing-plans (制定重构计划)
2. test-driven-development (确保不破坏功能)
3. code-review (审查改进)
四、完整工作流实战：从 0 到 1 开发一个功能
让我们通过一个完整的示例，展示 Superpowers 如何让 AI 完成一个真实的功能开发。
4.1 需求：实现一个 JWT 认证中间件
开发者输入：
"帮我实现一个 Express.js 的 JWT 认证中间件，支持：
1. 验证 Bearer token
2. 过期检查
3. 将用户信息注入 request 对象
4. 错误处理"
4.2 阶段 1：头脑风暴（brainstorming）
AI 自动激活 brainstorming 技能：
## 需求分析
### 功能需求确认
1. ✅ 验证 Bearer token（从 Authorization header 提取）
2. ✅ 过期检查（JWT exp 声明）
3. ✅ 用户信息注入（req.user = decoded payload）
4. ✅ 错误处理（401 Unauthorized）
### 技术选型
| 方案 | 库选择 | 优点 | 缺点 |
|------|-------|------|------|
| A: jsonwebtoken | 老牌稳定 | 文档全、社区大 | API 较老 |
| B: jose | 现代实现 | 支持 JWK、JWS | 学习曲线陡 |
| C: 自己实现 | 无依赖 | 完全可控 | 容易出安全漏洞 |
**推荐：方案 B (jose)**
理由：jose 是 JOSE 工作组的官方实现，支持最新的 JWT 标准，且 TypeScript 友好。
### 架构设计
\```mermaid
sequenceDiagram
Client->>Middleware: Authorization: Bearer xxx
Middleware->>Middleware: 提取 token
Middleware->>jose: jwtVerify(token, secret)
jose-->>Middleware: decoded payload / error
alt 验证成功
Middleware->>req: req.user = payload
Middleware->>Next: next()
else 验证失败
Middleware->>Client: 401 Unauthorized
end
\```
4.3 阶段 2：编写计划（writing-plans）
AI 自动激活 writing-plans 技能：
## 实施计划
### Phase 1: 环境准备 (30 min)
- [ ] 安装依赖: `npm install jose @types/express`
- [ ] 创建 `src/middleware/` 目录
- [ ] 创建 `src/__tests__/middleware/` 测试目录
### Phase 2: TDD 实现 (2 hours)
#### Task 2.1: Token 提取逻辑 (30 min)
- [ ] 写测试: `should extract token from Authorization header`
- [ ] 写测试: `should return 401 when no Authorization header`
- [ ] 写测试: `should return 401 when not Bearer scheme`
- [ ] 实现 `extractToken()` 函数
#### Task 2.2: JWT 验证 (45 min)
- [ ] 写测试: `should verify valid token`
- [ ] 写测试: `should return 401 for expired token`
- [ ] 写测试: `should return 401 for invalid signature`
- [ ] 实现 `verifyToken()` 函数
#### Task 2.3: 中间件组装 (45 min)
- [ ] 写测试: `should inject user into req`
- [ ] 写测试: `should call next() on success`
- [ ] 实现 `jwtMiddleware()` 函数
### Phase 3: 集成与测试 (30 min)
- [ ] 集成到 Express app
- [ ] 手动测试 happy path
- [ ] 手动测试 error cases
4.4 阶段 3：TDD 开发（test-driven-development）
AI 开始严格遵循 TDD 循环：
Task 2.1: Token 提取
RED 阶段：先写失败的测试
// src/__tests__/middleware/jwt.test.ts
import { extractToken } from '../../middleware/jwt';
describe('extractToken', () => {
it('should extract token from Authorization header', () => {
const header = 'Bearer eyJhbGciOiJIUzI1NiJ9...';
expect(extractToken(header)).toBe('eyJhbGciOiJIUzI1NiJ9...');
});
it('should return null when no Authorization header', () => {
expect(extractToken(undefined)).toBeNull();
});
it('should return null when not Bearer scheme', () => {
expect(extractToken('Basic dXNlcjpwYXNz')).toBeNull();
});
});
运行测试 → 失败（函数不存在）
GREEN 阶段：最小实现
// src/middleware/jwt.ts
export function extractToken(authHeader: string | undefined): string | null {
if (!authHeader) return null;
const parts = authHeader.split(' ');
if (parts.length !== 2 || parts[0] !== 'Bearer') return null;
return parts[1];
}
运行测试 → 通过 ✅
REFACTOR 阶段：代码已简洁，无需重构。
Task 2.2: JWT 验证
RED 阶段：
// 继续在 jwt.test.ts 中添加
import { jwtVerify, createLocalJWKSet } from 'jose';
import { verifyToken } from '../../middleware/jwt';
describe('verifyToken', () => {
const secret = new TextEncoder().encode('my-secret-key');
it('should verify valid token', async () => {
const token = await new SignJWT({ userId: 123 })
.setProtectedHeader({ alg: 'HS256' })
.sign(secret);
const payload = await verifyToken(token, secret);
expect(payload.userId).toBe(123);
});
it('should throw for expired token', async () => {
const token = await new SignJWT({ exp: Math.floor(Date.now() / 1000) - 3600 })
.setProtectedHeader({ alg: 'HS256' })
.sign(secret);
await expect(verifyToken(token, secret)).rejects.toThrow('Token expired');
});
});
GREEN 阶段：
export async function verifyToken(token: string, secret: Uint8Array): Promise<any> {
try {
const { payload } = await jwtVerify(token, secret);
return payload;
} catch (error) {
if (error.code === 'ERR_JWT_EXPIRED') {
throw new Error('Token expired');
}
throw new Error('Invalid token');
}
}
Task 2.3: 中间件组装
RED 阶段：
import { jwtMiddleware } from '../../middleware/jwt';
describe('jwtMiddleware', () => {
it('should inject user into req and call next', async () => {
const req = { headers: { authorization: 'Bearer valid-token' } };
const res = { status: jest.fn().mockReturnThis(), json: jest.fn() };
const next = jest.fn();
// Mock verifyToken
jest.spyOn(global, 'verifyToken').mockResolvedValue({ userId: 123 });
await jwtMiddleware(req, res, next);
expect(req.user).toEqual({ userId: 123 });
expect(next).toHaveBeenCalled();
});
});
GREEN 阶段：
import { Request, Response, NextFunction } from 'express';
export interface AuthRequest extends Request {
user?: any;
}
export async function jwtMiddleware(
req: AuthRequest,
res: Response,
next: NextFunction
) {
const token = extractToken(req.headers.authorization);
if (!token) {
return res.status(401).json({ error: 'Unauthorized' });
}
try {
const payload = await verifyToken(token, getSecret());
req.user = payload;
next();
} catch (error) {
return res.status(401).json({ error: error.message });
}
}
4.5 阶段 4：代码审查（code-review）
AI 自动激活 code-review 技能：
## Code Review Report
### 🟢 Suggestions
1. **Type Safety Improvement**
建议为 `req.user` 定义明确的 TypeScript 接口：
```typescript
export interface AuthRequest extends Request {
user?: JWTPayload; // 而非 any
}
- Configuration Management
当前 secret 通过getSecret()获取，建议支持环境变量：const secret = process.env.JWT_SECRET ? new TextEncoder().encode(process.env.JWT_SECRET) : getDefaultSecret();
✅ 通过项
- ✅ 错误处理完善
- ✅ 测试覆盖率 100%
- ✅ 符合 Express 中间件规范
### 4.6 最终结果
经过完整的 Superpowers 工作流，我们得到了：
1. **完整的测试覆盖**（RED-GREEN-REFACTOR 循环保证）
2. **符合最佳实践的代码**（code-review 技能把关）
3. **清晰的可维护性**（writing-code 技能规范）
```typescript
// 最终代码（整合后）
import { jwtVerify } from 'jose';
import { Request, Response, NextFunction } from 'express';
export interface AuthRequest extends Request {
user?: Record<string, any>;
}
export function extractToken(authHeader?: string): string | null {
if (!authHeader) return null;
const parts = authHeader.split(' ');
if (parts.length !== 2 || parts[0] !== 'Bearer') return null;
return parts[1];
}
export async function verifyToken(token: string, secret: Uint8Array) {
try {
const { payload } = await jwtVerify(token, secret);
return payload;
} catch (error: any) {
if (error.code === 'ERR_JWT_EXPIRED') {
throw new Error('Token expired');
}
throw new Error('Invalid token');
}
}
export function jwtMiddleware(secret: Uint8Array) {
return async (req: AuthRequest, res: Response, next: NextFunction) => {
const token = extractToken(req.headers.authorization);
if (!token) {
return res.status(401).json({ error: 'Unauthorized' });
}
try {
const payload = await verifyToken(token, secret);
req.user = payload;
next();
} catch (error: any) {
return res.status(401).json({ error: error.message });
}
};
}
五、进阶话题：Superpowers 的局限性与最佳实践
5.1 当前局限性
学习曲线陡峭
- 新手可能不理解为什么 AI "拒绝"直接写代码
- 需要适应"先思考后行动"的工程文化
过度工程化风险
- 对于简单任务（如修改一个配置），完整工作流可能显得繁琐
- 建议：通过
.superpowers/config.json配置技能开关
平台依赖
- 不同平台的钩子机制不同，可能存在兼容性问题
- 解决方案：优先使用 Claude Code 或 OpenClaw，支持最完善
5.2 最佳实践
渐进式采用
// .superpowers/config.json
{
"enabled_skills": [
"test-driven-development", // 先启用 TDD
"code-review" // 再加代码审查
],
"disabled_skills": [
"brainstorming" // 简单任务可以跳过头脑风暴
]
}
自定义技能
如果你发现某些重复的模式，可以编写自己的技能：
# skills/api-integration/SKILL.md
---
name: api-integration
description: 集成第三方 API 的标准流程
---
## Steps:
1. 阅读 API 文档，提取关键端点
2. 使用 `api-test` 工具测试端点
3. 生成 TypeScript 类型定义
4. 实现带重试的 API 客户端
5. 写集成测试（使用 nock mock）
团队协作
Superpowers 的技能文件可以提交到版本控制，团队共享：
git add skills/
git commit -m "feat: add custom skills for payment integration"
git push
新成员克隆仓库后，只需运行：
npx superpowers-skills install --from-project
六、总结与展望
6.1 核心价值回顾
Superpowers 的真正价值不在于"让 AI 写更多代码"，而在于：
- 注入工程纪律：TDD、代码审查、系统化调试不再是"可选的"，而是"强制的"
- 可预测的质量：每个功能都经过完整的测试→审查→验证流程
- 知识沉淀：技能文件本身就是团队最佳实践的文档
6.2 与同类工具对比
| 工具 | 核心定位 | 优势 | 劣势 |
|---|---|---|---|
| Superpowers | 工程流程框架 | 完整工作流、强制纪律 | 学习曲线陡 |
| Cursor | IDE 集成 | 实时补全、快速迭代 | 缺乏流程约束 |
| GitHub Copilot | 代码生成 | 上下文理解强 | 无工程规范 |
| Aider | CLI 工具 | 轻量级、快速 | 功能有限 |
6.3 未来展望
随着 AI 编程助手的普及，我预测：
- 技能市场：类似 npm，将出现 Superpowers Skills Registry，开发者可以分享和下载技能
- IDE 原生支持：VSCode、JetBrains 可能原生集成类似机制
- 企业定制：大厂会开发内部技能库，标准化团队的 AI 辅助开发流程
6.4 最后的思考
Superpowers 本质上是在回答一个问题：
"如果 AI 是你的 junior 开发者，你会如何训练它？"
答案是：用你希望 junior 开发者遵循的所有工程实践，去约束 AI 的行为。不是让 AI 变得更"聪明"，而是让 AI 变得更"专业"。
在 2026 年，代码生成已经不是难题，代码的质量、可维护性和工程规范性才是。Superpowers 正是为此而生。
附录：快速上手指南
A1. 安装（Claude Code）
# 方法 1: 通过插件市场
claude /plugin install superpowers
# 方法 2: 手动安装
git clone https://github.com/obra/superpowers.git ~/.claude/skills/superpowers
cd ~/.claude/skills/superpowers
npm install
npx superpowers-skills install claude-code
A2. 验证安装
启动 Claude Code，输入：
> @superpowers verify
应该看到：
✅ Superpowers installed correctly
✅ 14 skills loaded
✅ Hooks configured
A3. 第一个任务
> 帮我实现一个 LRU Cache 类，支持 get(key) 和 put(key, value)，要求 O(1) 时间复杂度
观察 AI 是否自动激活 brainstorming → writing-plans → test-driven-development 流程。
文章字数统计：约 8,500 字
参考文献：
- Superpowers GitHub: https://github.com/obra/superpowers
- Anthropic Agent Skills Documentation
- Test-Driven Development by Example (Kent Beck)
- Jose Library Documentation: https://github.com/panva/jose
本文由 AI 助手结合 Superpowers 官方文档和实践经验撰写，遵循 Superpowers 的"流程大于提示词"哲学。