Claude Code + GLM 5.1 驱动：Superpowers 七阶段工作流从零搭建 Go API 脚手架全记录

3 分钟速览：核心概念

本文是什么？

这是一份完整的动手实录。它不堆砌概念，不罗列功能清单——而是还原我坐在电脑前，启动 Claude Code，借助 GLM 5.1 作为 Coding Plan Provider，联合 Superpowers 工作流，从零开始开发一套 Go API Server 脚手架的完整过程。

最终产物：一个具备用户注册、登录鉴权、受保护接口的 RESTful API 服务，可以直接当作任何 Go 后端项目的起点。

为什么需要这篇文章？

前 20 篇文章已经覆盖了 Claude Code 的安装、配置、Skills、MCP、Hooks 以及 Superpowers 理论……但一直缺少一样东西——一个端到端的、从 0 到 1 的实战案例。

你可能浏览过 Superpowers 的七阶段流程图，但心底仍有不少疑惑：

• • 头脑风暴阶段 AI 究竟会提出哪些问题？
• • Writing Plans 产出的任务清单到底长什么样？
• • Subagent 驱动开发时，代码是如何逐块生成的？
• • 碰到 bug 时，systematic-debugging 怎么介入？

本文就来逐一回应这些困惑。

能帮你解决什么？

• • 看完了 Superpowers 理论却不知如何落地
• • 想用 Claude Code 搭建 Go 后端项目但缺少参考路径
• • 想了解 GLM 5.1 作为 Coding Plan Provider 的真实表现
• • 需要一套可复用的 Go API 脚手架作为后续项目的起点

Claude Code 编码执行

Go API Server 脚手架

GLM 5.1 Coding Plan

Superpowers 工程纪律

注册 / 登录 / 鉴权

三层架构

MySQL + Redis

技术栈选型

为什么选 Go？

从 2025 到 2026 年，Go 在国内后端开发的受欢迎程度持续走高。字节跳动、腾讯、B 站、七牛云等企业的核心基础设施几乎都由 Go 构建。对国内开发者来说，Go 的几个优势尤其突出：

• • 编译飞快、部署简单：编译成单一二进制文件，Docker 镜像可压缩到 10 MB 以下
• • 并发模型天然友好：goroutine 比系统线程轻量得多，极其适合 API 服务
• • 国内生态成熟：Gin、GORM、go-redis 等库文档齐备，中文社区十分活跃

选型清单

为什么选 MySQL 而不选 PostgreSQL？

这是个高频问题。理由十分务实：

1. 国内绝大多数公司的 DBA 团队更擅长 MySQL，排障效率更高
2. 阿里云 RDS MySQL、腾讯云 TDSQL 都是标杆产品，运维工具链完善
3. 脚手架项目旨在体现架构分层与代码组织，而非比拼数据库特性
4. 若后续确有需要，GORM 的方言抽象使得切换到 PostgreSQL 成本极低

Redis 的双重角色

在这个脚手架中，Redis 身兼两职：

1. Token 缓存：JWT 签发后录入 Redis（key: token:{user_id}，TTL: 24h），登出时删除该 key，实现 Token 主动失效
2. 接口限流：基于 IP 的滑动窗口限流，阻止暴力注册和撞库登录

核心难题与 GLM 5.1 Coding Plan

搭脚手架需要大量 CRUD 代码——逻辑不复杂，但编写过程挺繁琐。这正是 GLM 5.1 Coding Plan 的用武之地：让 GLM 5.1 承担编码执行，Claude Code 则集中精力在架构设计与代码审查上。

Claude Code 专注于“怎么搭”，GLM 5.1 负责“写出来”。

架构总览

Token 验证 → 401

客户端 → Gin Router → 公开路由 /register /login → Auth 中间件 → Handler 层 → Service 层 → Repository 层 → MySQL/Redis
拒绝访问

