告别AI生成的"玩具代码"：Samber Go 技能库实战指南

上个月，我让 AI 用 Go 写一个订单服务。生成只花了 4 分钟，但我接下来做了 40 分钟的事：把 panic 改成 error、把 utils 包拆掉、给 handler 补上 context、再补几个表驱动测试。

那一刻我彻底明白一件事：大模型不是不会写 Go，它只是没人告诉它，“生产级的 Go 代码”到底长什么样。

用 AI 写 Go 的人，大多都陷过“速度陷阱”：生成代码 5 分钟，改规范、补错误、调结构却要花半小时。问题从来不是模型不行，而是没人把 Go 社区沉淀了十年的工程共识喂给它。

这个库叫 samber/cc-skills-golang，它干的就是这件事：把 Go 的工程化经验，封装成 4 大模块、28 项 Skill，让 AI 可以直接加载执行。本文会带你把这 28 项拆开揉碎，覆盖从第一行代码到项目上线的全流程。

先上结论：别贪多，先开这 8 条
能力金字塔：4 大模块 28 项 Skill 全景
代码质量：AI 输出的第一道安全网（8 项）
架构与设计：决定项目能长多大（8 项）
质量保障与性能：守住上线后的稳定性（5 项）
项目脚手架与工具链：从第一天走正确的轨道（7 项）
落地路线：两步启用，性价比最高
结尾：规则，才是 AI 编程的护城河

一、先上结论：别贪多，先开这 8 条

如果你不想一次给 AI 灌 28 条规则，按“先止血，再健身”的顺序来，性价比最高。

第一阶段：基础必开（立刻消灭 80% 低级问题）

golang-error-handling：所有返回 error 的函数都启用

golang-naming：所有标识符命名统一

golang-testing：所有测试文件启用

golang-code-style：所有代码格式化统一

第二阶段：架构进阶（涉及跨层调用、并发、类型设计、新项目时追加）

golang-context：所有跨层调用启用

golang-concurrency：所有并发逻辑启用

golang-structs-interfaces：所有类型定义启用

golang-project-layout：新项目初始化启用

这 8 条不是拍脑袋选的。它们覆盖了 Go 工程化里最高频、最容易返工的部分。开完第一阶段，AI 输出的代码质量立刻上一个台阶；再补第二阶段，项目才真正具备“能长大”的底子。

下面按模块，把全部 28 项拆给你看。

二、能力金字塔：4 大模块 28 项 Skill 全景

在深入细节前，先建立整体认知。四组模块构成了 AI 生成 Go 代码的「能力金字塔」：

模块	Skill 数	解决什么	对 AI 输出的意义
代码质量 Code Quality	8	代码写得对不对、地道不地道	AI 输出的第一道安全网
架构与设计 Architecture & Design	8	项目做得好不好、能不能长大	决定代码的可维护上限
质量保障与性能 QA & Performance	5	服务稳不稳、快不快	守住上线后的稳定性底线
项目脚手架与工具链 Project Setup	7	工程齐不齐、顺不顺	从第一天就走正确的轨道

合计：28 项核心 Skill。

samber/cc-skills-golang 的核心价值，就是把 Go 社区十年踩坑经验，封装成一条条 AI 能直接加载执行的编码指令。它不会让大模型无所不能，但能让 AI 的输出，从“能跑的代码”变成“符合生产标准的工程交付”。

三、代码质量：AI 输出的第一道安全网（8 项）

模块定位：这是所有 Go 代码的「准入门槛」。没有这层约束，AI 很容易写出“能跑但充满反模式”的代码。8 项 Skill 从风格、文档、错误、静态检查、命名、运行安全、安全编码、结构体接口八个维度，给 AI 套上第一层工程枷锁。

1. golang-code-style：统一代码风格，先消灭无意义 diff

使用时机：生成新代码、Code Review、批量格式化存量代码。

