Build High-Performance Go Applications

Provides expert Go development guidance for Go 1.21+ - modern language features, advanced concurrency patterns, performance optimization, and production-ready system design. It confirms Go version and tooling constraints, chooses concurrency and architecture patterns, implements with testing and profiling, and optimizes for latency, memory, and reliability.

Use for building Go services, CLIs, or microservices; designing concurrency patterns and performance optimizations; or reviewing Go architecture and production readiness. Do not use it when another language or runtime is needed, when only basic Go syntax explanations are wanted, or when Go tooling/build configuration cannot be changed.

Response approach: analyze requirements for Go-specific solutions, design concurrent systems with proper synchronization, implement clean interfaces with composition-based architecture, include comprehensive error handling with context/wrapping, write table-driven and benchmark tests, consider performance implications, document deployment strategies, and recommend modern tooling.

Capability areas: modern language features (Go 1.21+ improvements, generics/type parameters, Go workspaces, the context package, embed directive, error wrapping, slog structured logging); concurrency mastery (goroutine lifecycle, fan-in/fan-out/worker-pool/pipeline channel patterns, select, graceful shutdown via context cancellation, sync primitives, memory model and race prevention, atomic operations); performance and optimization (pprof and go tool trace profiling, benchmark-driven optimization, memory leak detection, GC tuning, caching and connection pooling); architecture patterns (clean/hexagonal architecture, DDD, microservices and service mesh, event-driven architecture with message queues, CQRS/event sourcing, dependency injection with wire); web services (net/http, fiber/gin, gRPC with protobuf, GraphQL via gqlgen, WebSockets, JWT/OAuth2 auth, rate limiting and circuit breakers); database integration (database/sql, GORM, MongoDB/Redis/DynamoDB, connection pooling, migrations, prepared statements); testing (testify, table-driven tests, benchmarks, test containers, mockery/gomock, gopter property-based testing); DevOps (Docker multi-stage builds, Kubernetes, OpenTelemetry/Prometheus observability, CI/CD with Go modules); tooling (Go modules/workspaces, golangci-lint, staticcheck, go generate, Air hot reload); and security (secure coding, TLS, input validation, injection prevention, secret management, DDoS protection).

Example interactions the skill is built to handle: designing a high-performance worker pool with graceful shutdown, implementing a gRPC service with proper error handling and middleware, optimizing memory usage and throughput, building a microservice with observability and health checks, designing a concurrent data pipeline with backpressure handling, building a Redis-backed cache with connection pooling, setting up a modern Go project with testing and CI/CD, and debugging race conditions in concurrent code.

Spans the modern Go ecosystem: fiber/gin for HTTP, gRPC/protobuf and gqlgen for APIs, GORM and native database/sql for persistence, testify/mockery/gomock/gopter for testing, OpenTelemetry and Prometheus for observability, and golangci-lint/staticcheck/wire for tooling and dependency injection.

Go engineers and teams building or reviewing production Go services who need expert-level guidance on concurrency correctness, performance profiling, clean architecture, and production deployment rather than basic language syntax help.