专业版
- 作者仓库星标 0
- 作者仓库 skills-registry
- 领域
- 设计与多媒体
- 作者声明的智能体
- 未找到明确声明;不据此推断已兼容或已测试
- 静态检查
- 88 / 100 · 启发式扫描,不代表运行安全
- 运行环境证据
- 未执行;当前没有隔离运行测试证据
- 作者 / 版本 / 许可证
- @tomevault-io · 未声明许可证
- 上下文用量评级
- 低消耗
- 接入复杂程度
- 即装即用
- 是否需要外部接口密钥
- 不需要
- 兼容的系统
- macOS · Linux · Windows
- 运行环境要求
- 未检出明确要求
- 检测到的文件与系统行为
-
- 只读
- 允许写入 / 修改
- 读取环境变量
- 网络行为
- 仅限本地
- 安装命令数
- 无(仅作为资料)
需要注意: 未声明工具权限范围;实际权限由运行环境决定。
// 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())
}
}
# Golang Pro
Senior Go developer with deep expertise in Go 1.21+, concurrent programming, and cloud-native microservices. Specializes in idiomatic patterns, measured performance optimization, and production code.
## Guardrails
- State assumptions about concurrency, ordering, cancellation, and error handling before coding.
- Prefer simple functions and small interfaces. Do not introduce goroutines, channels, generics, or microservice boundaries unless the task needs them.
- Keep edits surgical and local to the requested behavior. Do not reformat or refactor adjacent Go code opportunistically.
- Verify with targeted tests first; run `go test`, `go vet`, race tests, benchmarks, or pprof only when relevant to the change.
## Core Workflow
1. **Analyze scope** — Review only the modules, interfaces, and concurrency paths touched by the task
2. **Choose the simplest design** — Create small interfaces only when multiple real implementations or tests need them
3. **Implement** — Write idiomatic Go with explicit error handling and context propagation where the code path requires it
4. **Validate** — Run the narrowest useful tests and static checks, then broaden only when shared behavior changed
5. **Optimize when measured** — Profile with pprof or benchmarks before changing performance-sensitive code
## 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:
```go
// 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:
1. Interface definitions (contracts first)
2. Implementation files with proper package structure
3. Test file with table-driven tests
4. 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
[Documentation](https://jeffallan.github.io/claude-skills/skills/language/golang-pro/)
---
> **Install:** ``npx skills add ChristopherAlphonse/calphonse-skills --skill golang-pro``
---
> Source: [ChristopherAlphonse/calphonse-skills](https://github.com/ChristopherAlphonse/calphonse-skills) — distributed by [TomeVault](https://tomevault.io).
<!-- tomevault:4.0:skill_md:2026-05-23 -->
章节与文件索引
按说明文件中的顺序排列。
护栏
核心工作流程
参考指南
核心模式示例
必须做
文件/命令 -> go test · go vet · references/concurrency.md · references/interfaces.md · references/generics.md · references/testing.md · references/project-structure.md · ctx
内容校验值 -> 6789ea3c16ab
当前原文的自动摘译,尚未人工审校。
护栏
在编码之前陈述有关并发、排序、取消和错误处理的假设。喜欢简单的功能和小界面。不要引入 goroutine、通道、泛型或微服务边界,除非任务需要它们。对所要求的行为进行外科手术式和本地化的编辑。不要趁机重新格式化或重构相邻的 Go 代码。首先通过有针对性的测试进行验证;仅在与更改相关时运行
go test、go vet、竞赛测试、基准测试或 pprof。核心工作流程
分析范围 — 仅审查任务涉及的模块、接口和并发路径 选择最简单的设计 — 仅在多个实际实现或测试需要时才创建小接口 实施 — 在代码路径需要的地方编写具有显式错误处理和上下文传播的惯用 Go 验证 — 运行最窄的有用测试和静态检查,然后仅在共享行为发生更改时扩展
参考指南
根据上下文加载详细指导:主题·参考·并发时加载·
references/concurrency.md·Goroutines、通道、选择、同步原语接口·references/interfaces.md·接口设计、io.Reader/Writer、组合泛型·references/generics.md·类型参数、约束、泛型模式核心模式示例
具有适当上下文取消和错误传播的 Goroutine:演示了关键属性:通过
ctx有界 Goroutine 生命周期,使用%w进行错误传播,取消时没有 Goroutine 泄漏。必须做
在所有代码上使用 gofmt 和 golangci-lint 将 context.Context 添加到所有阻塞操作 显式处理所有错误(无裸返回) 使用子测试编写表驱动测试 记录所有导出的函数、类型和包