AI 生成代码最常见的无意义内耗，就是风格混乱：缩进不统一、import 顺序杂乱，团队协作时 diff 里一半都是格式变化。这条 Skill 把 Go 社区风格标准固化为强制规则：

格式化强制：所有代码必须通过 gofmt 校验，不保留任何自定义排版
导入分组：goimports 自动按“标准库 → 第三方库 → 内部库”分组，空行分隔
Lint 对齐：遵循 golangci-lint 默认规则集的基础风格要求
注释规范：所有导出标识符必须带文档注释，禁止无意义废话注释
团队扩展：支持企业内部自定义规范覆盖社区默认规则

核心价值：消除 90% 无意义的格式差异，让代码 diff 只聚焦业务逻辑变化，团队风格高度统一。

2. golang-documentation：让代码自己会说话

使用时机：编写公共包、SDK、对外 API、项目 README。

AI 写注释经常走两个极端：要么冗余啰嗦，要么关键导出函数根本没注释，导致 godoc 生成不出有效文档，README 也找不到重点。这条 Skill 定义了完整规范：

包级文档：每个包必须有 package doc 注释，一句话说明核心职责
Godoc 约定：导出标识符的注释必须以标识符名称开头，符合官方工具解析规则
文档测试：Example 前缀的示例函数，既是使用示例，又是自动化测试
README 标准结构：项目概述 → 快速安装 → 使用示例 → 贡献指南
工具兼容：原生兼容 go doc、swaggo 等自动文档生成工具

核心价值：代码即文档，自动生成高质量的包文档和 API 参考，大幅降低团队沟通成本。

3. golang-error-handling：生产级错误处理规范（最高频核心 Skill）

使用时机：任何返回 error 的业务函数，生产项目强制启用。

错误处理是 AI 写 Go 代码的头号重灾区：业务异常直接 panic、只返回字符串丢失原始错误、没有哨兵错误导致上层无法分类、错误包装混乱不可追溯。这条 Skill 输出了社区公认的标准范式：

环节	标准做法
错误创建	优先 `fmt.Errorf` / `errors.New`，业务异常预定义哨兵错误变量
错误包装	用 `%w` 包装原始错误，保留完整调用链路，不丢失堆栈
错误判定	`errors.Is` 匹配哨兵错误，`errors.As` 提取自定义错误类型
自定义错误	实现 `Unwrap()` 和 `Is()` 方法，支持错误链穿透判断
panic 原则	仅程序启动初始化失败时使用，业务逻辑绝对禁止 `panic`
错误码体系	业务层定义清晰错误码，便于上游服务和监控系统识别

✅ 标准生产写法示例

// 预定义哨兵错误
var ErrUserNotFound = errors.New("user not found")

func GetUser(ctx context.Context, id string) (*User, error) {
    u, err := db.QueryUser(ctx, id)
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            // 包装原始错误，附加业务上下文
            return nil, fmt.Errorf("get user %s: %w", id, ErrUserNotFound)
        }
        return nil, fmt.Errorf("query user %s: %w", id, err)
    }
    return u, nil
}

核心价值：错误可追溯、可分类、可度量。业务层能精准处理不同异常，监控能按错误码聚合告警。

4. golang-lint：把静态检查变成 CI 门禁

使用时机：配置 CI 流水线、批量修复存量代码问题、统一团队检查标准。

AI 生成的代码经常触发大量 lint 告警，团队规则不统一、本地和 CI 结果不一致更是常态。这条 Skill 提供工程化方案：

提供 golangci-lint 标准化配置模板，覆盖社区公认规则集
按项目场景按需启用/禁用特定 linter，避免过度检查干扰开发
GitHub Actions / GitLab CI 一键接入 lint 门禁，不合格代码无法合并
规范 //nolint 内联抑制的使用场景和写法，禁止滥用跳过检查
建立错误、警告、建议三级告警分级处理策略

核心价值：把静态检查变成标准化流程，本地和 CI 结果一致，提前发现代码缺陷。

5. golang-naming：命名即文档

使用时机：定义包名、结构体、变量、函数、常量、自定义错误等所有标识符。

