Superpowers 深度解析：把 AI 从"会写代码"改造成"守纪律的工程师"——从 TDD 强制循环到子智能体并发架构的完整技术内幕

191k Star 的 Agent 技能框架如何重塑 AI 编程工作流

引言：AI 编程的"最后一公里"问题

2025 年到 2026 年，AI 编程工具经历了爆发式增长。从 GitHub Copilot 到 Claude Code，从 Cursor 到 OpenClaw，AI 已经能够熟练地"写代码"。但一个尴尬的现实是：AI 写的代码往往缺乏工程纪律。

你让 AI "实现一个用户认证模块"，它可能会：

• 直接开始写代码，而不先理清需求
• 写出功能但跳过测试
• 测试失败后盲目修改，缺乏系统性排查
• 自认为"完成"但实际上未验证边界条件
• 重构时没有计划，遗漏关键场景

这就是 Superpowers 要解决的问题。

GitHub 项目地址：https://github.com/obra/superpowers
作者：Jesse Vincent (Prime Radiant)
License：MIT
Star 数：191k+ (2026年5月)
支持平台：Claude Code、Codex CLI、Cursor、Gemini CLI、OpenCode、Factory Droid、GitHub Copilot CLI、Codex App

一、Superpowers 是什么？

1.1 官方定义

Superpowers 的官方定义非常精准：

"An agentic skills framework & software development methodology that works."

翻译过来就是：一个能真正工作的 Agent 技能框架和软件开发方法论。

但这句话说人话就是一件事：它把"软件工程师素养"植入到 AI agent 里。

1.2 核心理念：Skill-First 工作流

Superpowers 的黄金法则：

"在执行任何操作前，先检查是否有相关的 skill 可用。"

这不是一个简单的插件系统，而是一套完整的工程纪律植入机制。它强制 AI agent 遵循专业软件工程师的工作流程，而不是"随意发挥"。

1.3 从 v2.0 到 v5.1：7 个月的快速迭代

Superpowers 的迭代速度令人惊叹：

7 个月内，从一个"个人插件"打磨成了 8 个 AI 编码代理平台共同遵循的工作流层。

二、完整开发工作流：7 个自动触发阶段

Superpowers 将整个开发过程分为 7 个自动触发阶段，形成闭环的智能体开发流水线：

1. 需求探索 (brainstorming)
   ↓
2. 测试驱动设计 (tdd-design)
   ↓
3. 红绿重构循环 (test-driven-development)
   ↓
4. 子智能体任务拆分 (subagent-driven-development)
   ↓
5. 系统化调试 (systematic-debugging)
   ↓
6. 完成前验证 (verification-before-completion)
   ↓
7. 文档生成 (documentation-generation)

2.1 阶段 1：需求探索 (Brainstorming)

问题：传统 AI 编程工具直接开始写代码，需求理解不充分。

Superpowers 的解决方案：

# brainstorming skill 强制流程

用户请求 → AI 必须先进行需求探索对话：
  - 核心功能是什么？
  - 边界条件有哪些？
  - 错误处理策略？
  - 性能指标要求？
  
只有完成需求探索，才允许进入下一阶段。

代码示例：用户请求"实现用户登录功能"，AI 会先问：

brainstorming:
  questions:
    - "登录方式：邮箱+密码？手机号？OAuth？"
    - "密码存储：bcrypt？scrypt？argon2？"
    - "会话管理：JWT？Redis session？"
    - "错误处理：失败锁定？验证码？"
    - "性能要求：QPS？延迟要求？"

2.2 阶段 2：测试驱动设计 (TDD Design)

问题：AI 写代码常常跳过测试，或者写完代码再补测试。

Superpowers 的解决方案：

// tdd-design skill 强制流程

// 第一步：先写测试描述（不是测试代码）
describe("UserAuthentication", () => {
  // AI 必须先和人类确认测试场景
  it("should reject invalid password", async () => {
    // 红色阶段：测试必须先失败
  });
  
  it("should lock account after 5 failures", async () => {
    // AI 不能跳过边界测试
  });
});

// 第二步：人类确认测试场景后，才允许写实现代码

关键创新：Superpowers 强制 "测试描述必须先于实现代码"，而不是"写完代码再补测试"。

2.3 阶段 3：红绿重构循环 (Test-Driven Development)

这是 Superpowers 的核心工程纪律。

红绿重构循环的标准流程

# test-driven-development skill 强制循环

