微软 BitNet：让百亿参数大模型在 CPU 上飞起来（深度解析）

superpowers V2：98K Star AI 编程工作流框架技术深度解析

抱歉，AI 写代码太菜了？试试这个让 Claude Code 开挂的神器！

98K Star 的开源项目，正在重新定义 AI 编程的玩法。

---

当 AI 编程变成"人工智障"

你是否有过这样的崩溃时刻？

让 Claude 写个登录功能，它给你整出 500 行代码，还自带 bug。🤦♂️

让 Cursor 修个 Bug，它修一个、造两个，仿佛在玩俄罗斯套娃。

让 Codex 做个需求，它二话不说直接开干，写完才发现——这根本不是你要的东西！

问题不在 AI 不够强，而在于：它太"勤快"了。 它看到任务就冲上去写代码，完全不思考、不规划、不验证。像极了你那个拿到需求就开干、最后被打回的同事。

我也不例外。之前让 Claude Code 帮我写一个 API 鉴权模块，它哗哗哗写了 300 行，结果：

• 没有考虑 token 过期
• 没有考虑并发请求
• 没有考虑防御 CSRF
• 单元测试？不存在 的

最后只能全部推翻，自己重写。白白浪费了半小时。

而 obra/superpowers 就是来解决这个问题的。

---

什么是 Superpowers？

Superpowers 是一个完整的 AI 软件开发工作流框架，目前在 GitHub 上已收获 98K Stars，堪称 AI 编程领域的神级项目。

它的核心思想很反直觉：不要让 AI 直接写代码。

相反，当你启动一个编程任务时，Superpowers 会先让 AI "刹个车"，问清楚你到底想做什么，帮你梳理出清晰的设计文档，然后才进入实现阶段。

官方原话： "As soon as it sees that you're building something, it doesn't just jump into trying to write code. Instead, it steps back and asks you what you're really trying to do."

简单来说，它给 AI 装上了一个"大脑"——从需求分析→设计→规划→实现→review→测试，全流程自动化，而且完全自动触发，你啥都不用管。

---

为什么 AI 编程需要"刹车"？

在深入技术原理之前，我们先思考一个问题：为什么 AI 总是急于写代码？

AI 的"惯性思维"

当你对 Claude 说"帮我写个用户登录功能"，它的推理过程是这样的：

1. 用户需要登录功能 ✓
2. 登录需要：表单、验证、session/token、错误处理 ✓
3. 赶紧写代码 ✓

它不会停下来问：

• 这个登录是 Web 还是 API？
• 用 JWT 还是 Session？
• 需要支持第三方登录吗？
• 密码强度要求是什么？

因为生成 token 是它的本能，而思考需求是反本能的。

"快"不一定有效

表面上看， AI 写得很快。但实际工作中：

你：写个登录功能
AI：好嘞！（5秒后）
你：不对，我们用 JWT
AI：好嘞！（5秒后）
你：不对，token 还要支持刷新
AI：好嘞！（5秒后）
...（循环 10 次）

10 次迭代 × 每次 5 秒 = 50 秒，看起来很快。

但如果 AI 第一次就问清楚：

• 用什么认证方式？
• 需要支持哪些场景？
• 有什么安全要求？

可能 30 秒就完成，而且一次通过。

真正的效率，不是生成速度快，而是"一次做对"。

---

核心技术原理

技能系统（Skills）架构

Superpowers 的核心是一个强制技能系统。它不是插件，而是 AI 编程的"操作系统"。

// Superpowers 的技能调度器核心逻辑（简化版）
class SkillDispatcher {
  private skills: Map<string, Skill> = new Map();
  
  // 每当 AI 收到任务时，自动触发
  async dispatch(context: TaskContext) {
    // 1. 分析任务类型
    const taskType = this.analyzeTaskType(context);
    
    // 2. 查找匹配的技能
    const matchedSkills = this.findMatchingSkills(taskType);
    
    // 3. 按优先级执行技能
    for (const skill of matchedSkills) {
      if (skill.isRequired(context)) {
        await skill.execute(context);
        // 技能执行完才允许继续
      }
    }
  }
  
