Superpowers：让AI编程Agent从"码农"进化为"架构师"的工程化框架

GitHub 95k+ Star，Anthropic官方认可，AI编码代理的"肌肉记忆"训练系统

引言：AI编程的痛点

用过Claude Code、Cursor或GitHub Copilot的开发者都有一个共同感受：AI写代码很快，但质量参差不齐。

你让它"帮我写一个用户登录功能"，它可能：

• 不问你用JWT还是Session，直接选一个开写
• 不写单元测试，写完才发现边界情况没处理
• 不考虑错误处理，happy path一路到底
• 架构设计？不存在的，直接上手怼代码

结果就是：代码能跑，但不敢用。Review的时间比自己写还长。

这就是Superpowers要解决的问题。

什么是Superpowers？

Superpowers不是又一个AI代码生成工具，而是一套软件开发工作流强制执行框架。它通过14个可组合的"技能"（Skills），将测试驱动开发（TDD）、结构化调试、设计优先规划等软件工程最佳实践，固化为AI必须遵循的自动化工作流。

核心理念：流程大于提示。

传统AI编程：给提示词 → AI生成代码 → 人工检查修改
Superpowers：定义工作流 → AI按流程执行 → 自动验证质量 → 持续迭代优化

项目热度

• GitHub Star: 95,180+（截至2026年4月）
• 日增Star: 约4,000
• 官方认可: 2026年2月被Anthropic官方接受进入Claude插件市场
• 多平台支持: Claude Code、Cursor、Codex、Gemini CLI

核心架构：三层设计

┌─────────────────────────────────────────┐
│           可插拔技能层 (Skills)           │
│  TDD | 调试 | 设计验证 | 代码审查 | ...  │
├─────────────────────────────────────────┤
│           平台适配层 (Adapters)           │
│   Claude Code | Cursor | Codex | ...    │
├─────────────────────────────────────────┤
│           共享核心层 (Core)               │
│      技能注册 | 工作流引擎 | 状态管理      │
└─────────────────────────────────────────┘

这种架构确保了跨平台兼容性和可扩展性。无论你用哪个AI编码工具，Superpowers都能提供一致的工程化体验。

五阶段结构化开发流程

Superpowers的核心是五阶段结构化工作流，这是对传统软件开发的AI化改造：

阶段一：需求理解（Requirement Clarification）

AI不会直接写代码，而是先通过结构化对话模板与开发者明确需求：

## 需求澄清清单

### 项目类型
- [ ] Web应用
- [ ] API服务  
- [ ] 命令行工具
- [ ] 库/框架

### 技术栈约束
- 编程语言：_____
- 主要框架：_____
- 数据库：_____

### 非功能需求
- [ ] 性能要求（QPS/响应时间）
- [ ] 安全合规要求
- [ ] 可扩展性要求

关键产出：需求规格说明书（SRS）+ 约束条件清单

阶段二：设计验证（Design Validation）

这是传统AI编码代理完全缺失的环节。

AI代理提出完整的设计方案，包括：

• 系统架构图
• 模块划分与职责
• 接口定义（输入/输出/错误码）
• 数据流图

必须等待开发者确认后，才进入编码阶段。

## 设计方案确认

### 架构概述
[AI生成的架构图/描述]

### 模块设计
| 模块名 | 职责 | 依赖 |
|--------|------|------|
| auth | 身份认证 | user, jwt |
| user | 用户管理 | db |

### 接口定义
```go
type AuthService interface {
    Login(ctx context.Context, req LoginRequest) (*LoginResponse, error)
    Logout(ctx context.Context, token string) error
}

请确认以上设计后，我将继续实施计划。

### 阶段三：详细计划（Detailed Planning）

基于确认的设计，AI创建详细的开发计划：

```markdown
## 实施计划

### 任务1: 用户模型定义
- [ ] 创建 User struct
- [ ] 数据库 migration
- [ ] 预计文件：models/user.go, migrations/001_users.sql

### 任务2: JWT工具包
- [ ] Token生成/验证
- [ ] 过期处理
- [ ] 预计文件：pkg/jwt/jwt.go

### 任务3: 登录接口实现
- [ ] Handler实现
- [ ] 单元测试（先写测试！）
- [ ] 集成测试

阶段四：自主执行（Autonomous Execution）

多个专业子代理开始协作：

并行执行 + 两轮Review机制：

1. 规格合规审查：是否按设计实现？
2. 代码质量审查：是否符合团队规范？

阶段五：验证交付（Verification & Delivery）

• 自动化测试通过率检查
• 代码覆盖率报告
• 文档生成
• 变更日志整理

14个核心技能（Skills）详解

Superpowers通过14个可组合的技能覆盖软件开发生命周期：

1. design-first（设计优先）

强制要求先完成设计文档，再开始编码。