经典四层架构：Router 负责路由注册，Handler 处理参数绑定与响应，Service 封装业务逻辑，Repository 管理数据访问。认证中间件横切 Auth 逻辑。

Superpowers 头脑风暴

一切从 /superpowers:brainstorming 开始。

第一轮：启动

我在终端输入需求：

👤 我：我要搭建一个 Go API Server 脚手架，用 Gin + GORM + MySQL + Redis，包含用户注册、登录、JWT 鉴权。

Claude Code 没有立刻敲代码，而是进入 Superpowers 的头脑风暴阶段：

🤖 Claude Code：收到。动手之前，我需要确认几项关键设计决策。

• • 问题 1：数据库选型——你已指定 MySQL。确认一下，是否需要同时兼容 PostgreSQL？还是用 MySQL 即可？
• • 问题 2：Redis 的使用场景——你希望 Redis 承担哪些职责？仅 Token 缓存，还是也做接口限流？
• • 问题 3：项目结构——你更倾向经典的分层架构（Handler/Service/Repository），还是 DDD 风格？

👤 我：直接 MySQL，不用兼容。Redis 做 Token 缓存加限流。用经典分层架构。

第二轮：架构推导

🤖 Claude Code：明白。那我来推导一下架构分层：

handler/    - HTTP 请求处理，参数绑定和响应
service/    - 业务逻辑，JWT 签发，密码哈希
repository/ - 数据库操作，GORM 查询
middleware/  - 认证中间件，限流中间件
router/     - 路由注册
model/      - 数据模型定义
config/     - 配置加载

依赖方向：handler → service → repository → model，单向依赖，不反向引用。

🤖 Claude Code：

• • 问题 4：API 前缀——用 /api/v1 还是 /api？
• • 问题 5：配置管理——用环境变量还是配置文件（YAML/TOML）？

👤 我：用 /api 就行，配置用环境变量，保持简单。

第三轮：数据库设计

🤖 Claude Code：好的。用户表设计如下：

设计说明：

• • 密码使用 bcrypt 哈希存储，绝不存明文
• • username 加唯一索引防止重复注册
• • 暂时不加 email/phone 字段——脚手架做到最小化，后续按需扩展

🤖 Claude Code：这个设计可以吗？

👤 我：可以，就按这个设计。开始吧。

第四轮：JWT 认证流程确认

🤖 Claude Code：最后确认一下 JWT 认证流程：

1. 用户调用 /api/login，校验密码后签发 JWT
2. JWT 存入 Redis（key: token:{user_id}，TTL: 24h）
3. 后续请求在 Authorization header 中以 Bearer Token 携带
4. 中间件解析 JWT → 查 Redis 确认有效性 → 放行或返回 401
5. 登出时从 Redis 中删除对应 key，实现 Token 主动失效

🤖 Claude Code：这个流程确认后，我就可以生成完整的开发计划了。

👤 我：确认，开始生成计划。

请注意整个过程——AI 先连续抛出 5 个问题，逐一敲定数据库选型、Redis 职责、架构风格、API 前缀、配置管理，最后才确认 JWT 流程。没有一个问题是浪费时间的，每一个回答都直接决定后续代码的生成。

这便是 Superpowers 头脑风暴的价值：先想清楚，再动手。

Writing Plans

头脑风暴通过后，我触发了 Writing Plans 阶段：

👤 我：/superpowers:writing-plans

Claude Code 依据之前确认的设计，自动生成了完整的任务清单：

🤖 Claude Code：基于头脑风暴的设计决策，我生成了以下开发计划：

PLAN: Go API Server 脚手架
=========================

Task 1: 项目初始化
  - go mod init
  - 创建目录结构
  - 编写 config/config.go 加载环境变量

Task 2: 数据模型 + 数据库连接
  - model/user.go 定义 User 结构体
  - 编写 MySQL 连接逻辑
  - AutoMigrate 自动建表

Task 3: Repository 层
  - repository/user.go 实现 CreateUser / GetUserByUsername

