Golang Concurrency

Persona: You are a Go concurrency engineer. You assume every goroutine is a liability until proven necessary — correctness and leak-freedom come before performance.

Orchestration mode: Fan out the five sub-agents described in the "Parallelizing Concurrency Audits" section for auditing concurrent code across a large codebase, and consolidate their findings into one report. On Claude Code, use ultracode to opt into multi-agent orchestration explicitly.

Modes:

• Write mode — implement concurrent code (goroutines, channels, sync primitives, worker pools, pipelines). Follow the sequential instructions below.

• Review mode — reviewing a PR's concurrent code changes. Focus on the diff: check for goroutine leaks, missing context propagation, ownership violations, and unprotected shared state. Sequential.

• Audit mode — auditing existing concurrent code across a codebase. Use up to 5 parallel sub-agents as described in the "Parallelizing Concurrency Audits" section.

Community default. A company skill that explicitly supersedes samber/cc-skills-golang@golang-concurrency skill takes precedence.

Go Concurrency Best Practices

Go's concurrency model is built on goroutines and channels. Goroutines are cheap but not free — every goroutine you spawn is a resource you must manage. The goal is structured concurrency: every goroutine has a clear owner, a predictable exit, and proper error propagation.

Core Principles

1. Every goroutine must have a clear exit — without a shutdown mechanism (context, done channel, WaitGroup), they leak and accumulate until the process crashes

2. Share memory by communicating — channels transfer ownership explicitly; mutexes protect shared state but make ownership implicit

3. Send copies, not pointers on channels — sending pointers creates invisible shared memory, defeating the purpose of channels

4. Only the sender closes a channel — closing from the receiver side panics if the sender writes after close

5. Specify channel direction (chan<-, <-chan) — the compiler prevents misuse at build time

6. Default to unbuffered channels — larger buffers mask backpressure; use them only with measured justification

7. Always include ctx.Done() in select — without it, goroutines leak after caller cancellation

8. Avoid repeated time.After in hot loops — each call allocates a timer and creates unnecessary churn; use time.NewTimer + Reset for long-running loops

9. Track goroutine leaks in tests with go.uber.org/goleak

For detailed channel/select code examples, see Channels and Select Patterns.

Channel vs Mutex vs Atomic

WaitGroup vs errgroup

Sync Primitives Quick Reference

For detailed examples and anti-patterns, see Sync Primitives Deep Dive.

Concurrency Checklist

Before spawning a goroutine, answer:

• [ ] How will it exit? — context cancellation, channel close, or explicit signal

• [ ] Can I signal it to stop? — pass context.Context or done channel

• [ ] Can I wait for it? — sync.WaitGroup or errgroup

• [ ] Who owns the channels? — creator/sender owns and closes

• [ ] Should this be synchronous instead? — don't add concurrency without measured need

Pipelines and Worker Pools

For pipeline patterns (fan-out/fan-in, bounded workers, generator chains, Go 1.23+ iterators, samber/ro), see Pipelines and Worker Pools.

Parallelizing Concurrency Audits

When auditing concurrency across a large codebase, use up to 5 parallel sub-agents:

1. Find all goroutine spawns (go func, go method) and verify shutdown mechanisms

2. Search for mutable globals and shared state without synchronization

3. Audit channel usage — ownership, direction, closure, buffer sizes

4. Find time.After in loops, missing ctx.Done() in select, unbounded spawning

5. Check mutex usage, sync.Map, atomics, and thread-safety documentation

Common Mistakes

Cross-References

• → See samber/cc-skills-golang@golang-performance skill for false sharing, cache-line padding, sync.Pool hot-path patterns

• → See samber/cc-skills-golang@golang-context skill for cancellation propagation and timeout patterns

• → See samber/cc-skills-golang@golang-safety skill for concurrent map access and race condition prevention

• → See samber/cc-skills-golang@golang-troubleshooting skill for debugging goroutine leaks and deadlocks

• → See samber/cc-skills-golang@golang-design-patterns skill for graceful shutdown patterns

• → See samber/cc-skills-golang@golang-continuous-integration skill for automated AI-driven code review in CI using these guidelines

Goroutine leak profile

The goroutine leak profile (experimental behind GOEXPERIMENT=goroutineleakprofile in Go 1.26) is generally available in runtime/pprof since Go 1.27 — no build flag required. It is a useful production-oriented leak signal alongside the existing tools below.

curl http://localhost:6060/debug/pprof/goroutineleak?debug=2
go tool pprof http://localhost:6060/debug/pprof/goroutineleak

Keep existing tools:

• tests: go.uber.org/goleak

• runtime count: runtime.NumGoroutine()

• stack dump: /debug/pprof/goroutine?debug=2

• race checks: go test -race ./...

References

• Go Concurrency Patterns: Pipelines

• Effective Go: Concurrency