2. tdd-enforcer（TDD强制执行）

红绿重构循环：先写测试 → 测试失败 → 写代码 → 测试通过 → 重构。

# Superpowers会自动检查：
✗ 写了代码但没写测试 → 拒绝提交
✗ 测试未通过 → 阻止进入下一阶段
✓ 测试覆盖率达到阈值 → 允许继续

3. task-decomposer（任务拆解）

将大需求拆分为可独立实现、可验证的小任务。

4. code-reviewer（代码审查）

自动检查：

• 代码风格一致性
• 潜在bug模式
• 安全漏洞
• 性能陷阱

5. debug-strategist（调试策略）

遇到bug不盲目改代码，而是：

1. 复现问题
2. 定位根因
3. 设计修复方案
4. 验证修复

6. doc-generator（文档生成）

自动生成API文档、README、变更日志。

7. test-designer（测试设计）

自动生成边界条件测试、异常场景测试。

8. refactor-advisor（重构建议）

识别代码坏味道，提出重构方案。

9. security-auditor（安全审计）

检查SQL注入、XSS、敏感信息泄露等风险。

10. performance-profiler（性能分析）

识别性能瓶颈，提出优化建议。

11. dependency-manager（依赖管理）

管理第三方库版本，检查安全漏洞。

12. git-strategist（Git策略）

规范提交信息，建议分支策略。

13. ci-cd-designer（CI/CD设计）

自动生成CI/CD流水线配置。

14. onboarding-assistant（上手助手）

帮助新成员快速理解项目结构。

实战示例：用Superpowers开发一个Go Web登录功能

传统方式 vs Superpowers方式

传统AI对话：

用户：帮我写一个Go的登录功能
AI：好的，这是代码...
[直接生成200行代码，没有测试，没有错误处理]

Superpowers方式：

用户：帮我写一个Go的登录功能
AI：在开始之前，我需要了解一些信息：

1. 你使用什么认证方式？
   - JWT
   - Session
   - OAuth2

2. 用户密码如何存储？
   - bcrypt
   - argon2
   - 其他

3. 数据库用什么？
   - PostgreSQL
   - MySQL
   - MongoDB

4. 需要哪些功能？
   - [ ] 登录
   - [ ] 注册
   - [ ] 刷新Token
   - [ ] 密码重置

请回答以上问题，我将为你生成完整的设计方案。

完整代码示例

假设需求已确认：JWT认证、PostgreSQL、bcrypt、需要登录和刷新Token。

步骤1：设计确认后，AI生成接口定义

// auth/service.go
package auth

import "context"

type Service interface {
    // Login 用户登录
    // 成功返回JWT token对（access + refresh）
    Login(ctx context.Context, email, password string) (*TokenPair, error)
    
    // RefreshToken 使用refresh token获取新的access token
    RefreshToken(ctx context.Context, refreshToken string) (*TokenPair, error)
    
    // Logout 登出，使token失效
    Logout(ctx context.Context, token string) error
}

type TokenPair struct {
    AccessToken  string    `json:"access_token"`
    RefreshToken string    `json:"refresh_token"`
    ExpiresAt    time.Time `json:"expires_at"`
}

// 错误定义
var (
    ErrInvalidCredentials = errors.New("invalid email or password")
    ErrTokenExpired       = errors.New("token expired")
    ErrTokenInvalid       = errors.New("invalid token")
)

步骤2：AI自动生成测试（TDD模式）

// auth/service_test.go
package auth

import (
    "context"
    "testing"
    "time"
    
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
)

// MockUserRepository 模拟用户仓库
type MockUserRepository struct {
    mock.Mock
}

func (m *MockUserRepository) FindByEmail(ctx context.Context, email string) (*User, error) {
    args := m.Called(ctx, email)
    if args.Get(0) == nil {
        return nil, args.Error(1)
    }
    return args.Get(0).(*User), args.Error(1)
}

func TestLogin_Success(t *testing.T) {
    // Arrange
    mockRepo := new(MockUserRepository)
    svc := NewService(mockRepo, &Config{
        AccessTokenTTL:  15 * time.Minute,
        RefreshTokenTTL: 7 * 24 * time.Hour,
        SecretKey:       "test-secret",
    })
    
    hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password123"), bcrypt.DefaultCost)
    mockRepo.On("FindByEmail", mock.Anything, "user@example.com").
        Return(&User{
            ID:       1,
            Email:    "user@example.com",
            Password: string(hashedPassword),
        }, nil)
    
    // Act
    tokens, err := svc.Login(context.Background(), "user@example.com", "password123")
    
    // Assert
    assert.NoError(t, err)
    assert.NotNil(t, tokens)
    assert.NotEmpty(t, tokens.AccessToken)
    assert.NotEmpty(t, tokens.RefreshToken)
    mockRepo.AssertExpectations(t)
}