while not all_tests_pass():
    # 红色阶段：写一个失败的测试
    write_failing_test()
    
    # 绿色阶段：写最少的代码让测试通过
    write_minimal_implementation()
    
    # 重构阶段：优化代码，保持测试通过
    refactor_without_breaking_tests()

实际代码示例

// 红色阶段：先写测试（测试必须失败）
import { describe, it, expect } from "vitest";
import { authenticateUser } from "./auth";

describe("authenticateUser", () => {
  it("should return null for invalid password", async () => {
    const result = await authenticateUser("user@example.com", "wrong-password");
    expect(result).toBeNull();
  });
});

// 运行测试 → 失败（红色）

// 绿色阶段：写最少的代码让测试通过
export async function authenticateUser(email: string, password: string) {
  const user = await db.findUserByEmail(email);
  if (!user) return null;
  
  const isValid = await bcrypt.compare(password, user.passwordHash);
  if (!isValid) return null;
  
  return user;
}

// 运行测试 → 通过（绿色）

// 重构阶段：优化代码（保持测试通过）
export async function authenticateUser(email: string, password: string) {
  const user = await db.findUserByEmail(email);
  if (!user || !await bcrypt.compare(password, user.passwordHash)) {
    return null;
  }
  
  // 记录登录日志（重构添加的功能）
  await logLoginAttempt(email, true);
  return user;
}

Superpowers 的强制规则：

1. 不能跳过红色阶段：必须先有失败测试
2. 不能跳过绿色阶段：必须让测试通过，但不能过度实现
3. 不能跳过重构阶段：代码必须优化，但不能破坏测试

2.4 阶段 4：子智能体任务拆分 (Subagent-Driven Development)

这是 Superpowers 最核心的执行模式，通过并发子智能体大幅缩短开发时间。

架构设计

主智能体 (Main Agent)
  ├─ 分析任务，拆分子任务
  ├─ 创建子智能体 1 → 实现 Model 层
  ├─ 创建子智能体 2 → 实现 Service 层
  ├─ 创建子智能体 3 → 实现 API 层
  └─ 汇总结果，运行集成测试

实际代码示例

// subagent-driven-development skill

// 主智能体任务拆分
async function implementUserModule() {
  // 1. 分析任务复杂度
  const task = {
    name: "User Authentication Module",
    subtasks: [
      "Database schema design",
      "Password hashing utility",
      "JWT token generation",
      "API route implementation",
      "Integration tests"
    ]
  };
  
  // 2. 创建子智能体并发执行
  const results = await Promise.all([
    spawnSubagent("implement-database-schema", task.subtasks[0]),
    spawnSubagent("implement-password-hashing", task.subtasks[1]),
    spawnSubagent("implement-jwt-generation", task.subtasks[2])
  ]);
  
  // 3. 汇总结果
  return mergeSubagentResults(results);
}

// 子智能体 1：实现数据库 schema
async function implementDatabaseSchema() {
  // 这个子智能体只关心数据库 schema
  return `
    CREATE TABLE users (
      id UUID PRIMARY KEY,
      email VARCHAR(255) UNIQUE NOT NULL,
      password_hash VARCHAR(255) NOT NULL,
      created_at TIMESTAMP DEFAULT NOW()
    );
  `;
}

性能提升：通过这种方式，原本需要 30 分钟的顺序执行，可以缩短到 10 分钟的并发执行。

2.5 阶段 5：系统化调试 (Systematic Debugging)

问题：传统 AI 调试是"盲目尝试"，缺乏系统性。

Superpowers 的解决方案：

# systematic-debugging skill 强制流程

1. 复现问题（获取错误日志）
2. 定位问题范围（哪个模块？哪行代码？）
3. 提出假设（可能的原因）
4. 设计验证实验（最小化复现用例）
5. 修复问题
6. 添加回归测试（防止问题再次出现）

代码示例：

// 问题：用户登录偶尔失败

// 第一步：复现问题
// 错误日志：JSON.parse error in line 42

// 第二步：定位问题范围
// 问题在 JWT token 解析逻辑

// 第三步：提出假设
// 假设：JWT token 包含特殊字符导致 JSON.parse 失败

// 第四步：设计验证实验
const testToken = "eyJhbGciOiJIUzI1NiJ9.eyJlbWFpbCI6InRlc3QlNDBleGFtcGxlLmNvbSJ9.signature";
// email 包含 @ 符号，在 JSON 解析时可能出问题