AI 训练数据来源混杂，命名经常混乱：一会儿蛇形一会儿驼峰，包名起成 utils、helpers 这种语义模糊的名称，接口命名冗长不堪。这条 Skill 严格执行 Go 社区命名约定：

整体风格：统一 MixedCaps（驼峰命名），禁止 snake_case 蛇形命名
包名：全小写、简短、语义明确，禁止下划线和中文拼音
构造函数：统一 NewXxx() 命名模式
接口命名：优先使用 -er 后缀，用行为命名而非功能集合
错误命名：统一 Err 前缀命名哨兵错误
反模式黑名单：禁止 utils、helpers、common、base 等语义模糊的包名

✅ 命名正反示例对照表

场景	✅ 推荐写法	❌ 不推荐写法
包名	`user`、`order`	`user_utils`、`common_helper`
接口	`Reader`、`Formatter`	`UserServiceInterface`
哨兵错误	`ErrNotFound`、`ErrInvalidParam`	`NotFoundError`、`error1`
常量	`MaxRetryCount`	`MAX_RETRY_COUNT`、`max_retry`

核心价值：看到名字就知道用途，团队代码可读性大幅提升。

6. golang-safety：防御式编程，少写 panic

使用时机：开发线上高可用服务，规避运行时 panic 和数据异常。

AI 写代码经常忽略边界检查：空切片直接索引、nil map 直接赋值、并发读写 map 不加锁，代码一上线就频繁 panic。这条 Skill 相当于给 AI 加上“安全护栏”：

nil 安全：访问 slice、map、channel 前先检查长度和 nil 状态
Slice 陷阱：注意 append 底层数组共享问题，避免意外修改原切片
Map 并发：读写场景用 sync.RWMutex，纯并发写入用 sync.Map
浮点数：禁止直接用 == 比较，使用差值小于 epsilon 的方式判断
零值设计：利用结构体零值作为合法默认状态，避免多余初始化
数值溢出：关键计算路径做数值溢出校验

✅ 典型场景正反例

// ✅ 安全写法：先检查长度再访问
func GetFirstItem(s []string) string {
    if len(s) == 0 {
        return ""
    }
    return s[0]
}

// ❌ 风险写法：空切片直接索引会触发 panic
func GetFirstItem(s []string) string {
    return s[0]
}

核心价值：消除 80% 以上的运行时 panic，大幅提升服务稳定性。

7. golang-security：从编码层堵住 OWASP Top 10

使用时机：处理外部用户输入、数据库操作、加密逻辑、文件读写场景。

AI 处理外部输入时很容易引入安全漏洞：SQL 拼接、命令注入、XSS、密钥硬编码都是高发问题。这条 Skill 从编码层面堵住风险：

数据库：全部使用参数化查询，绝对禁止字符串拼接 SQL
命令执行：使用 exec.Command 参数传入方式，禁止 Shell 拼接执行
输出转义：HTML 输出自动转义，防御 XSS 攻击
加密实践：使用标准库 crypto 包，禁止自研加密算法
文件安全：路径清洗，防止目录穿越攻击
密钥管理：从环境变量或密钥服务读取，禁止硬编码在代码中
Cookie 安全：设置 HttpOnly、Secure、SameSite 属性

核心价值：从编码层面堵住常见安全漏洞，降低线上安全风险。

8. golang-structs-interfaces：小接口，组合优先

使用时机：领域模型定义、组件抽象、依赖解耦场景。

AI 很容易写出臃肿的大接口，一个接口十几个方法，难以实现、难以测试，完全违背 Go 的设计哲学。这条 Skill 反复强调 Go 的核心原则：

组合优于继承：通过结构体嵌入实现能力复用，不使用类型继承
接口隔离原则：定义小而精的接口，一个接口 1~2 个方法
类型断言：安全的类型断言写法，必须判断 ok 返回值
标签规范：JSON、YAML、数据库标签的标准写法和命名约定
接收器选择：不需要修改状态用值接收器，需要修改状态用指针接收器

