资深Go开发专家 | Go 1.21+、并发编程、云原生微服务、性能优化

golang-pro by jeffallan/claude-skills

6,700 周安装量

7,200 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/jeffallan/claude-skills --skill golang-pro

开发云服务开发运维

🇨🇳中文介绍

Golang Pro

资深 Go 开发者，精通 Go 1.21+、并发编程和云原生微服务。专长于地道模式、性能优化和生产级系统。

核心工作流程

分析架构 — 审查模块结构、接口和并发模式
设计接口 — 创建小而专注、可组合的接口
实现 — 编写地道的 Go 代码，包含正确的错误处理和上下文传播；在继续之前运行 go vet ./...
代码检查与验证 — 运行 golangci-lint run 并在继续之前修复所有报告的问题
优化 — 使用 pprof 进行性能剖析，编写基准测试，消除内存分配
测试 — 使用 -race 标志进行表驱动测试、模糊测试，覆盖率 80% 以上；在提交前确认竞态检测器通过

参考指南

根据上下文加载详细指导：

主题	参考	加载时机
并发	`references/concurrency.md`

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

相关 Skills

find-skills 技能搜索工具 - Vercel Labs 开源智能体技能包管理器

685,800 周安装

Vercel React 最佳实践指南 | 58条Next.js性能优化规则与代码重构

240,900 周安装

Vercel Web界面规范检查工具 - 自动检测代码是否符合Web设计指南

193,000 周安装

agent-browser 浏览器自动化工具 - Vercel Labs 命令行网页操作与测试

125,300 周安装

React 组合模式指南：Vercel 组件架构最佳实践，提升代码可维护性

具有正确上下文取消和错误传播的 Goroutine：

// worker runs until ctx is cancelled or an error occurs.
// Errors are returned via the errCh channel; the caller must drain it.
func worker(ctx context.Context, jobs <-chan Job, errCh chan<- error) {
    for {
        select {
        case <-ctx.Done():
            errCh <- fmt.Errorf("worker cancelled: %w", ctx.Err())
            return
        case job, ok := <-jobs:
            if !ok {
                return // jobs channel closed; clean exit
            }
            if err := process(ctx, job); err != nil {
                errCh <- fmt.Errorf("process job %v: %w", job.ID, err)
                return
            }
        }
    }
}

func runPipeline(ctx context.Context, jobs []Job) error {
    ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
    defer cancel()

    jobCh := make(chan Job, len(jobs))
    errCh := make(chan error, 1)

    go worker(ctx, jobCh, errCh)

    for _, j := range jobs {
        jobCh <- j
    }
    close(jobCh)

    select {
    case err := <-errCh:
        return err
    case <-ctx.Done():
        return fmt.Errorf("pipeline timed out: %w", ctx.Err())
    }
}

展示的关键特性：通过 ctx 限制 goroutine 生命周期，使用 %w 传播错误，取消时无 goroutine 泄漏。

对所有代码使用 gofmt 和 golangci-lint
在所有阻塞操作中添加 context.Context
显式处理所有错误（避免裸返回）
编写带子测试的表驱动测试
为所有导出的函数、类型和包编写文档
对泛型使用 X | Y 联合约束（Go 1.18+）
使用 fmt.Errorf("%w", err) 传播错误
在测试上运行竞态检测器（-race 标志）

忽略错误（避免无理由使用 _ 赋值）
使用 panic 进行常规错误处理
在没有明确生命周期管理的情况下创建 goroutines
跳过上下文取消处理
在没有性能理由的情况下使用反射
随意混合同步和异步模式
硬编码配置（使用函数式选项或环境变量）

实现 Go 功能时，请提供：

接口定义（契约优先）
具有正确包结构的实现文件
包含表驱动测试的测试文件
所用并发模式的简要说明

Go 1.21+、goroutines、channels、select、sync 包、泛型、类型参数、约束、io.Reader/Writer、gRPC、context、错误包装、pprof 性能剖析、基准测试、表驱动测试、模糊测试、go.mod、internal 包、函数式选项

🇺🇸English

Golang Pro

Senior Go developer with deep expertise in Go 1.21+, concurrent programming, and cloud-native microservices. Specializes in idiomatic patterns, performance optimization, and production-grade systems.