// 第五步：修复问题
// 使用 base64url 解码，而不是 JSON.parse
const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64url').toString());

// 第六步：添加回归测试
it("should handle email with special characters", async () => {
  const token = await generateTestToken("test@example.com");
  const result = parseJWT(token);
  expect(result.email).toBe("test@example.com");
});

2.6 阶段 6：完成前验证 (Verification Before Completion)

问题：AI 常常自认为"完成"，但实际上未验证边界条件。

Superpowers 的解决方案：

// verification-before-completion skill 强制检查清单

async function verifyCompletion(task: Task): Promise<VerificationResult> {
  const checks = [
    "所有测试通过？",
    "边界条件覆盖？",
    "错误处理完整？",
    "性能符合要求？",
    "代码已重构优化？",
    "文档已更新？"
  ];
  
  for (const check of checks) {
    if (!await runCheck(check, task)) {
      return { verified: false, failedCheck: check };
    }
  }
  
  return { verified: true };
}

// 只有所有检查通过，AI 才能宣布"任务完成"

2.7 阶段 7：文档生成 (Documentation Generation)

Superpowers 自动生成三种文档：

1. API 文档：从代码注释生成 OpenAPI 规范
2. 架构文档：从代码结构生成 Mermaid 图表
3. 使用示例：从测试用例生成使用示例代码

// documentation-generation skill

// 从代码注释生成 OpenAPI 规范
/**
 * @openapi
 * /auth/login:
 *   post:
 *     summary: User login
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *           schema:
 *             type: object
 *             properties:
 *               email:
 *                 type: string
 *               password:
 *                 type: string
 */
export async function loginHandler(req: Request, res: Response) {
  // ...
}

三、技能库全景：15+ 个技能模块

Superpowers 的技能库按职能分为 5 大类，共 15+ 个技能模块，全部自动触发。

3.1 需求分析类

3.2 设计类

3.3 开发类

3.4 调试类

3.5 验证类

四、支持的平台与安装方式

Superpowers 支持 8 大主流 AI 编程智能体平台，通过各自的插件系统一键安装。

4.1 支持的平台

4.2 安装流程（以 Claude Code 为例）

# 第一步：安装插件
/plugin install superpowers@claude-plugins-official

# 第二步：重新加载插件
/reload-plugins

# 第三步：验证安装
/plugin list
# 应该看到 superpowers 及相关技能

4.3 配置文件结构

安装后，Superpowers 会在你的项目中创建以下结构：

your-project/
├── .superpowers/
│   ├── config.json           # 全局配置
│   ├── skills/               # 技能库
│   │   ├── brainstorming/
│   │   ├── test-driven-development/
│   │   ├── subagent-driven-development/
│   │   └── ...
│   └── workflows/            # 工作流定义
│       ├── default.json
│       └── strict-tdd.json
├── CLAUDE.md                 # Claude Code 配置（自动生成）
└── .superpowers.md           # 项目特定的 superpowers 配置

五、技术架构深度剖析

5.1 插件系统架构

Superpowers 的核心是一个 可扩展的插件系统，它不修改 AI 编程工具的源代码，而是通过 hook 机制 注入工程纪律。

// 插件系统核心架构

interface SuperpowersPlugin {
  name: string;
  version: string;
  hooks: {
    beforeCodeGeneration: (context: Context) => Promise<void>;
    afterCodeGeneration: (context: Context) => Promise<void>;
    beforeTestExecution: (context: Context) => Promise<void>;
    afterTestExecution: (context: Context) => Promise<void>;
  };
  skills: Skill[];
}

// 示例：TDD 强制 hook
const TDDPlugin: SuperpowersPlugin = {
  name: "test-driven-development",
  version: "5.1.0",
  hooks: {
    beforeCodeGeneration: async (context) => {
      // 强制先写测试
      if (!context.hasFailingTest) {
        throw new Error("Red phase required: write a failing test first!");
      }
    },
    afterCodeGeneration: async (context) => {
      // 强制运行测试
      const result = await runTests();
      if (!result.allPass) {
        throw new Error("Green phase required: make tests pass!");
      }
    }
  }
};

5.2 子智能体通信协议

Superpowers 的子智能体系统基于 消息传递协议，而不是共享内存。

// 子智能体通信协议

interface SubagentMessage {
  type: "task" | "result" | "error";
  taskId: string;
  payload: any;
  dependencies?: string[];  // 依赖的其他子智能体任务
}