✅ 接口设计正反例

// ✅ 推荐：小接口，仅定义必要行为，易实现易测试
type Stringer interface {
    String() string
}

// ❌ 不推荐：臃肿大接口，难以实现和 mock
type UserService interface {
    GetUser(id string) (*User, error)
    CreateUser(u *User) error
    UpdateUser(u *User) error
    DeleteUser(id string) error
    ListUser(page int) ([]User, int, error)
}

核心价值：代码解耦性好，可测试性强，完全符合 Go 的设计哲学。

四、架构与设计：决定项目能长多大（8 项）

如果说代码质量是“写得对”，那架构设计就是“做得好”。这 8 项 Skill 决定了项目做大之后，会不会变成难以维护的“屎山”。它们不纠结单行代码，而是从并发模型、依赖管理、设计模式等维度，定义 Go 应用的架构范式。

1. golang-concurrency：别再无脑 go

使用时机：异步任务、批量处理、高性能服务开发场景。

Go 的核心优势是并发，但 AI 写并发最容易出问题：无脑 go 关键字、无限开 goroutine、没有同步机制、竞态条件满天飞，一压测服务就雪崩。这条 Skill 直接输出社区验证过的成熟并发模式：

基础模型：goroutine + channel 通信模型，优先用 channel 传递数据而非共享内存
同步原语：正确使用 Mutex、RWMutex、WaitGroup、Once、Cond
Worker Pool 模式：固定协程池处理任务队列，限制并发数，防止资源耗尽
Fan-out/Fan-in：多生产者、多消费者的分发聚合模式
Pipeline 模式：流式数据处理，分阶段链式执行
取消机制：通过 context 传递取消信号，及时释放 goroutine

✅ 标准 Worker Pool 实现示例

func ProcessJobs(jobs <-chan Job, workerNum int) {
    var wg sync.WaitGroup
    wg.Add(workerNum)
    for i := 0; i < workerNum; i++ {
        go func(id int) {
            defer wg.Done()
            for job := range jobs {
                if err := handleJob(job); err != nil {
                    log.Printf("worker %d error: %v", id, err)
                }
            }
        }(i)
    }
    wg.Wait()
}

核心价值：并发逻辑稳定可控，不会出现 goroutine 泄漏和服务雪崩。

2. golang-context：全链路超时与取消

使用时机：所有跨函数、跨服务调用链路。

AI 经常把 context 存进结构体，或者跨层调用不传 ctx，导致超时、取消机制全线失效——请求取消了，后端还在跑，资源泄漏严重。这条 Skill 明确了几条铁则：

根节点：使用 context.Background() 作为程序根上下文
生命周期控制：WithCancel、WithTimeout、WithDeadline 管理上下文生命周期
值传递规范：WithValue 仅传递链路元数据（trace_id、user_id），禁止传递业务参数
透传原则：跨函数、跨服务必须逐层传递 ctx，作为函数第一个参数
红线禁令：绝对禁止把 context 保存到结构体字段中

核心价值：全链路超时可控，取消信号可透传，资源及时释放。

3. golang-data-structures：别什么场景都只用 slice + map

使用时机：业务集合存储、性能优化前期选型。

AI 不管什么场景都用 slice 和 map，不会根据场景选择合适的数据结构，性能差还有并发安全隐患。这条 Skill 讲透常用数据结构的特性和选型：

Slice：理解容量增长策略（2 倍扩容），预分配容量提升性能
Map：哈希表实现特性，读写复杂度，并发安全约束
Channel：无缓冲/有缓冲的适用场景，作为通信管道而非数据存储
Sync 原语：不同并发场景下 Mutex、RWMutex、Map、Once 的选型
重点提示：append 底层数组共享的副作用

核心价值：根据场景选对数据结构，性能和并发安全都有保障。

4. golang-database：数据库访问标准范式

使用时机：所有数据库持久层代码。

