Skill UI

Guidelines for writing clear, idiomatic Go code: line breaking, variable declarations, composite literals, control flow, and function design. Useful when reviewing Go code or setting project coding standards.

A comprehensive guide for writing, reviewing, and auditing concurrent Go code. It covers core principles of structured concurrency, including proper resource management for goroutines, safe use of channels, mutexes, and advanced synchronization primitives like errgroup and singleflight. Essential for avoiding common issues like goroutine leaks, race conditions, and context propagation failures.

Provides comprehensive guidelines on using Go's `context.Context` for managing request lifecycles. Learn how to correctly propagate cancellation signals, enforce deadlines, handle timeouts, and safely pass request-scoped values across API boundaries (HTTP handlers, services, databases). Essential reading for writing resilient and robust concurrent Go applications.

A comprehensive guide for setting up production-grade CI/CD pipelines for Go projects using GitHub Actions. This skill covers essential quality gates including unit testing, linting (golangci-lint), static analysis security testing (SAST), vulnerability scanning, dependency management, Docker builds, and automated releases using GoReleaser.

Comprehensive guide to Go's built-in and standard library data structures, including slices, maps, and arrays. Deep dives into memory allocation, capacity growth mechanics, and best practices for optimization. Learn when to use `strings.Builder`, preallocation techniques, `container/heap`, and managing pointers safely with `unsafe.Pointer` and `weak.Pointer`. Ideal for optimizing performance-critical Go code.

A comprehensive guide detailing best practices for database interaction in Go. It covers secure query writing using parameterized placeholders, handling transactions, managing connection pooling, dealing with NULLable columns, and choosing between libraries like sqlx and pgx, while strongly advising against using ORMs.

This comprehensive guide covers Dependency Injection (DI) patterns specifically for Golang. It explains why DI is crucial for building testable, loosely coupled, and maintainable services. The skill compares manual constructor injection for small projects with advanced DI libraries (like google/wire, uber-go/dig) for complex architectures, focusing on best practices such as interface-based design and managing service lifecycles.

This skill enforces best practices for managing Go modules, focusing on stability, security, and maintainability. It guides users through essential workflows like dependency addition, safe upgrading (e.g., patch updates), cleanup (go mod tidy), and critical vulnerability scanning (govulncheck). Use this when initializing, updating, or auditing a Go project's dependency tree to ensure supply chain safety.

A comprehensive guide to creating production-ready, idiomatic Go applications. Covers critical patterns such as functional options, robust error handling, graceful shutdown, resource management, and architectural best practices. Ideal for refactoring existing Go code, choosing between architectural patterns, or designing scalable APIs and constructors.

A comprehensive guide for writing, reviewing, and structuring technical documentation for Go projects. It covers best practices for godoc comments, READMEs, contribution guidelines, and changelogs, ensuring documentation is accurate, discoverable, and tailored for both human readers and AI agents. Applicable to both libraries and CLIs.

A comprehensive guide to implementing robust, idiomatic error handling in Go. It covers best practices for error creation, context wrapping using `%w`, type-safe inspection with `errors.Is`/`errors.As`, adhering to the single handling rule, and utilizing structured logging with `slog`. Essential for building scalable, debuggable, and production-ready Go applications.

A comprehensive guide for building robust, production-ready microservices using gRPC in Golang. This skill covers advanced patterns including structured error handling with specific status codes, implementing cross-cutting concerns via interceptors (logging, auth), managing connections, ensuring graceful shutdowns, and defining optimal Protobuf schemas for distributed systems.