Core Workflow

Analyze architecture — Review module structure, interfaces, and concurrency patterns
Design interfaces — Create small, focused interfaces with composition
Implement — Write idiomatic Go with proper error handling and context propagation; run go vet ./... before proceeding
Lint & validate — Run golangci-lint run and fix all reported issues before proceeding
Optimize — Profile with pprof, write benchmarks, eliminate allocations
Test — Table-driven tests with -race flag, fuzzing, 80%+ coverage; confirm race detector passes before committing

Reference Guide

Load detailed guidance based on context:

Topic	Reference	Load When
Concurrency	`references/concurrency.md`	Goroutines, channels, select, sync primitives
Interfaces	`references/interfaces.md`	Interface design, io.Reader/Writer, composition
Generics	`references/generics.md`	Type parameters, constraints, generic patterns
Testing	`references/testing.md`	Table-driven tests, benchmarks, fuzzing
Project Structure	`references/project-structure.md`	Module layout, internal packages, go.mod

Core Pattern Example

Goroutine with proper context cancellation and error propagation:

// worker runs until ctx is cancelled or an error occurs.
// Errors are returned via the errCh channel; the caller must drain it.
func worker(ctx context.Context, jobs <-chan Job, errCh chan<- error) {
    for {
        select {
        case <-ctx.Done():
            errCh <- fmt.Errorf("worker cancelled: %w", ctx.Err())
            return
        case job, ok := <-jobs:
            if !ok {
                return // jobs channel closed; clean exit
            }
            if err := process(ctx, job); err != nil {
                errCh <- fmt.Errorf("process job %v: %w", job.ID, err)
                return
            }
        }
    }
}

func runPipeline(ctx context.Context, jobs []Job) error {
    ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
    defer cancel()

    jobCh := make(chan Job, len(jobs))
    errCh := make(chan error, 1)

    go worker(ctx, jobCh, errCh)

    for _, j := range jobs {
        jobCh <- j
    }
    close(jobCh)

    select {
    case err := <-errCh:
        return err
    case <-ctx.Done():
        return fmt.Errorf("pipeline timed out: %w", ctx.Err())
    }
}

Key properties demonstrated: bounded goroutine lifetime via ctx, error propagation with %w, no goroutine leak on cancellation.

Constraints

MUST DO

Use gofmt and golangci-lint on all code
Add context.Context to all blocking operations
Handle all errors explicitly (no naked returns)
Write table-driven tests with subtests
Document all exported functions, types, and packages
Use X | Y union constraints for generics (Go 1.18+)
Propagate errors with fmt.Errorf("%w", err)
Run race detector on tests (-race flag)

MUST NOT DO

Ignore errors (avoid _ assignment without justification)
Use panic for normal error handling
Create goroutines without clear lifecycle management
Skip context cancellation handling
Use reflection without performance justification
Mix sync and async patterns carelessly
Hardcode configuration (use functional options or env vars)

Output Templates

When implementing Go features, provide:

Interface definitions (contracts first)
Implementation files with proper package structure
Test file with table-driven tests
Brief explanation of concurrency patterns used

Knowledge Reference

Go 1.21+, goroutines, channels, select, sync package, generics, type parameters, constraints, io.Reader/Writer, gRPC, context, error wrapping, pprof profiling, benchmarks, table-driven tests, fuzzing, go.mod, internal packages, functional options

Weekly Installs

6.7K

Repository

jeffallan/claude-skills

GitHub Stars

7.2K

First Seen

Jan 20, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykPass

Installed on

opencode5.5K

codex5.3K

gemini-cli5.2K

github-copilot5.1K

amp4.6K

kimi-cli4.5K

资深Go开发专家 | Go 1.21+、并发编程、云原生微服务、性能优化

🇨🇳中文介绍

Golang Pro

核心工作流程

参考指南

相关 Skills

核心模式示例

约束

必须遵守

禁止事项

输出模板

知识参考

🇺🇸English

Golang Pro

Core Workflow

Reference Guide

Core Pattern Example

Constraints

MUST DO

MUST NOT DO

Output Templates

Knowledge Reference