AI 写数据库代码容易踩坑：SQL 拼接注入风险、连接池不配置导致连接耗尽、事务使用混乱。这条 Skill 定义了标准范式：

注入防护：全部使用 $1、? 占位符的参数化查询
连接池配置：SetMaxOpenConns、SetMaxIdleConns、SetConnMaxLifetime 三件套
事务规范：Begin → Commit/Rollback 标准流程，defer 兜底回滚
迁移方案：使用 golang-migrate 等标准化数据库迁移工具
代码生成：sqlc、sqlboiler 生成类型安全的数据库代码

核心价值：数据库访问安全、高效、可维护，避免常见数据库坑。

5. golang-dependency-injection：别在构造函数里直接 new 依赖

使用时机：中大型项目组件解耦场景。

AI 喜欢在构造函数里直接 new 依赖，把实现写死，导致无法替换、单元测试只能跑集成环境，没法 mock。这条 Skill 推广 Go 原生的依赖注入理念：

Go 原生风格：构造函数注入优先，依赖通过参数传入
接口注入：面向接口编程，实现依赖倒置
三大 DI 方案对比：
- Google Wire：编译期 DI，零运行时开销，适合大多数项目
- Uber Dig：运行时反射 DI，灵活性高，适合动态插件场景
- Uber Fx：完整应用生命周期管理，适合大型应用
引入阈值：项目复杂度达到一定程度再引入 DI，避免过度设计

✅ 构造函数注入正反例

// ✅ 推荐：依赖通过构造函数传入，外部可控，易测试
type UserHandler struct {
    repo UserRepository
}

func NewUserHandler(repo UserRepository) *UserHandler {
    return &UserHandler{repo: repo}
}

// ❌ 不推荐：内部硬编码依赖，无法替换，难以单测
type UserHandler struct{}

func NewUserHandler() *UserHandler {
    return &UserHandler{
        repo: NewMySQLUserRepo(), // 写死实现
    }
}

核心价值：组件解耦，易测试、易替换、易扩展。

6. golang-design-patterns：用 Go 的方式，而不是 Java 的

使用时机：公共组件、SDK、中间件封装场景。

AI 很容易生搬硬套 Java 的 23 种设计模式，写出来的代码不伦不类，不符合 Go 的语言哲学。这条 Skill 输出 Go 原生的惯用设计模式：

函数式选项（Functional Options）：配置类对象的标准写法，支持可选参数、向后兼容
建造者模式：复杂对象的逐步构建
中间件链：HTTP/gRPC 横切关注点的链式处理
熔断器模式：防止服务级联故障
所有模式都附带 Go 风格的代码实现和文件结构示例

✅ 函数式选项模式标准实现

type Server struct {
    host    string
    port    int
    timeout time.Duration
}

type Option func(*Server)

func WithHost(host string) Option {
    return func(s *Server) { s.host = host }
}

func WithTimeout(d time.Duration) Option {
    return func(s *Server) { s.timeout = d }
}

func NewServer(port int, opts ...Option) *Server {
    s := &Server{
        host:    "0.0.0.0",
        port:    port,
        timeout: 30 * time.Second, // 默认值
    }
    for _, opt := range opts {
        opt(s)
    }
    return s
}

// 使用：只传需要修改的配置
s := NewServer(8080, WithHost("localhost"), WithTimeout(10*time.Second))

核心价值：用 Go 的方式解决设计问题，代码简洁地道，可扩展性强。

7. golang-modernize：让代码跟上 Go 1.21+

使用时机：老项目迁移至 Go 新版本。

AI 训练数据滞后，经常还在用老版本写法，比如老式计数循环，不用新标准库，代码过时冗余。这条 Skill 推动代码跟上语言迭代：

循环升级：for i := range n 替代传统计数循环
内置函数：使用内置 min()、max()，不用自己实现
新标准库：slices、maps、cmp、slog 等标准库优先使用
迭代器模式：iter.Seq 迭代器新语法
测试新特性：t.Context()、b.Loop()、synctest
工具升级：gofmt -r 代码重写，批量升级到新语法

