golang-patterns_skill

Overview

This skill codifies idiomatic Go patterns, best practices, and conventions to help you build robust, efficient, and maintainable Go applications. It focuses on readability, safe concurrency, error handling, package and API design, and performance optimizations. Use it as a practical checklist during development, reviews, and refactors.

How this skill works

The skill inspects common Go design areas and recommends concrete patterns: making zero values useful, accepting interfaces and returning concrete types, clear error wrapping, and safe concurrency constructs. It highlights anti-patterns, suggests tooling and linter settings, and provides concise code idioms and examples you can apply directly to functions, packages, and system-level design. Outputs are actionable guidelines aimed at reducing bugs and improving long-term maintainability.

When to use it

• When writing new Go modules, libraries, or services.
• During code reviews to flag non-idiomatic constructs and bugs.
• While refactoring to simplify interfaces, reduce global state, and improve testability.
• When designing concurrent systems, worker pools, or graceful shutdown flows.
• Before committing linter and CI changes to enforce consistent style.

Best practices

• Prefer simplicity and clear control flow; return early and keep the happy path unindented.
• Design types whose zero value is usable without explicit initialization.
• Accept interfaces in function parameters and return concrete struct types.
• Wrap errors with context using fmt.Errorf(...%w...) and use errors.Is / errors.As for checks.
• Use context for cancellation/timeouts and errgroup to coordinate goroutines.
• Avoid package-level mutable state; inject dependencies via constructors.

Example use cases

• Implementing an HTTP service with dependency-injected database and graceful shutdown.
• Refactoring a leaking goroutine into a context-aware worker pool or errgroup-based routine.
• Designing a small, focused interface in the consumer package instead of exposing it globally.
• Improving performance by preallocating slices, using strings.Builder, or sync.Pool for buffers.
• Adding linters and go tooling (gofmt, goimports, staticcheck, golangci-lint) to CI.