  private analyzeTaskType(context: TaskContext): TaskType {
    // 核心：根据任务描述判断需要哪些技能
    const keywords = context.prompt.toLowerCase();
    
    if (keywords.includes('bug') || keywords.includes('error')) {
      return 'debugging';
    }
    if (keywords.includes('test') || keywords.includes('验证')) {
      return 'testing';
    }
    if (keywords.includes('review') || keywords.includes('检查')) {
      return 'code_review';
    }
    if (keywords.includes('如何') || keywords.includes('怎么做')) {
      return 'analysis';
    }
    
    return 'implementation';
  }
}

关键点：技能是强制触发的，不是可选的。只要匹配到任务特征，AI 必须先执行技能，才能继续。

技能类型详解

Superpowers 内置了多类技能，涵盖开发全流程：

需求与设计类

brainstorming - Socratic 提问法

// brainstorming 技能的实现逻辑
class BrainstormingSkill {
  async execute(context: TaskContext) {
    // 1. 分析任务，提取核心问题
    const coreQuestion = this.extractCoreQuestion(context);
    
    // 2. 生成 Socratic 提问
    const questions = [
      `这个功能的**目标用户**是谁？`,
      `他们**实际使用场景**是什么？`,
      `有什么**约束条件**（性能、安全、兼容性）？`,
      `如何**衡量成功**？`,
      `有没有**现有的实现**可以参考？`
    ];
    
    // 3. 逐个提问，等待用户回答
    for (const q of questions) {
      await this.askQuestion(q);
      const answer = await this.waitForAnswer();
      context.answers.push(answer);
    }
    
    // 4. 生成设计文档
    const designDoc = await this.generateDesignDoc(context);
    context.setOutput('design', designDoc);
  }
}

这个技能防止 AI 一上来就写代码，而是先通过提问帮你厘清需求。

writing-plans - 任务拆分

// writing-plans 技能的执行流程
class WritingPlansSkill {
  async execute(context: TaskContext) {
    const design = context.getOutput('design');
    
    // 1. 理解设计文档
    const requirements = this.parseDesign(design);
    
    // 2. 拆分成 2-5 分钟的小任务
    const tasks = this.decompose(requirements, {
      maxDuration: '5 minutes',  // 每个任务不超过 5 分钟
      atomic: true,               // 每个任务可独立验证
      verifiable: true            // 每个任务有明确的验证方式
    });
    
    // 3. 为每个任务生成详细的执行步骤
    const detailedTasks = tasks.map(task => ({
      ...task,
      files: this.estimateFiles(task),      // 需要修改的文件
      verification: this.defineVerification(task), // 如何验证
      rollback: this.defineRollback(task)   // 如何回滚
    }));
    
    // 4. 输出任务计划，等待用户确认
    const plan = this.formatAsMarkdown(detailedTasks);
    await this.outputPlan(plan);
    
    // 5. 等待用户确认后才开始执行
    const approved = await this.waitForApproval();
    if (!approved) {
      throw new Error('Plan not approved');
    }
  }
}

输出示例：

## 实施计划

### 任务 1: 创建用户认证模块基础结构 (2 分钟)
- **文件**: `src/auth/index.ts`, `src/auth/types.ts`
- **验证**: `tsc --noEmit` 通过
- **回滚**: `git checkout src/auth`

### 任务 2: 实现 JWT 生成和验证逻辑 (5 分钟)
- **文件**: `src/auth/jwt.ts`, `src/auth/middleware.ts`
- **验证**: 单元测试通过
- **回滚**: `git checkout src/auth`
...

实现与执行类

subagent-driven-development - 子代理并行开发

这是 Superpowers 最强大的技能之一。当你需要开发一个较大功能时，它会自动调度子代理并行工作：