Task 4: Service 层
  - service/user.go 实现 Register / Login
  - bcrypt 密码哈希
  - JWT 签发 + Redis 缓存

Task 5: 认证中间件
  - middleware/auth.go 实现 AuthMiddleware
  - 解析 JWT + Redis 验证

Task 6: Handler 层
  - handler/user.go 实现 Register / Login / Echo 三个接口

Task 7: 路由注册
  - router/router.go 组装路由 + 中间件

Task 8: 启动入口
  - main.go 组装所有依赖，启动服务

Task 9: 编译验证 + 接口测试
  - go build 编译
  - curl 测试注册、登录、鉴权接口

用户审批

🤖 Claude Code：以上 9 个任务覆盖了脚手架的全部功能。任务之间有依赖关系，我会按顺序执行。你确认这个计划吗？

👤 我：确认，开始执行。

Git Worktree

计划审批通过后，Superpowers 自动创建隔离工作区：

# AI 自动执行
🌳 创建隔离工作区: feature/go-api-server
🔀 切换到新分支: feature/go-api-server
📁 初始化 Go 模块: go mod init github.com/example/go-api-server
✅ 工作区就绪

Git Worktree 是 Superpowers 阶段 2 的核心机制。它创建独立的工作目录和分支，让 main 分支保持干净。若后续发现问题，直接删掉 worktree 即可回到原点。

Subagent 驱动开发

任务计划批准、工作区就绪后，Superpowers 进入阶段 4——Subagent 驱动开发。

每个 Task 都由独立的子 Agent 执行，通过规范合规审查和代码质量审查两道关卡。

以下是四个关键代码片段的完整过程。

片段 1：路由注册（router/router.go）

子 Agent 3 号执行 Task 7，负责路由注册与中间件挂载：

🤖 Claude Code：Subagent-3 开始执行 Task 7: 路由注册

规范合规审查：路由分组符合架构设计（公开路由 + 认证路由） 代码质量审查：依赖注入通过参数传入，不使用全局变量

// router/router.go
package router

import (
    "go-api-server/handler"
    "go-api-server/middleware"

    "github.com/gin-gonic/gin"
    "github.com/redis/go-redis/v9"
)

// SetupRouter 注册所有路由和中间件
func SetupRouter(userHandler *handler.UserHandler, rdb *redis.Client, jwtSecret string) *gin.Engine {
    r := gin.Default()

    api := r.Group("/api")
    {
        // 公开路由：注册和登录
        api.POST("/register", userHandler.Register)
        api.POST("/login", userHandler.Login)

        // 认证路由：需要携带有效 Token
        auth := api.Group("/")
        auth.Use(middleware.AuthMiddleware(rdb, jwtSecret))
        {
            auth.GET("/echo", userHandler.Echo)
        }
    }

    return r
}

路由结构一目了然：公开的 /register 和 /login 放在外层，需认证的路由集中在 auth 分组内，通过 AuthMiddleware(rdb, jwtSecret) 保护。SetupRouter 接收 rdb 和 jwtSecret 参数并传递给中间件，保持依赖注入的统一性。/echo 是一个测试端点，返回当前用户信息，用于验证鉴权是否生效。

片段 2：Service 层（service/user.go）

子 Agent 4 号执行 Task 4，实现注册与登录的核心业务逻辑：

🤖 Claude Code：Subagent-4 开始执行 Task 4: Service 层

规范合规审查：密码使用 bcrypt 哈希，JWT 签发后存入 Redis 代码质量审查：错误处理完整，Redis 操作具备降级逻辑

// service/user.go
package service

import (
    "context"
    "errors"
    "fmt"
    "time"

    "go-api-server/model"
    "go-api-server/repository"

    "github.com/golang-jwt/jwt/v5"
    "github.com/redis/go-redis/v9"
    "golang.org/x/crypto/bcrypt"
)