func TestLogin_InvalidCredentials(t *testing.T) {
    // Arrange
    mockRepo := new(MockUserRepository)
    svc := NewService(mockRepo, &Config{})
    
    mockRepo.On("FindByEmail", mock.Anything, "user@example.com").
        Return(nil, ErrUserNotFound)
    
    // Act
    tokens, err := svc.Login(context.Background(), "user@example.com", "wrongpassword")
    
    // Assert
    assert.ErrorIs(t, err, ErrInvalidCredentials)
    assert.Nil(t, tokens)
}

func TestLogin_EmptyEmail(t *testing.T) {
    // Arrange
    svc := NewService(nil, &Config{})
    
    // Act
    tokens, err := svc.Login(context.Background(), "", "password123")
    
    // Assert
    assert.Error(t, err)
    assert.Nil(t, tokens)
    assert.Contains(t, err.Error(), "email is required")
}

步骤3：实现业务逻辑

// auth/service_impl.go
package auth

import (
    "context"
    "errors"
    "time"
    
    "github.com/golang-jwt/jwt/v5"
    "golang.org/x/crypto/bcrypt"
)

type service struct {
    repo   UserRepository
    config *Config
}

func NewService(repo UserRepository, config *Config) Service {
    return &service{
        repo:   repo,
        config: config,
    }
}

func (s *service) Login(ctx context.Context, email, password string) (*TokenPair, error) {
    // 输入验证
    if email == "" {
        return nil, errors.New("email is required")
    }
    if password == "" {
        return nil, errors.New("password is required")
    }
    
    // 查找用户
    user, err := s.repo.FindByEmail(ctx, email)
    if err != nil {
        return nil, ErrInvalidCredentials
    }
    
    // 验证密码
    if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)); err != nil {
        return nil, ErrInvalidCredentials
    }
    
    // 生成token对
    return s.generateTokenPair(user.ID)
}

func (s *service) generateTokenPair(userID int64) (*TokenPair, error) {
    now := time.Now()
    
    // Access Token
    accessClaims := jwt.MapClaims{
        "user_id": userID,
        "type":    "access",
        "exp":     now.Add(s.config.AccessTokenTTL).Unix(),
        "iat":     now.Unix(),
    }
    accessToken := jwt.NewWithClaims(jwt.SigningMethodHS256, accessClaims)
    accessString, err := accessToken.SignedString([]byte(s.config.SecretKey))
    if err != nil {
        return nil, err
    }
    
    // Refresh Token
    refreshClaims := jwt.MapClaims{
        "user_id": userID,
        "type":    "refresh",
        "exp":     now.Add(s.config.RefreshTokenTTL).Unix(),
        "iat":     now.Unix(),
    }
    refreshToken := jwt.NewWithClaims(jwt.SigningMethodHS256, refreshClaims)
    refreshString, err := refreshToken.SignedString([]byte(s.config.SecretKey))
    if err != nil {
        return nil, err
    }
    
    return &TokenPair{
        AccessToken:  accessString,
        RefreshToken: refreshString,
        ExpiresAt:    now.Add(s.config.AccessTokenTTL),
    }, nil
}

步骤4：AI自动运行测试并报告

$ go test ./auth -v
=== RUN   TestLogin_Success
--- PASS: TestLogin_Success (0.12s)
=== RUN   TestLogin_InvalidCredentials
--- PASS: TestLogin_InvalidCredentials (0.01s)
=== RUN   TestLogin_EmptyEmail
--- PASS: TestLogin_EmptyEmail (0.00s)
=== RUN   TestRefreshToken_Success
--- PASS: TestRefreshToken_Success (0.02s)
PASS
coverage: 87.3% of statements
ok      github.com/example/app/auth    0.152s

✅ 所有测试通过，代码覆盖率87.3%

如何开始使用Superpowers？

Claude Code用户

# 安装插件
/plugin install superpowers@claude-plugins-official

# 开始使用
# 无需额外操作，Agent会自动触发对应的技能

Cursor用户

# 在Cursor设置中启用Superpowers扩展
# 或手动安装
npm install -g @superpowers/cursor-adapter

Codex/Gemini CLI用户

# 安装Superpowers CLI
npm install -g @superpowers/cli

# 初始化项目
superpowers init

# 开始编码（自动触发工作流）
superpowers code

总结：为什么Superpowers值得关注？

Superpowers代表了AI辅助编程的下一个进化阶段：从"能写代码"到"能写好代码"。

它不是替代开发者，而是让AI真正成为值得信赖的开发伙伴。

参考链接

• GitHub: https://github.com/obra/superpowers
• Claude插件市场: 搜索 "superpowers"
• 官方文档: https://superpowers.dev/docs

本文基于Superpowers开源项目及相关技术资料撰写，代码示例为演示用途，生产环境请根据实际需求调整。