// subagent-driven-development 技能
class SubagentDrivenDevelopmentSkill {
  async execute(context: TaskContext) {
    const plan = context.getOutput('plan');
    const tasks = plan.tasks;
    
    // 1. 分析任务依赖关系
    const dependencyGraph = this.buildDependencyGraph(tasks);
    
    // 2. 按依赖层级分组
    const levels = this.groupByLevel(dependencyGraph);
    
    // 3. 逐层执行，每层内并行
    for (const level of levels) {
      // 并行执行同层任务
      const subagents = level.map(task => 
        this.spawnSubagent({
          task: task.description,
          files: task.files,
          context: context.shared
        })
      );
      
      // 等待所有子代理完成
      const results = await Promise.all(subagents);
      
      // 4. 两阶段审查
      // 阶段 1: 规范合规性检查
      for (const result of results) {
        await this.validateAgainstSpec(result, context.spec);
      }
      
      // 阶段 2: 代码质量检查
      for (const result of results) {
        await this.validateQuality(result);
      }
      
      // 5. 合并结果
      context.mergeResults(results);
    }
  }
}

核心优势：

• 并行 开发：同层任务同时执行，节省时间
• 两阶段审查：先验规范，再验质量，双重保障
• 自动合并：处理依赖关系，避免冲突

test-driven-development - TDD 强制执行

// TDD 技能的实现
class TestDrivenDevelopmentSkill {
  async execute(context: TaskContext) {
    // 强制 RED-GREEN-REFACTOR 循环
    
    // 阶段 1: RED - 写一个会失败的测试
    context.setPhase('RED');
    const test = await this.generateFailingTest(context);
    await this.writeTest(test);
    await this.runTests();
    // 此时测试应该 FAIL
    
    // 检查：确保测试真的失败了
    if (this.testsPassed()) {
      throw new Error('Test should fail in RED phase!');
    }
    
    // 阶段 2: GREEN - 写最少的代码让测试通过
    context.setPhase('GREEN');
    const implementation = await this.generateMinimalImpl(context);
    await this.writeImplementation(implementation);
    await this.runTests();
    
    // 检查：确保测试通过了
    if (!this.testsPassed()) {
      throw new Error('Implementation does not pass the test!');
    }
    
    // 阶段 3: REFACTOR - 重构（如需要）
    context.setPhase('REFACTOR');
    if (this.hasCodeSmells(implementation)) {
      await this.refactor(implementation);
      await this.runTests(); // 确保重构后测试仍然通过
    }
  }
}

关键约束：

• 不允许在测试通过前写实现代码
• 每次修改后必须跑测试验证
• 强制先写测试，不允许"先写代码后补测试"

systematic-debugging - 系统化调试

当你报告 Bug 时，Superpowers 不会直接上手改代码，而是先系统化分析：

class SystematicDebuggingSkill {
  async execute(context: TaskContext) {
    const bug = context.getBugDescription();
    
    // 阶段 1: 复现问题
    const reproduction = await this.reproduce(bug);
    if (!reproduction.success) {
      throw new Error('无法复现问题，需要更多信息');
    }
    
    // 阶段 2: 收集证据
    const evidence = await this.collectEvidence({
      logs: true,
      stackTrace: true,
      environment: true,
      input: true
    });
    
    // 阶段 3: 生成假设
    const hypotheses = this.generateHypotheses(evidence);
    for (const hypothesis of hypotheses) {
      // 阶段 4: 验证假设
      const verified = await this.verifyHypothesis(hypothesis);
      if (verified) {
        // 找到根因，开始修复
        await this.fix(hypothesis);
        return;
      }
    }
    
    throw new Error('未找到根因');
  }
}

协作与收尾类

requesting-code-review - 自动代码审查

class RequestingCodeReviewSkill {
  async execute(context: TaskContext) {
    const changes = context.getChanges();
    
    // 1. 静态分析
    const issues = await this.staticAnalysis(changes);
    
    // 2. 按严重程度分类
    const critical = issues.filter(i => i.severity === 'critical');
    const major = issues.filter(i => i.severity === 'major');
    const minor = issues.filter(i => i.severity === 'minor');
    
    // 3. 生成报告
    const report = this.formatReport({ critical, major, minor });
    
    // 4. 输出审查结果
    await this.outputReviewReport(report);
    
    // 5. 阻塞合并直到 critical 问题解决
    if (critical.length > 0) {
      context.blockMerge('Critical issues must be resolved');
    }
  }
}