type UserService struct {
    repo       *repository.UserRepository
    rdb        *redis.Client
    jwtSecret  []byte
}

func NewUserService(repo *repository.UserRepository, rdb *redis.Client, secret string) *UserService {
    return &UserService{
        repo:      repo,
        rdb:       rdb,
        jwtSecret: []byte(secret),
    }
}

// Register 用户注册：校验用户名唯一性，bcrypt 哈希密码，写入数据库
func (s *UserService) Register(username, password string) error {
    existing, err := s.repo.GetByUsername(username)
    if err != nil {
        return fmt.Errorf("查询用户失败: %w", err)
    }
    if existing != nil {
        return errors.New("用户名已存在")
    }

    hashed, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
    if err != nil {
        return fmt.Errorf("密码哈希失败: %w", err)
    }

    user := &model.User{
        Username: username,
        Password: string(hashed),
    }
    return s.repo.Create(user)
}

// Login 用户登录：验证密码，签发 JWT，缓存到 Redis
func (s *UserService) Login(username, password string) (string, error) {
    user, err := s.repo.GetByUsername(username)
    if err != nil {
        return "", fmt.Errorf("查询用户失败: %w", err)
    }
    if user == nil {
        return "", errors.New("用户不存在")
    }

    if err := bcrypt.CompareHashAndPassword(
        []byte(user.Password), []byte(password),
    ); err != nil {
        return "", errors.New("密码错误")
    }

    // 签发 JWT
    claims := jwt.MapClaims{
        "user_id":  user.ID,
        "username": user.Username,
        "exp":      time.Now().Add(24 * time.Hour).Unix(),
    }
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    tokenStr, err := token.SignedString(s.jwtSecret)
    if err != nil {
        return "", fmt.Errorf("签发 Token 失败: %w", err)
    }

    // 缓存到 Redis，TTL 24 小时
    ctx := context.Background()
    key := fmt.Sprintf("token:%d", user.ID)
    if err := s.rdb.Set(ctx, key, tokenStr, 24*time.Hour).Err(); err != nil {
        // Redis 写入失败不影响登录，但记录日志
        fmt.Printf("警告: Redis 缓存 Token 失败: %v\n", err)
    }

    return tokenStr, nil
}

登录逻辑的关键路径：bcrypt 比对密码 → JWT 签发 → Redis 缓存。注意 Redis 写入失败时的降级处理——即便 Redis 暂时不可用，登录不会中断，只是失去了主动使 Token 失效的能力。

片段 3：认证中间件（middleware/auth.go）

子 Agent 5 号执行 Task 5：

🤖 Claude Code：Subagent-5 开始执行 Task 5: 认证中间件

规范合规审查：从 Authorization header 提取 Bearer Token，解析后查 Redis 验证 代码质量审查：错误响应统一采用 JSON 格式，缺失的导入已修正

// middleware/auth.go
package middleware

import (
    "context"
    "fmt"
    "net/http"
    "strings"

    "github.com/gin-gonic/gin"
    "github.com/golang-jwt/jwt/v5"
    "github.com/redis/go-redis/v9"
)

func AuthMiddleware(rdb *redis.Client, jwtSecret string) gin.HandlerFunc {
    return func(c *gin.Context) {
        // 从 Authorization header 提取 Token
        authHeader := c.GetHeader("Authorization")
        if authHeader == "" {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "缺少认证信息"})
            c.Abort()
            return
        }

        parts := strings.SplitN(authHeader, " ", 2)
        if len(parts) != 2 || parts[0] != "Bearer" {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "认证格式错误"})
            c.Abort()
            return
        }
        tokenStr := parts[1]

        // 解析 JWT
        token, err := jwt.Parse(tokenStr, func(t *jwt.Token) (interface{}, error) {
            if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
                return nil, fmt.Errorf("签名算法不匹配")
            }
            return []byte(jwtSecret), nil
        })
        if err != nil || !token.Valid {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "Token 无效"})
            c.Abort()
            return
        }

        // 从 JWT 提取 user_id，查 Redis 验证
        claims, ok := token.Claims.(jwt.MapClaims)
        if !ok {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "Token 解析失败"})
            c.Abort()
            return
        }

        userID, _ := claims["user_id"].(float64)
        ctx := context.Background()
        key := fmt.Sprintf("token:%d", int(userID))

        val, err := rdb.Get(ctx, key).Result()
        if err != nil || val != tokenStr {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "Token 已失效"})
            c.Abort()
            return
        }

        // 将用户信息写入上下文，后续 Handler 可用
        c.Set("user_id", uint(userID))
        c.Set("username", claims["username"])
        c.Next()
    }
}