核心价值：跟上 Go 版本迭代，使用新特性提升代码简洁度和性能。

8. golang-refactoring：安全重构，不越改越乱

使用时机：存量业务大规模代码重构场景。

AI 重构代码很容易改出 bug，破坏原有行为，引入 import 循环。这条 Skill 定义了安全重构的完整流程：

安全网：重构前保证测试覆盖率，作为行为验证基础
工具驱动：使用 gopls 的 Rename/Inline/Extract、gofmt -r、gopatch 等自动化重构工具
重构目录：Fowler 经典重构模式映射到 Go 语言的具体实现
导入循环：识别和打破 import 循环的方法
渐进式重构：类型别名等渐进式重构手段，小步快跑
工作流：重构分支 + 分阶段 PR + 人工审核的流程

核心价值：大规模重构也能保证行为一致性，不会越改越乱。

五、质量保障与性能：守住上线后的稳定性（5 项）

代码能跑、能迭代还不够，还要能稳定跑、跑得快。这 5 项 Skill 负责线上服务的质量底线和性能表现，让 AI 生成的代码不仅能跑，还能跑好。

1. golang-testing：生产级测试体系（高频核心 Skill）

使用时机：编写单元测试、集成测试场景。

AI 写测试通常只会写一条正常路径，覆盖不全，也不会用 Go 的测试特性，测试完全是摆设。这条 Skill 输出生产级测试的标准范式：

表驱动测试：用表格批量覆盖正常、边界、异常场景
模糊测试：go test -fuzz 挖掘边界异常
协程泄漏检测：goleak 检测测试后未回收的 goroutine
快照测试：比对输出与预期快照
代码覆盖率：go test -cover 统计覆盖率阈值
并行测试：t.Parallel() 加速测试执行

✅ 标准表驱动测试示例

func TestCalculateDiscount(t *testing.T) {
    cases := []struct {
        name     string
        price    float64
        discount float64
        expect   float64
        wantErr  bool
    }{
        {"正常折扣", 100.0, 0.1, 90.0, false},
        {"零价格", 0, 0.1, 0, false},
        {"折扣超限", 100, 1.5, 0, true},
    }

    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            res, err := CalculateDiscount(tc.price, tc.discount)
            if tc.wantErr {
                require.Error(t, err)
                return
            }
            require.NoError(t, err)
            assert.Equal(t, tc.expect, res)
        })
    }
}

核心价值：测试覆盖全面，能有效发现 bug，回归测试效率高。

2. golang-benchmark：别猜性能，去测

使用时机：需要测量和优化代码性能时。

AI 优化性能全靠猜，不会写基准测试，没有数据支撑。这条 Skill 建立了完整的性能度量体系：

基准测试：go test -bench 标准写法，避免编译器优化干扰
pprof 剖析：CPU、内存、goroutine、阻塞四种 profile
trace 追踪：执行链路可视化，还原运行全过程
火焰图：可视化性能瓶颈，一眼找到热点
benchstat：多版本基准测试结果对比，统计显著性
持续剖析：生产环境的性能采集方案

核心价值：性能优化有数据支撑，精准定位瓶颈，不是瞎优化。

3. golang-observability：线上出问题，别再只会 fmt.Println

使用时机：构建需要监控、告警、追踪的生产服务时。

AI 写代码默认只会 fmt.Println 打日志，没有结构化日志，没有指标，没有链路追踪，线上出问题根本没法查。这条 Skill 搭建了完整的可观测性框架：

结构化日志：slog 标准库或 zap/zerolog，统一 JSON 格式
Prometheus 指标：Counter、Gauge、Histogram、Summary 四种核心指标类型
OpenTelemetry 追踪：分布式链路追踪标准
告警体系：基于指标的告警规则设计
Grafana 大盘：可视化监控面板

✅ 结构化日志输出示例