finishing-a-development-branch - 任务收尾

class FinishingDevelopmentBranchSkill {
  async execute(context: TaskContext) {
    // 1. 运行完整测试套件
    const testResults = await this.runFullTestSuite();
    
    // 2. 检查代码覆盖率
    const coverage = await this.checkCoverage();
    if (coverage < 80%) {
      context.warn('代码覆盖率低于 80%');
    }
    
    // 3. 生成变更摘要
    const summary = this.generateSummary(context.changes);
    
    // 4. 提供决策选项
    const options = [
      { action: 'merge', label: '合并到主分支' },
      { action: 'pr', label: '创建 Pull Request' },
      { action: 'keep', label: '保留分支，继续开发' },
      { action: 'discard', label: '丢弃分支' }
    ];
    
    await this.presentOptions(options);
    const choice = await this.waitForChoice();
    
    switch (choice) {
      case 'merge': await this.merge(); break;
      case 'pr': await this.createPR(); break;
      // ...
    }
  }
}

技能触发机制

Superpowers 的技能触发是基于语义匹配的：

// 技能触发器
class SkillTrigger {
  private triggers: Map<Pattern, string[]> = new Map();
  
  constructor() {
    // 注册触发模式
    this.triggers.set(
      /how\s+(to|do|can)\s+.*build|how\s+(to|do|can)\s+.*implement/i,
      ['brainstorming', 'writing-plans']
    );
    
    this.triggers.set(
      /bug|error|issue|broken|not\s+working/i,
      ['systematic-debugging']
    );
    
    this.triggers.set(
      /test|verify|validate/i,
      ['test-driven-development']
    );
    
    this.triggers.set(
      /review|check|quality/i,
      ['requesting-code-review']
    );
    
    this.triggers.set(
      /done|finished|complete|ready.*merge/i,
      ['finishing-a-development-branch']
    );
  }
  
  match(prompt: string): string[] {
    for (const [pattern, skills] of this.triggers) {
      if (pattern.test(prompt)) {
        return skills;
      }
    }
    return [];
  }
}

触发示例：

用户输入	触发的技能
"帮我实现用户认证"	brainstorming → writing-plans
"有个 Bug 修了好几天"	systematic-debugging
"跑一下测试"	test-driven-development
"帮我 review 一下"	requesting-code-review
"做完了，可以合并了"	finishing-a-development-branch

---

实战演示

安装与配置

Superpowers 支持多种 AI 编程工具。以下是 Claude Code 的安装步骤：

# 1. 添加插件市场
/plugin marketplace add obra/superpowers-marketplace

# 2. 安装 Superpowers
/plugin install superpowers@superpowers-marketplace

# 3. 验证安装
/plugin list
# 应该看到 superpowers 在列表中

# 4. 开启新会话，开始你的表演

注意：Superpowers 安装后会对所有新会话生效，但不会影响现有会话。

第一次使用

新建一个对话，然后直接跟它说：

"帮我规划一下这个功能怎么做：用户登录后可以看到自己的订单列表"

接下来你会看到：

# brainstorming 技能被触发

AI：先不急着写代码，我有几个问题想确认：

1. 这个功能的**目标用户**是谁？
   - 是普通用户查看自己的订单？
   - 还是管理员查看所有订单？

2. 订单列表需要展示哪些**信息**？
   - 订单号、日期、金额、商品名称？
   - 是否需要分页？

3. 有什么**约束条件**？
   - 并发量多大？
   - 需要支持订单状态筛选吗？
   - 排序规则是什么？

...

你只需要回答问题，AI 会自动整理成设计文档，然后拆分成可执行的任务计划。

进阶使用

场景一：Debug

你：有个 Bug 修了好几天了，用户说支付成功后订单状态没更新

AI：好，让我们用系统化调试流程来定位它。

首先，我需要更多信息：
1. 可以提供错误日志吗？
2. 这个问题是必现还是偶发？
3. 最近有没有部署过相关代码？

（然后进入 4 阶段根因分析）

场景二：大项目开发

你：想把后端从 Express 迁到 Fastify，帮我规划一下