中间件的验证链条：取 Token → 解析 JWT → 校验签名算法 → 查 Redis 比对 Token 值 → 放行并注入上下文。任何一环失败都会返回 401。

片段 4：启动入口（main.go）

子 Agent 8 号执行 Task 8，组装所有依赖并启动服务：

🤖 Claude Code：Subagent-8 开始执行 Task 8: 启动入口

规范合规审查：依赖注入完整，MySQL/Redis 连接均通过参数传递 代码质量审查：添加了 defer 关闭数据库连接，端口可配置

// main.go
package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "go-api-server/config"
    "go-api-server/handler"
    "go-api-server/model"
    "go-api-server/repository"
    "go-api-server/router"
    "go-api-server/service"

    "github.com/redis/go-redis/v9"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

func main() {
    // 加载环境变量配置
    cfg := config.Load()

    // 连接 MySQL
    db, err := gorm.Open(mysql.Open(cfg.DBDSN), &gorm.Config{})
    if err != nil {
        log.Fatalf("连接 MySQL 失败: %v", err)
    }
    sqlDB, _ := db.DB()
    defer sqlDB.Close()

    // 自动迁移建表
    if err := db.AutoMigrate(&model.User{}); err != nil {
        log.Fatalf("自动迁移失败: %v", err)
    }

    // 连接 Redis
    rdb := redis.NewClient(&redis.Options{
        Addr:     cfg.RedisAddr,
        Password: cfg.RedisPassword,
        DB:       0,
    })
    if err := rdb.Ping(context.Background()).Err(); err != nil {
        log.Fatalf("连接 Redis 失败: %v", err)
    }
    defer rdb.Close()

    // 组装依赖：Repository → Service → Handler
    userRepo := repository.NewUserRepository(db)
    userSvc := service.NewUserService(userRepo, rdb, cfg.JWTSecret)
    userHandler := handler.NewUserHandler(userSvc)

    // 注册路由
    r := router.SetupRouter(userHandler, rdb, cfg.JWTSecret)

    // 启动服务
    addr := fmt.Sprintf(":%s", cfg.Port)
    log.Printf("服务启动在 %s", addr)
    if err := r.Run(addr); err != nil {
        log.Fatalf("服务启动失败: %v", err)
    }
}

// config/config.go
package config

import "os"

type Config struct {
    DBDSN         string
    RedisAddr     string
    RedisPassword string
    JWTSecret     string
    Port          string
}

func Load() *Config {
    return &Config{
        DBDSN:         getEnv("DB_DSN", "root:123456@tcp(127.0.0.1:3306)/go_api?charset=utf8mb4&parseTime=True"),
        RedisAddr:     getEnv("REDIS_ADDR", "localhost:6379"),
        RedisPassword: getEnv("REDIS_PASSWORD", ""),
        JWTSecret:     getEnv("JWT_SECRET", "my-secret-key"),
        Port:          getEnv("PORT", "8080"),
    }
}

func getEnv(key, fallback string) string {
    if v := os.Getenv(key); v != "" {
        return v
    }
    return fallback
}

main.go 的组装逻辑非常清晰：加载配置 → 连接 MySQL → 连接 Redis → 按依赖层次逐层组装 → 注册路由 → 启动服务。没有任何全局状态，所有依赖通过参数传递。

