samber/cc-skills-golang

Go Code Style defines conventions for line breaking, variable declarations, control flow, and comments to keep Go code clear and reviewable. Use it when writing or reviewing Go code, answering style questions, or establishing project standards.

Go Continuous Integration configures CI/CD pipelines for Go projects using GitHub Actions, including testing, linting, SAST, security scanning, code coverage, Dependabot, Renovate, GoReleaser, code review automation, and release pipelines.

Go Dependency Management covers go.mod management, installing/upgrading packages, vulnerability scanning, outdated dependency tracking, conflict resolution, go.work workspaces, and Dependabot/Renovate setup for adding, removing, or upgrading Go dependencies.

Go Documentation guides writing and reviewing doc comments, README, CONTRIBUTING, CHANGELOG, Go Playground demos, Example tests, and llms.txt for Go projects. Use it when documenting libraries, applications, or CLIs, or auditing documentation completeness and style.

Go GraphQL guides implementation of GraphQL APIs in Go using gqlgen or graphql-go, covering schema design, resolvers, DataLoaders, subscriptions, and authentication. Use when building GraphQL servers or integrating with existing Go HTTP services.

Go Naming Conventions provides rules for naming packages, functions, variables, interfaces, errors, and other Go identifiers. Use it when writing new Go code, reviewing or refactoring, or deciding between naming alternatives to follow Go standards.

Go Observability adds structured logging, Prometheus metrics, OpenTelemetry tracing, profiling, and RUM instrumentation to Go services. Use it when instrumenting Go services for production monitoring, setting up metrics or alerting, adding tracing, correlating logs with traces, or migrating legacy loggers to slog.

Go Package Docs queries the pkg.go.dev API to read package documentation, API signatures, usage examples, available versions, importers, licenses, and known vulnerabilities for any Go module without authentication.

Go Popular Libraries recommends production-ready Golang libraries and frameworks for choosing a library, comparing alternatives, or adding a new dependency.

Go gRPC provides gRPC usage guidelines, protobuf organization, and production-ready patterns for Golang microservices. Use when implementing, reviewing, or debugging gRPC servers and clients, writing proto files, setting up interceptors, handling status codes, configuring TLS/mTLS, testing with bufconn, or working with streaming RPCs.

Golang Benchmark measures and compares Go benchmark results with benchstat, profiles CPU and memory data with pprof, and sets up CI regression detection. Use it when writing, running, or analyzing Go benchmarks, or investigating production performance with Prometheus runtime metrics.

Golang CLI provides patterns and best practices for building, modifying, and reviewing Go command-line applications. Use it when working with Cobra/Viper, flags, config layering, version embedding, exit codes, I/O, signals, completion, and CLI testing.

Golang Concurrency provides patterns and review/audit guidance for writing safe concurrent Go code using goroutines and channels. Use it when writing, reviewing, or auditing concurrent code to avoid goroutine leaks, race conditions, and channel ownership issues.

Golang Context provides idiomatic patterns for context.Context in Go, covering propagation through API boundaries, cancellation, timeouts, deadlines, and request-scoped values. Use when designing context propagation across layers, debugging leaked or unexpired contexts, or choosing between context.Background, TODO, and WithoutCancel.

Golang Data Structures covers slices, maps, arrays, container/list, heap, ring, strings.Builder vs bytes.Buffer, generic collections, unsafe/weak pointers, and copy semantics. Use it when choosing or optimizing Go data structures, implementing generic containers, using container packages, or questioning slice/map internals.

Golang Database provides best practices for safe Go database access using database/sql, sqlx, and pgx. Use when writing, reviewing, or debugging Golang code that interacts with PostgreSQL, MariaDB, MySQL, or SQLite.

Golang Dependency Injection explains when and how to apply DI in Go, covering manual constructor injection and libraries like google/wire, uber-go/dig, uber-go/fx, and samber/do. Use it when designing service architecture, refactoring coupled code, or selecting a DI library.

Golang Design Patterns provides idiomatic Go patterns for functional options, constructors, error flow, resource lifecycle, graceful shutdown, resilience, and streaming. Use it when choosing architectural patterns, designing APIs, or applying idiomatic Go practices.

Golang Error Handling provides guidance for creating, wrapping, inspecting, and logging errors in Go, covering sentinel errors, custom types, errors.Is/As, errors.Join, panic/recover, and structured logging. Use it when writing, reviewing, or auditing Go error handling code to avoid swallowed errors and duplicate logs.

Golang Gopls provides semantic code intelligence for Go via the official gopls language server, including go-to-definition, find references, call hierarchies, workspace symbol search, diagnostics, safe rename, refactoring, and formatting. Use it when navigating, understanding, or refactoring Go code in the local resolved build.

Golang How-To orchestrates the relevant Go skills for any coding, review, debug, or setup task, loading primary and secondary skills together and disambiguating overlaps. It also configures project files to trigger skills automatically.

Golang Lint configures golangci-lint for Go projects, covering linter selection, .golangci.yml setup, nolint directives, and lint output interpretation. Use it when setting up code quality tooling, fixing lint warnings, or cleaning up a legacy codebase.

Golang Modernize scans Go codebases and suggests modern replacements for outdated patterns, language features, and standard library APIs. Use it during code review, Go version upgrades, or CI to bring code up to current idioms while preserving safety.

Golang Performance Optimization applies Go-specific optimization patterns—allocation reduction, CPU efficiency, memory layout, GC tuning, pooling, caching, and hot-path tuning—when profiling or benchmarks have identified a bottleneck. Use it for performance code review or to suggest benchmark-driven improvements.

Google Wire provides compile-time dependency injection for Go using code generation, resolving the dependency graph at build time and emitting plain constructor calls. Use it when wiring an application graph with google/wire to catch missing dependencies at compile time rather than runtime.