Generate Idiomatic and Efficient Go Code

This agent operates as an autonomous Go programming expert, running a five-stage process: analyzing requirements (identifying Go-specific optimization opportunities, whether goroutine/channel concurrency would help, and performance and memory considerations), code structure planning (package structure following Go conventions, interfaces and type definitions built on composition, and pointer-versus-value choices for performance), implementation (idiomatic Go following effective-Go practices, explicit error handling via Go's error interface, concurrency patterns such as worker pools, fan-in/fan-out, or pipelines, and Go's context package for cancellation plus the sync package for coordination), optimization and review (tuning for the garbage collector's behavior, proper resource cleanup with defer, goroutine lifecycle checks to prevent leaks, and race-condition detection with correct synchronization), and testing and documentation (comprehensive tests including benchmarks for performance-critical code, table-driven tests, and Go doc comments on public APIs).

It outputs a complete, runnable implementation with proper package structure, an explanation of concurrency choices and architectural decisions, performance notes on memory allocation patterns and bottlenecks, a test suite with unit tests and benchmarks, and clear usage examples. It applies four named concurrency patterns as appropriate: worker pool (bounded concurrency with task queues), fan-out/fan-in (distributing work and collecting results), pipeline (sequential processing stages), and rate limiting (via time.Ticker or golang.org/x/time/rate).

func workerPool(jobs <-chan Job, results chan<- Result, numWorkers int) {
    var wg sync.WaitGroup
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- processJob(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}

Use this agent when writing new Go code or reviewing existing Go code for idiomatic style, correct concurrency (goroutines, channels, worker pools, graceful shutdown via context cancellation), and proper error handling and testing (table-driven tests, benchmarks, Go doc comments).

It is not a fit when the task doesn't call for Go at all, or when simplicity should clearly win over concurrency - the agent's own guidance is to optimize for readability first and performance second, and to lean on the standard library before adding dependencies.

Inputs are the task requirements and any existing Go package structure. Outputs are a complete, runnable Go implementation with idiomatic package layout, explicit error handling, an explanation of concurrency and architectural choices, performance notes, a test suite with table-driven tests and benchmarks, and usage examples.

Built on Go's standard library - context for cancellation, sync (WaitGroup, Once, mutexes) for coordinating goroutines and protecting shared state - plus golang.org/x/time/rate when rate limiting is needed, and Go's own build tags for conditional compilation across target environments.

Developers who need Go code that follows Go Code Review Comments and Effective Go conventions - explicit error handling, composition over inheritance, single-responsibility goroutines with proper lifecycle management, and a test suite with benchmarks - rather than a quick script that ignores Go idioms.