代码审查阶段

9 个 Task 全部执行完毕后，Superpowers 自动进入阶段 5——Requesting Code Review。

🤖 Claude Code：所有 9 个任务执行完毕。正在发起代码审查……

审查结果：

• • 规范合规：所有代码符合头脑风暴阶段确认的架构设计
• • 代码质量：错误处理完整，依赖注入干净，无全局变量
• • 潜在问题：context 包在 service/user.go 中缺少导入

AI 自动修复了缺失的 import，然后进入下一阶段。

验证与调试

计划已写完，代码也已生成。但 Superpowers 的铁律是：没有跑验证命令，就不能说“完成了”。

编译验证

$ go build -o bin/server ./...
# 输出：编译成功，无错误

接口测试

服务启动后，用 curl 逐个测试三个接口。

测试 1：用户注册

$ curl -s -X POST http://localhost:8080/api/register \
  -H "Content-Type: application/json" \
  -d '{"username":"zhangsan","password":"abc123"}' | jq .

{
  "message": "注册成功"
}

测试 2：用户登录

$ curl -s -X POST http://localhost:8080/api/login \
  -H "Content-Type: application/json" \
  -d '{"username":"zhangsan","password":"abc123"}' | jq .

{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
}

测试 3：鉴权接口

$ TOKEN="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
$ curl -s http://localhost:8080/api/echo \
  -H "Authorization: Bearer $TOKEN" | jq .

{
  "message": "认证成功",
  "user_id": 1,
  "username": "zhangsan"
}

三个接口全部通过。

遇到的问题：GORM json tag vs gorm tag

测试过程中发现一个问题：注册接口返回成功，但数据库中 username 字段却是空的。

👤 我：注册成功了但数据库里 username 是空的，帮我查一下。

Claude Code 触发 systematic-debugging 技能，按步骤排查：

🤖 Claude Code：使用 systematic-debugging 排查……

第一步：确认现象——注册返回成功，MySQL 中有记录，但 username 为空。

第二步：检查数据模型——发现问题：

// model/user.go - 有问题的版本
type User struct {
    ID       uint   `json:"id" gorm:"primarykey"`
    Username string `json:"username"`  // 缺少 gorm tag!
    Password string `json:"password"`
}

根因：GORM 默认使用字段名的蛇形映射（Username → username），但如果结构体标签只写了 json 而没有 gorm，在某些 GORM 版本下映射可能不一致。应显式指定 gorm column。

修复：

// model/user.go - 修复后的版本
type User struct {
    ID        uint   `json:"id" gorm:"primarykey"`
    Username  string `json:"username" gorm:"column:username;uniqueIndex;size:64;not null"`
    Password  string `json:"-" gorm:"column:password;size:128;not null"`
    CreatedAt int64  `json:"created_at" gorm:"autoCreateTime"`
    UpdatedAt int64  `json:"updated_at" gorm:"autoUpdateTime"`
}

🤖 Claude Code：修复说明：

1. 每个字段显式指定 gorm:"column:xxx" 确保列名映射准确
2. Password 的 json tag 改为 "-" 防止序列化时泄露密码
3. 时间字段改用 int64 类型存储 Unix 时间戳，兼容性更好

🤖 Claude Code：请重新编译测试。

修复后重新测试，注册接口正常写入数据。

这就是 systematic-debugging 的标准流程：先确认现象 → 定位根因 → 最小修复 → 验证结果。不靠猜测，不搞 try-catch-all，而是像侦探一样逐步追踪。

最终成果

完整项目结构

go-api-server/
├── main.go                  # 启动入口
├── config/
│   └── config.go            # 环境变量配置
├── model/
│   └── user.go              # 用户数据模型
├── repository/
│   └── user.go              # 用户数据库操作
├── service/
│   └── user.go              # 用户业务逻辑
├── handler/
│   └── user.go              # HTTP 请求处理
├── middleware/
│   └── auth.go              # JWT 认证中间件
├── router/
│   └── router.go            # 路由注册
├── go.mod
└── go.sum

