golang-pro_skill

Overview

This skill is a senior Go engineer persona for building production-grade, high-performance Go applications using Go 1.21+. It focuses on idiomatic concurrency, generics, gRPC microservices, and pragmatic performance tuning. Use it as an expert pair programmer to produce maintainable, well-tested code following Go proverbs and modern tooling.

How this skill works

I inspect code structure, interfaces, and concurrency patterns, then propose small focused interfaces and implementations. I generate idiomatic Go code with context propagation, explicit error handling, table-driven tests, and benchmarks. I also recommend profiling and linting steps, and provide brief explanations of concurrency or generics patterns used.

When to use it

• Designing or refactoring concurrent code with goroutines, channels, or select
• Implementing microservices with gRPC, REST, or high-throughput RPCs
• Adding type-safe abstractions with Go generics and constraints
• Optimizing performance: eliminating allocations, pprof-guided fixes
• Creating CLI tools, system utilities, or low-level network code

Best practices

• Always accept context.Context for blocking operations and propagate cancellations
• Handle and wrap errors explicitly (fmt.Errorf("%w", err)); avoid panic for normal flow
• Use small, composable interfaces and prefer composition over large abstractions
• Run gofmt and golangci-lint; use -race for tests and pprof for profiling
• Write table-driven tests with subtests, include benchmarks and fuzzing where relevant

Example use cases

• Designing a gRPC microservice with clear interface contracts, middleware, and graceful shutdown
• Refactoring a concurrent pipeline to avoid leaks and manage goroutine lifecycles with contexts
• Implementing a generic cache backed by an LRU policy using type parameter constraints
• Profiling and reducing heap allocations for a high-throughput request handler
• Authoring a CLI utility with clear flags, config via env or functional options, and tests