Engineering GoConcurrencyGoroutines

Golang Pro

Go development patterns: goroutines, channels, context propagation, interfaces, error handling, testing, modules, and high-performance service design.

A production Go expert focused on idiomatic concurrency patterns, error wrapping with fmt.Errorf, interface-driven design, and building observable HTTP services with net/http. Covers goroutine lifecycle management, context cancellation, sync primitives (Mutex, WaitGroup, sync.Map), and the table-driven testing pattern with testify.

Added Mar 20, 2026

$npx skills add johnefemer/skillfish --skill golang-pro

Capabilities Real Examples Get Started Models & Context Works Great With

What This Skill Can Do

Concrete capabilities you get when you install this skill.

Design goroutine pipelines with fan-out/fan-in and bounded concurrency

Implement context propagation for cancellation and deadline handling

Write idiomatic error wrapping with sentinel errors and fmt.Errorf %w

Design small, composable interfaces and dependency injection patterns

Profile CPU and memory with pprof and identify goroutine leaks

Structure Go modules and packages for maintainability at scale

Real Conversations

See how the Golang Pro skill responds to actual requests. These are representative examples of what your AI agent will produce.

You

I need to process 10,000 files concurrently but not spawn 10,000 goroutines at once. How do I implement a worker pool in Go?

Agent

Use a buffered channel as a semaphore to bound concurrency:

func processFiles(paths []string, maxWorkers int) error {
    sem := make(chan struct{}, maxWorkers) // semaphore
    var wg sync.WaitGroup
    errs := make(chan error, len(paths))

    for _, path := range paths {
        wg.Add(1)
        sem <- struct{}{} // acquire slot (blocks when at maxWorkers)
        go func(p string) {
            defer wg.Done()
            defer func() { <-sem }() // release slot
            if err := processFile(p); err != nil {
                errs <- fmt.Errorf("processing %s: %w", p, err)
            }
        }(path)
    }

    wg.Wait()
    close(errs)

    var combined []error
    for err := range errs {
        combined = append(combined, err)
    }
    return errors.Join(combined...)
}

For maxWorkers, start with runtime.NumCPU() for CPU-bound work or 50–100 for I/O-bound work (file reads).

If you need early cancellation on first error, add a context.WithCancel and check ctx.Err() at the top of each goroutine. The errgroup package (golang.org/x/sync/errgroup) wraps this entire pattern and is worth using for new code.

You

My Go HTTP service leaks goroutines. The goroutine count climbs from 50 to 5,000 over 24 hours and the service eventually OOMs. How do I find the leak?

Agent

Goroutine leaks in HTTP servers have three common causes. Here's how to find yours:

1. Expose pprof to inspect live goroutines:

import _ "net/http/pprof"
// curl http://localhost:6060/debug/pprof/goroutine?debug=2 | head -100
// Shows every goroutine's stack trace — look for goroutines blocked on channel send/receive

2. The top three culprits:

// A) Unbuffered channel with no consumer — goroutine blocks forever
results := make(chan Result) // ❌
go func() { results <- compute() }() // leaks if caller returns early

// Fix: buffered channel or select with context
results := make(chan Result, 1) // ✅

// B) goroutine started without context — won't stop when request is done
go func() {
    for {
        fetch(url) // loops forever
        time.Sleep(time.Second)
    }
}() // ❌ never exits

// Fix: propagate context
go func(ctx context.Context) {
    for {
        select {
        case <-ctx.Done(): return
        case <-time.After(time.Second): fetch(url)
        }
    }
}(req.Context()) // ✅

// C) http.Response body not closed
resp, _ := http.Get(url)
// missing: defer resp.Body.Close() — keeps connection + goroutine alive

3. Add a goroutine count metric:

metrics.Gauge("goroutines", float64(runtime.NumGoroutine()))

Track it in Prometheus/Grafana. Spikes after specific request types point to the exact handler causing the leak.

Get Started

How to install and use this skill in your preferred environment.

Skills are designed for AI coding agents (Claude Code, Cursor, Windsurf) and IDE-based workflows where the agent can read files, run scripts, and act on your codebase.

Models & Context

Which AI models and context windows work best with this skill.

Recommended Models

Claude Sonnet 4 or GPT-4o produce idiomatic Go; avoid models that suggest Java-style patterns. Gemini 2.5 Pro handles concurrent code reasoning well.

Context Window

SKILL.md ~5KB. Fits in 32K context; for large service refactors, 64K+ keeps full package trees visible.

Pro tips for best results

1

Be specific

Include numbers — users, budget, RPS — so the skill can size the architecture.

2

Share constraints

Compliance needs, team size, and existing stack all improve the output.

3

Iterate

Start with a high-level design, then ask follow-ups for IaC, cost analysis, or security review.

4

Combine skills

Pair with companion skills below for end-to-end coverage.

Works Great With

These skills complement Golang Pro for end-to-end coverage. Install them together for better results.

Senior Backend

REST APIs, database optimization, authentication, and microservices.

BackendAPIs

Microservices Architect

Microservices design: service decomposition, inter-service communication, saga pattern, API gateway, distributed tracing, and monolith migration.

MicroservicesgRPC

Docker Expert

Docker mastery: multi-stage builds, layer optimization, security scanning, Compose for dev/prod, networking, volumes, and container debugging.

DockerContainers

Performance Profiler

Node/Python/Go profiling, bundle analysis, and load testing.

PerformanceProfiling

TDD Guide

Test-driven development workflow with test generation and multi-framework support.

TDDTesting

$ skillfish add johnefemer/skillfish --all # install all skills at once

Ready to try Golang Pro?

Install the skill and start getting expert-level guidance in your workflow — any agent, any IDE.