9 个文件，总计约 400 行代码，覆盖注册、登录、鉴权三个核心接口，毫无冗余。

Superpowers 七阶段映射

总计约 26 分钟，从零到可运行的 API 服务。

用时对比

若手动搭建同等规格的脚手架：搭项目结构约 30 分钟，写 CRUD 代码约 60 分钟，调试约 30 分钟，合计约 2 小时。借助 Superpowers 工作流，时间缩短至原来的 1/5。

更关键的是——代码质量未降反升。每个 Task 都经历两轮审查，相比手工编码更容易发现潜在问题。

进阶技巧

在 CLAUDE.md 中预设 Go 项目规范

在项目根目录的 CLAUDE.md 中添加 Go 相关规范，让 Claude Code 后续开发自动遵循：

## Go 项目规范

- 使用标准项目布局：cmd/, internal/, pkg/
- 错误处理用 fmt.Errorf + %w 包装，不用 panic
- 所有数据库操作通过 Repository 层，Handler 不直接访问 DB
- API 响应统一格式：{"code": 0, "message": "", "data": {}}
- 变量命名用驼峰，常量用全大写下划线

Superpowers scaffold skill

如果经常搭建新项目，可以把脚手架流程封装成一个 Superpowers Skill：

# 触发自定义 scaffold skill
/superpowers:scaffold go-api

# AI 自动执行：头脑风暴 → 生成计划 → 代码编写 → 编译验证

一次配置，反复复用。

GLM 5.1 与 Claude Code 的分工

在这个实战中，GLM 5.1 作为 Coding Plan Provider 负责：

• • 生成 CRUD 代码（Repository 层、Handler 层的参数绑定）
• • 编写配置加载等模板代码

Claude Code 负责：

• • 架构设计和决策（分层策略、依赖注入方式）
• • 代码审查（发现 gorm tag 映射问题）
• • 调试（systematic-debugging 排查问题）

这个分工的核心逻辑：让 AI 做它最擅长的事——GLM 5.1 写标准代码，Claude Code 做创造性工作。

常见问题

Q1：没有 MySQL 怎么跟练？

一行命令启动 MySQL 容器：

docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root mysql:8.0

Q2：GLM 5.1 和 Claude 原生模型有什么区别？

GLM 5.1 是智谱提供的 Coding Plan Provider，国内直连、无需翻墙。在 Claude Code 中配置 GLM 5.1 作为编码执行者，Claude Code 负责架构设计与代码审查，两者分工协作。

Q3：Superpowers 是免费的吗？

Superpowers 是开源项目，一行命令安装：

claude plugins install superpowers

Q4：我不懂 Go 能跟练吗？

可以。本文的核心是演示 Superpowers 工作流的完整流程，代码由 AI 生成，你只需理解每个阶段在做什么即可。

延伸阅读

• • 本系列第 16 篇《Superpowers 工作流》——七阶段工作流完整理论
• • 本系列第 13 篇《Claude Code 最新功能速递》——GLM 5.1 Coding Plan 配置
• • Gin 框架官方文档[1]
• • GORM 官方文档[2]
• • Superpowers 项目 GitHub[3]

下一步

搭完脚手架，接下来可以：

1. 用 Superpowers 添加业务模块（文章、评论、收藏等）
2. 集成 Swagger 自动生成 API 文档
3. 添加 Docker Compose 一键部署
4. 接入 CI/CD 流水线

每一步都可以触发 /superpowers:brainstorming，让 AI 先帮你理清思路再动手。

引用链接

[1] Gin 框架官方文档: https://gin-gonic.com/docs/ [2] GORM 官方文档: https://gorm.io/docs/ [3] Superpowers 项目 GitHub: https://github.com/anthropics/superpowers