// 主智能体
class MainAgent {
  async spawnSubagent(task: Task): Promise<SubagentResult> {
    const subagent = new Subagent();
    
    // 发送任务
    await subagent.send({
      type: "task",
      taskId: task.id,
      payload: task.instructions
    });
    
    // 接收结果
    const result = await subagent.receive();
    return result;
  }
}

// 子智能体
class Subagent {
  async run() {
    while (true) {
      const message = await this.receive();
      
      if (message.type === "task") {
        const result = await this.executeTask(message.payload);
        await this.send({
          type: "result",
          taskId: message.taskId,
          payload: result
        });
      }
    }
  }
}

5.3 状态管理系统

Superpowers 使用 事件溯源（Event Sourcing） 模式管理开发状态。

// 事件溯源状态管理

interface Event {
  type: string;
  timestamp: number;
  payload: any;
}

class SuperpowersState {
  private events: Event[] = [];
  
  // 应用事件
  applyEvent(event: Event) {
    this.events.push(event);
    this.updateState(event);
  }
  
  // 重建状态（从事件历史）
  rebuildState() {
    this.state = initialState();
    for (const event of this.events) {
      this.updateState(event);
    }
  }
  
  // 回滚到某个时间点
  rollbackTo(timestamp: number) {
    this.events = this.events.filter(e => e.timestamp <= timestamp);
    this.rebuildState();
  }
}

// 示例事件
const events = [
  { type: "TEST_WRITTEN", timestamp: 1715000000, payload: { test: "should reject invalid password" } },
  { type: "TEST_FAILED", timestamp: 1715000010, payload: { error: "Function not defined" } },
  { type: "IMPLEMENTATION_WRITTEN", timestamp: 1715000020, payload: { function: "authenticateUser" } },
  { type: "TEST_PASSED", timestamp: 1715000030, payload: { test: "should reject invalid password" } }
];

六、与其他 AI 编程工具的对比

6.1 Superpowers vs. 纯 AI 编程工具

6.2 Superpowers vs. Claude Code 原生功能

Claude Code 本身已经很强大，但 Superpowers 在以下方面提供了增强：

1. 强制工程纪律：Claude Code 可以遵循指令，但不强制；Superpowers 强制
2. 跨平台一致性：Superpowers 在 8 个平台上提供一致的工作流
3. 技能可复用：Superpowers 的技能可以跨项目复用

七、实战案例：用 Superpowers 实现一个完整的 REST API

让我们通过一个完整的实战案例，展示 Superpowers 的完整工作流。

7.1 需求：实现一个简单的博客 API

用户请求：

用 TypeScript 和 Express 实现一个简单的博客 API，支持：
- 创建文章
- 获取文章列表
- 获取单篇文章
- 更新文章
- 删除文章

7.2 Superpowers 执行流程

第一步：Brainstorming（需求探索）

# AI 自动触发 brainstorming skill

AI: "在实现之前，我需要确认几个问题："

1. 数据存储：使用 SQLite？PostgreSQL？MongoDB？
2. 认证：需要用户登录吗？需要 JWT 认证吗？
3. 验证：文章标题和内容有什么限制？
4. 分页：文章列表需要分页吗？每页多少条？
5. 错误处理：如何返回错误信息？

用户: "用 SQLite，不需要认证，标题最少 5 个字符，需要分页（每页 10 条），错误返回 JSON 格式。"

AI: "好的，需求已确认，开始设计测试。"

第二步：TDD Design（测试驱动设计）

// AI 自动生成测试描述（不写实现）

import { describe, it, expect, beforeEach, afterEach } from "vitest";
import { createApp } from "./app";
import { setupTestDB, teardownTestDB } from "./test-db";

describe("Blog API", () => {
  beforeEach(async () => {
    await setupTestDB();
  });
  
  afterEach(async () => {
    await teardownTestDB();
  });
  
  describe("POST /api/posts", () => {
    it("should create a new post with valid data", async () => {
      const response = await request(app)
        .post("/api/posts")
        .send({ title: "Test Post", content: "This is test content" });
      
      expect(response.status).toBe(201);
      expect(response.body).toHaveProperty("id");
      expect(response.body.title).toBe("Test Post");
    });
    
    it("should reject post with title shorter than 5 characters", async () => {
      const response = await request(app)
        .post("/api/posts")
        .send({ title: "Test", content: "Content" });
      
      expect(response.status).toBe(400);
      expect(response.body).toHaveProperty("error");
    });
  });
  
  // 更多测试...
});

