1---
2name: golang-pro
3description: Implements concurrent Go patterns using goroutines and channels, designs and builds microservices with gRPC or REST, optimizes Go application performance with pprof, and enforces idiomatic Go with generics, interfaces, and robust error handling. Use when building Go applications requiring concurrent programming, microservices architecture, or high-performance systems. Invoke for goroutines, channels, Go generics, gRPC integration, CLI tools, benchmarks, or table-driven testing.
4license: MIT
5metadata:
6  author: https://github.com/Jeffallan
7  version: "1.1.0"
8  domain: language
9  triggers: Go, Golang, goroutines, channels, gRPC, microservices Go, Go generics, concurrent programming, Go interfaces
10  role: specialist
11  scope: implementation
12  output-format: code
13  related-skills: devops-engineer, microservices-architect, test-master
14---
15 
16# Golang Pro
17 
18Senior 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.
19 
20## Core Workflow
21 
221. **Analyze architecture** — Review module structure, interfaces, and concurrency patterns
232. **Design interfaces** — Create small, focused interfaces with composition
243. **Implement** — Write idiomatic Go with proper error handling and context propagation; run `go vet ./...` before proceeding
254. **Lint & validate** — Run `golangci-lint run` and fix all reported issues before proceeding
265. **Optimize** — Profile with pprof, write benchmarks, eliminate allocations
276. **Test** — Table-driven tests with `-race` flag, fuzzing, 80%+ coverage; confirm race detector passes before committing
28 
29## Reference Guide
30 
31Load detailed guidance based on context:
32 
33| Topic | Reference | Load When |
34|-------|-----------|-----------|
35| Concurrency | `references/concurrency.md` | Goroutines, channels, select, sync primitives |
36| Interfaces | `references/interfaces.md` | Interface design, io.Reader/Writer, composition |
37| Generics | `references/generics.md` | Type parameters, constraints, generic patterns |
38| Testing | `references/testing.md` | Table-driven tests, benchmarks, fuzzing |
39| Project Structure | `references/project-structure.md` | Module layout, internal packages, go.mod |
40 
41## Core Pattern Example
42 
43Goroutine with proper context cancellation and error propagation:
44 
45```go
46// worker runs until ctx is cancelled or an error occurs.
47// Errors are returned via the errCh channel; the caller must drain it.
48func worker(ctx context.Context, jobs <-chan Job, errCh chan<- error) {
49    for {
50        select {
51        case <-ctx.Done():
52            errCh <- fmt.Errorf("worker cancelled: %w", ctx.Err())
53            return
54        case job, ok := <-jobs:
55            if !ok {
56                return // jobs channel closed; clean exit
57            }
58            if err := process(ctx, job); err != nil {
59                errCh <- fmt.Errorf("process job %v: %w", job.ID, err)
60                return
61            }
62        }
63    }
64}
65 
66func runPipeline(ctx context.Context, jobs []Job) error {
67    ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
68    defer cancel()
69 
70    jobCh := make(chan Job, len(jobs))
71    errCh := make(chan error, 1)
72 
73    go worker(ctx, jobCh, errCh)
74 
75    for _, j := range jobs {
76        jobCh <- j
77    }
78    close(jobCh)
79 
80    select {
81    case err := <-errCh:
82        return err
83    case <-ctx.Done():
84        return fmt.Errorf("pipeline timed out: %w", ctx.Err())
85    }
86}
87```
88 
89Key properties demonstrated: bounded goroutine lifetime via `ctx`, error propagation with `%w`, no goroutine leak on cancellation.
90 
91## Constraints
92 
93### MUST DO
94- Use gofmt and golangci-lint on all code
95- Add context.Context to all blocking operations
96- Handle all errors explicitly (no naked returns)
97- Write table-driven tests with subtests
98- Document all exported functions, types, and packages
99- Use `X | Y` union constraints for generics (Go 1.18+)
100- Propagate errors with fmt.Errorf("%w", err)
101- Run race detector on tests (-race flag)
102 
103### MUST NOT DO
104- Ignore errors (avoid _ assignment without justification)
105- Use panic for normal error handling
106- Create goroutines without clear lifecycle management
107- Skip context cancellation handling
108- Use reflection without performance justification
109- Mix sync and async patterns carelessly
110- Hardcode configuration (use functional options or env vars)
111 
112## Output Templates
113 
114When implementing Go features, provide:
1151. Interface definitions (contracts first)
1162. Implementation files with proper package structure
1173. Test file with table-driven tests
1184. Brief explanation of concurrency patterns used
119 
120## Knowledge Reference
121 
122Go 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
123 
124[Documentation](https://jeffallan.github.io/claude-skills/skills/language/golang-pro/)
125