{
  "time": "2026-09-08T10:00:00Z",
  "level": "error",
  "msg": "failed to query user",
  "user_id": "123",
  "trace_id": "abc123",
  "error": "sql: no rows in result set",
  "duration_ms": 12
}

核心价值：线上问题可排查，性能可监控，服务可观测。

4. golang-performance：可落地的性能优化手段

使用时机：需要减少内存分配、提升 CPU 效率、优化热路径时。

AI 说优化只会喊“减少分配”，没有具体可落地的手段。这条 Skill 给出了 Go 里可验证的性能优化方法：

对象复用：sync.Pool 复用高频对象，减少 GC 压力
CPU 优化：避免不必要的接口断言、反射，减少堆逃逸
内存布局：结构体字段排序优化内存对齐，减少填充
GC 调优：GOGC、GOMEMLIMIT 参数调整
缓存策略：热点数据缓存，预计算
热路径优化：识别并优化最频繁执行的代码路径

✅ sync.Pool 对象复用示例

var bufPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func HandleRequest() {
    buf := bufPool.Get().(*bytes.Buffer)
    defer bufPool.Put(buf) // 用完归还
    buf.Reset()

    // 使用 buf 处理业务，减少内存分配与 GC 压力
}

核心价值：性能优化有明确手段，可落地可验证。

5. golang-troubleshooting：系统化排查，而不是泛泛建议

使用时机：定位和解决运行时 bug 时。

线上出问题，AI 只会给泛泛建议，没有系统化排查流程。这条 Skill 输出了 Go 专属的故障排查体系：

常见陷阱速查：Go 最容易踩坑的地方，快速定位
测试驱动排查：用测试复现问题再修复
pprof 捕获：运行时性能问题定位
Delve 调试：断点、单步、变量查看
竞态检测：go test -race 检测竞态条件
GODEBUG 开关：环境变量控制运行时行为，辅助排查

核心价值：线上故障有系统化的排查流程，缩短故障恢复时间。

六、项目脚手架与工具链：从第一天走正确的轨道（7 项）

新项目冷启动或者老项目整改时，不用自己摸索最佳实践，直接对齐社区标准。这 7 项 Skill 覆盖从项目结构到 CI 流水线的全套工程化配置，避免从零踩坑。

1. golang-project-layout：标准目录，职责分明

使用时机：创建新项目或重构现有项目结构时。

AI 新建项目经常文件夹乱建，业务代码、库代码、入口混在一起，越到后面越乱。这条 Skill 直接给出 Go 社区公认的标准布局：

cmd/：应用入口，每个子目录对应一个可执行程序
internal/：内部私有包，外部不可导入
pkg/：对外公开的库代码
同时覆盖单体仓库、CLI 项目的不同布局方案

✅ 标准项目目录示例

project/
├── cmd/
│   └── api/          # 应用入口
│       └── main.go
├── internal/         # 私有包，外部不可导入
│   ├── user/
│   └── order/
├── pkg/              # 公共可导出库
│   └── model/
├── go.mod
└── README.md

核心价值：项目结构清晰，职责分明，团队新人上手快。

2. golang-cli：命令行工具也要专业

使用时机：构建命令行工具时。

AI 写命令行工具经常参数解析混乱，退出码不规范，信号处理缺失。这条 Skill 定义了 CLI 开发标准：

项目布局：CLI 工具标准目录结构
退出码：遵循 Unix 规范，0 成功，非 0 失败
信号处理：优雅处理 SIGINT/SIGTERM，实现平滑退出
I/O 模式：标准输入输出、文件操作规范
参数解析：flag、cobra 等方案选型
终端 UX：进度条、颜色输出、交互提示

核心价值：命令行工具专业、规范，用户体验好。

3. golang-continuous-integration：开箱即用的 CI

使用时机：配置 GitHub Actions 自动化流程时。

AI 配 CI 流水线东拼西凑，步骤不全，缓存没配，速度慢。这条 Skill 提供开箱即用的标准流水线：