第三步：Red-Green-Refactor（红绿重构循环）

// 红色阶段：运行测试 → 失败

// 绿色阶段：写最少代码让测试通过
import express, { Express, Request, Response } from "express";
import { Database } from "sqlite3";

export function createApp(db: Database): Express {
  const app = express();
  app.use(express.json());
  
  app.post("/api/posts", (req: Request, res: Response) => {
    const { title, content } = req.body;
    
    // 验证
    if (!title || title.length < 5) {
      return res.status(400).json({ error: "Title must be at least 5 characters" });
    }
    
    // 插入数据库
    db.run(
      "INSERT INTO posts (title, content) VALUES (?, ?)",
      [title, content],
      function(err) {
        if (err) {
          return res.status(500).json({ error: "Database error" });
        }
        res.status(201).json({ id: this.lastID, title, content });
      }
    );
  });
  
  return app;
}

// 运行测试 → 通过（绿色）

// 重构阶段：优化代码（保持测试通过）
export function createApp(db: Database): Express {
  const app = express();
  app.use(express.json());
  
  app.post("/api/posts", validatePostInput, async (req: Request, res: Response) => {
    try {
      const { title, content } = req.body;
      const id = await db.insert("posts", { title, content });
      res.status(201).json({ id, title, content });
    } catch (error) {
      res.status(500).json({ error: "Failed to create post" });
    }
  });
  
  return app;
}

// 抽取验证逻辑到中间件
function validatePostInput(req: Request, res: Response, next: NextFunction) {
  const { title, content } = req.body;
  
  if (!title || title.length < 5) {
    return res.status(400).json({ error: "Title must be at least 5 characters" });
  }
  
  if (!content) {
    return res.status(400).json({ error: "Content is required" });
  }
  
  next();
}

第四步：Subagent-Driven Development（子智能体并发开发）

// 主智能体拆分任务
async function implementBlogAPI() {
  const subtasks = [
    { name: "implement-database-schema", deps: [] },
    { name: "implement-create-post-endpoint", deps: ["implement-database-schema"] },
    { name: "implement-get-posts-endpoint", deps: ["implement-database-schema"] },
    { name: "implement-get-single-post-endpoint", deps: ["implement-database-schema"] },
    { name: "implement-update-post-endpoint", deps: ["implement-database-schema"] },
    { name: "implement-delete-post-endpoint", deps: ["implement-database-schema"] },
    { name: "write-integration-tests", deps: ["implement-create-post-endpoint", "implement-get-posts-endpoint", "implement-get-single-post-endpoint", "implement-update-post-endpoint", "implement-delete-post-endpoint"] }
  ];
  
  // 按依赖关系并发执行
  const results = await executeWithDeps(subtasks);
  return mergeResults(results);
}

第五步：Verification Before Completion（完成前验证）

// AI 自动运行验证清单

const verificationChecklist = [
  "✅ 所有测试通过（15/15）",
  "✅ 边界条件覆盖（标题最短长度、空内容、不存在的文章 ID）",
  "✅ 错误处理完整（数据库错误、验证错误、404）",
  "✅ 性能符合要求（GET /api/posts 响应时间 < 50ms）",
  "✅ 代码已重构优化（中间件抽取、错误处理统一）",
  "✅ 文档已更新（README.md、API.md）"
];

if (verificationChecklist.every(item => item.startsWith("✅"))) {
  console.log("任务完成！");
} else {
  console.log("验证失败，继续修复...");
}

八、性能优化：Superpowers 如何加速开发？

8.1 并发执行性能对比

8.2 Token 消耗优化

Superpowers 通过 智能上下文管理 减少 token 消耗：

// 上下文窗口管理策略

class ContextManager {
  private maxTokens = 100000;  // Claude 3.5 的上下文窗口
  
  // 只保留相关代码
  trimContext(currentTask: Task, fullContext: Context): Context {
    return {
      // 保留当前任务相关的代码
      relevantCode: this.extractRelevantCode(currentTask, fullContext),
      
      // 保留最近的对话历史（最近 10 条）
      recentHistory: fullContext.history.slice(-10),
      
      // 保留项目配置文件
      configFiles: fullContext.configFiles
    };
  }
  
