Go Service Rules

The problem

Go makes concurrency easy to write but difficult to debug at scale. Silent goroutine leaks, unbuffered channel deadlocks, and missing context deadlines often pass unit tests only to crash services under production load.

What it does

• Analyzes goroutine lifetimes to ensure every routine has a defined exit path and cancellation listener.
• Identifies unsafe channel patterns, including receiver-side closes and unbuffered sends that lack select blocks.
• Audits context propagation to prevent disconnected cancellation chains and missing request deadlines.
• Refactors error handling to use structured wrapping with errors.Is and errors.As instead of bare returns.
• Hardens net/http implementations by enforcing timeouts and graceful shutdown sequences.

Frameworks & tools

Go 1.22+, errgroup, context, net/http, and the Go race detector.

Why this beats prompting it yourself

Generic LLMs often suggest code that compiles but leaks memory. This skill applies a strict "Starter owns the Stopper" ownership model and forces a Concurrency Map for every change, ensuring structural integrity that a standard prompt misses.

Use cases

• Fixing OOM kills caused by growing goroutine counts in long-running services.
• Implementing safe fan-out patterns using limited errgroup concurrency.
• Adding graceful shutdown to HTTP servers to prevent dropped requests during deployments.
• Standardizing error wrapping across a microservice to improve observability.

Known limitations

This skill reviews and rewrites code in the editor but does not execute go test, the race detector, or profilers. Verification requires manual command execution.