四步标准流程：构建 → 测试 → Lint → 发布
GitHub Actions 标准模板
依赖缓存：go mod 缓存，提升构建速度
多 Go 版本兼容测试
自动发布：二进制构建、容器镜像推送

核心价值：开箱即用的 CI 流水线，不用自己踩坑配置。

4. golang-dependency-management：依赖版本不再乱

使用时机：管理 go.mod、处理依赖版本时。

AI 处理 go.mod 不规范，版本混乱，replace 指令乱用，团队依赖版本不一致。这条 Skill 统一了依赖管理标准：

go.mod 规范：模块路径、版本号格式
版本管理：语义化版本、伪版本、replace 指令使用规范
工具依赖：toolchain 指令固定 Go 版本
多模块工作区：go.work 管理多模块项目

核心价值：依赖管理标准化，团队版本一致，避免依赖冲突。

5. golang-gopls：别只把 gopls 当补全

使用时机：需要语义级代码智能时。

很多人只用 gopls 做自动补全，不知道还有很多高级功能。这条 Skill 充分挖掘语言服务器的能力：

语义跳转：Go to Definition、Find References
调用层次：Call/Implementation Hierarchy
工作区符号搜索
实时诊断
安全重构：Rename、Extract、Inline 等跨文件重构
MCP 服务器：通过 gopls 自身暴露能力给 AI

核心价值：充分发挥 IDE 能力，提升开发效率和重构安全性。

6. golang-pkg-go-dev：快速评估第三方包

使用时机：需要查看第三方包的文档、API、示例时。

找第三方库不知道哪个靠谱，想查 API 还要翻网页。这条 Skill 打通了官方包生态：

包文档自动提取
API 参考完整列表
符号快速定位
代码示例自动提取
版本信息、导入者统计
许可证、已知漏洞检查

核心价值：快速评估第三方库，不用到处查资料。

7. golang-popular-libraries：只推生产验证过的库

使用时机：需要选择合适的第三方库时。

AI 推荐的库良莠不齐，很多都是玩具项目，不适合生产。这条 Skill 坚持严格的选型原则：

标准库优先原则：能不用第三方就不用
场景匹配：根据需求选择合适的库
生产就绪：只推荐经过生产验证的知名库

核心价值：技术选型不踩坑，用稳定可靠的库。

七、落地路线：两步启用，性价比最高

不用一下子把 28 条全用上。一次性塞太多规则，上下文爆了，重点反而被稀释。按下面两步走，投入产出比最高。

第一步：基础必开（4 条）

golang-error-handling：所有返回 error 的函数都启用
golang-naming：所有标识符命名统一
golang-testing：所有测试文件启用
golang-code-style：所有代码格式化统一

这 4 条一开，AI 输出的代码质量立刻上一个台阶，80% 的低级问题都会消失。

第二步：架构进阶（4 条）

golang-context：所有跨层调用启用
golang-concurrency：所有并发逻辑启用
golang-structs-interfaces：所有类型定义启用
golang-project-layout：新项目初始化启用

等团队真的吃透了这 8 条，再把 lint、security、database、benchmark、CI、依赖管理等按项目阶段逐步补齐。到那时，你会发现 AI 写出来的 Go 代码，终于从“能跑”变成了“敢上线”。

八、结尾：规则，才是 AI 编程的护城河

很多人讨论 AI 能不能取代程序员。

但我看到的现实更具体：用好 AI 的程序员，正在取代不用 AI 的程序员。

而用好 AI 的关键，从来不是换更贵的模型，而是给模型更好的规则和约束。samber/cc-skills-golang 这 28 项核心 Skill，本质上是把 Go 社区十几年踩过的坑、沉淀的经验，变成了 AI 可以直接执行的标准。

它不会让大模型无所不能，但能让 AI 的输出，从「能跑的代码」变成「符合生产标准的工程交付」。

如果你也在用 Cursor、Copilot 写 Go，别再只追求生成速度了。把规则喂给 AI，它才会还你一个能上线的项目。