  // 抽取相关代码（使用 AST 分析）
  extractRelevantCode(task: Task, context: Context): Code[] {
    const ast = parseAST(context.code);
    const dependencies = analyzeDependencies(task, ast);
    return dependencies.map(dep => context.code[dep]);
  }
}

效果：Token 消耗减少 40-60%，同时保持良好的代码质量。

九、最佳实践与常见陷阱

9.1 最佳实践

1. 从小任务开始

// ✅ 好的做法：小任务，快速反馈
"实现一个函数：验证邮箱格式"

// ❌ 坏的做法：大任务，反馈慢
"实现一个完整的用户管理系统"

2. 频繁运行测试

# ✅ 好的做法：每写一点代码就运行测试
npm test -- --watch

# ❌ 坏的做法：写完所有代码再运行测试
npm test

3. 使用类型检查

// ✅ 好的做法：使用 TypeScript 强制类型安全
interface User {
  id: number;
  email: string;
  passwordHash: string;
}

// ❌ 坏的做法：使用 any
const user: any = { ... };

9.2 常见陷阱

陷阱 1：跳过红色阶段

// ❌ 错误：直接写实现代码（跳过红色阶段）
export function authenticateUser(email: string, password: string) {
  // ...
}

// ✅ 正确：先写失败测试
it("should reject invalid password", async () => {
  const result = await authenticateUser("user@example.com", "wrong");
  expect(result).toBeNull();
});

// 然后写实现代码

陷阱 2：过度实现

// ❌ 错误：在绿色阶段过度实现
export function authenticateUser(email: string, password: string) {
  // 写了很多代码，但测试只需要基本功能
  const user = await db.findUserByEmail(email);
  const isValid = await bcrypt.compare(password, user.passwordHash);
  const token = jwt.sign({ userId: user.id }, SECRET);
  await cache.set(token, user);
  return { user, token };
}

// ✅ 正确：写最少的代码让测试通过
export function authenticateUser(email: string, password: string) {
  // 只实现测试需要的功能
  return null;  // 暂时返回 null，让测试通过
}

十、未来展望：Superpowers 的路线图

10.1 v6.0 计划（2026 Q3）

• 多语言支持：除了 TypeScript/JavaScript，支持 Python、Rust、Go
• 可视化工作流编辑器：通过 UI 设计工作流，而不是手写配置
• 云端同步：在多个设备之间同步 Superpowers 配置

10.2 v7.0 计划（2026 Q4）

• AI 代码审查：自动审查代码质量、安全性、性能
• 智能重构建议：基于最佳实践的重构建议
• 团队协作：多个开发者共享 Superpowers 配置

十一、总结

Superpowers 不是一个简单的 AI 编程插件，而是 一套完整的工程纪律植入机制。它把"软件工程师素养"——测试驱动开发、系统化调试、完成前验证——植入到 AI agent 里，让 AI 从"会写代码"变成"守纪律的工程师"。

核心要点回顾

1. 7 个自动触发阶段：从需求探索到文档生成，形成闭环流水线
2. TDD 强制循环：红色 → 绿色 → 重构，不能跳过任何一个阶段
3. 子智能体并发：通过任务拆分和并发执行，加速开发 2-3 倍
4. 15+ 技能模块：覆盖需求、设计、开发、调试、验证全流程
5. 8 平台支持：Claude Code、Cursor、GitHub Copilot CLI 等

适合人群

• 个人开发者：提升代码质量，减少 bug
• 团队负责人：统一团队开发流程，提升协作效率
• 开源维护者：确保贡献者遵循项目规范

开始使用

# Claude Code
/plugin install superpowers@claude-plugins-official

# Cursor
# 在设置中搜索 "superpowers" 并安装

# 其他平台参见官方文档

GitHub 项目地址：https://github.com/obra/superpowers
文档：https://superpowers.dev
Discord 社区：https://discord.gg/superpowers

参考资料：

1. Superpowers GitHub 仓库：https://github.com/obra/superpowers
2. Jesse Vincent 的博客：https://prime-radiant.com
3. TDD 红绿重构循环：https://martinfowler.com/bliki/TestDrivenDevelopment.html
4. 子智能体架构设计：https://www.anthropic.com/research/building-effective-agents
5. Claude Code 官方文档：https://docs.anthropic.com/claude-code

本文深入解析了 Superpowers 的技术架构、工作原理和最佳实践。通过 15+ 代码示例和完整的实战案例，帮助读者理解如何将 AI 从"会写代码"改造成"守纪律的工程师"。