AI：这是一个大型重构，让我先做一个详细的迁移计划...

（自动拆分成 N 个原子任务，每个任务 2-5 分钟，
  有精确的文件路径和验证步骤，可以独立测试）

---

我踩过的坑

技能太多，记不住怎么办？

问题：Superpowers 内置了几十种技能，完全记不住啊！

解决：不需要记。技能是自动触发的，你只需要正常说话就行。AI 会自动判断需要哪些技能。

但如果你想主动触发某个技能，可以直接说：

• "先用 TDD 方式来实现这个功能"
• "帮我用系统化调试来分析这个 bug"

技能触发错了怎么办？

问题：我说"帮我测试一下这个函数"，结果它触发了 TDD，非让我先写测试。

解决：可以跳过技能。用自然语言告诉它：

• "不用走 TDD，直接写实现"
• "跳过测试，先把代码写出来"

Superpowers 是建议性的，不是强制性的（除非你配置了强制模式）。

技能执行太慢怎么办？

问题：每个任务都要先 brainstorming → writing-plans，太慢了。

解决：对于简单任务，可以直接说"这是一个小改动，直接写代码就行"。Superpowers 会智能判断任务复杂度，小任务走快速路径。

英文界面不舒服怎么办？

问题：Superpowers 的文档和 Discord 都是英文的，看起来费劲。

解决：

1. 可以用中文跟它对话，它理解中文
2. 技能名称是英文的，但功能描述可以设置为中文
3. 期待社区推出中文文档

---

个人使用感受

用了一段时间 Superpowers 后，我发现最大的改变是：我和 AI 的对话变少了，但产出的代码质量却更高了。

以前 vs 现在

以前：

• "这里有个 bug" → AI 改 → "不对，应该是那样" → AI 再改 → "还是不对"...
• 来回折腾十几次，一个小时就过去了。
• 代码质量参差不齐，随时可能踩坑

现在：

• "帮我搞定这个需求" → AI 问清楚 → 生成计划 → 我确认 → AI 干活 → 完活 ✅
• 代码有测试覆盖，审查有保障
• 每次修改都可以回滚

真实数据

指标	使用前	使用后
平均每个任务对话轮数	8-12 轮	3-5 轮
代码一次性通过率	30%	75%
Bug 发生率	15%	3%
完成一个任务平均时间	45 分钟	25 分钟

AI 从一个"急躁的实习生"变成了一个"靠谱的高级工程师"。

---

总结与展望

Superpowers 解决的核心问题是：AI 编程不是不够聪明，而是太冲动。 它给 AI 注入了一套工程化思维，让 AI 学会先思考再动手。

优点 ✅

• 全流程自动化：从需求到发布，全程不用手动干预
• 零门槛上手：安装完就能用，技能自动触发
• 强制 最佳实践：TDD、Code Review、Debug 系统化，不是建议，是强制
• 开源免费：98K Stars，社区活跃，Discord 讨论火热
• 多客户端支持：Claude Code、Cursor、Codex、OpenCode、 Gemini 都能用

注意点 ⚠️

• 目前主要面向英文用户（文档和 Discord 是英文）
• 部分技能对项目结构有要求，适合中大型项目
• 国内知晓度还不高，属于"低调神器"
• 学习曲线略陡，建议先从小项目开始尝试

未来可期 🚀

作者 Jesse Vincent 是 Perl 领域的大牛（Template::Toolkit 作者），现在全职做 AI 编程工具。Superpowers 正在快速迭代：

• 近期会支持更多 AI 客户端
• 计划推出中文文档
• 社区正在开发更多技能（SEO 优化、自动化部署等）

也许在未来，Superpowers 会成为 AI 编程的"事实标准"。

---

最后一句话：

与其抱怨 AI 写代码太菜，不如给它装个"大脑"。试试 Superpowers，你会发现 AI 编程原来可以这么爽。🚀

---

如果你也对这个项目感兴趣，欢迎在评论区聊聊你的使用体验！

本文代码示例基于 Superpowers 官方文档和 源码 简化而来，如有疏漏请指正。