Skill UI

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.

A comprehensive guide for advanced Go developers, detailing the internals, optimal usage, and performance pitfalls of core data structures like slices, maps, and arrays. It covers capacity growth mechanics, preallocation strategies using `make` and `slices` package functions, and best practices for choosing between various standard library containers (e.g., `strings.Builder` vs `bytes.Buffer`). Essential for writing highly efficient, memory-safe 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 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.

This skill provides comprehensive guidance on idiomatic Go design patterns and best practices for writing production-ready code. It covers functional options, constructor design, graceful shutdown, resource management, dependency injection, and crucial architectural considerations, helping developers write robust and maintainable Go applications.

This comprehensive guide provides best practices for creating, reviewing, and auditing documentation for Go projects. It covers writing principles (e.g., Intent over paraphrase, Concision), structuring documentation (godoc comments, README, CHANGELOG), and workflow orchestration for both libraries and CLI applications. Ideal for technical writers and developers ensuring code is discoverable and maintainable.

A comprehensive guide for writing robust, idiomatic, and production-ready error handling in Go. This skill covers best practices for error creation, wrapping (using %w), inspection (errors.Is/As), combining errors (errors.Join), and structured logging with slog. It promotes reliable code by enforcing principles like the single handling rule and contextual logging, crucial for building scalable applications.

This comprehensive guide covers best practices for building robust, production-ready gRPC microservices in Go. It details proper protobuf organization, utilizing interceptors for cross-cutting concerns (logging, auth), implementing graceful shutdowns, handling gRPC status codes, and optimizing client connections with deadlines and retry policies. Essential for engineers designing reliable distributed systems.

This skill automatically modernizes Go codebases by identifying and replacing outdated patterns, deprecated APIs, and non-idiomatic code. It conducts comprehensive scans across language features, standard library upgrades, testing patterns, and tooling (including running lint checks). It ensures the codebase adheres to the latest Go best practices, improving safety, correctness, and readability for modern Go versions.

A comprehensive guide detailing recommended naming conventions for various Go language elements, including packages, structs, interfaces, constants, functions, and error handling. Use this skill when writing, reviewing, or refactoring Go code to ensure adherence to idiomatic Go style.

This skill acts as a Go ecosystem expert, guiding developers through the process of selecting and vetting production-ready third-party libraries and frameworks for Go projects. It enforces best practices by prioritizing the standard library, ensuring library maturity, and evaluating performance and simplicity to avoid over-engineering. Use this when you need to compare alternatives or choose the optimal dependency for a specific task.

This guide serves as a comprehensive blueprint for architecting and structuring Golang projects. It covers best practices for defining project types (CLI, Service, Library, Monorepo), adhering to 12-Factor App principles, standardizing module naming conventions, and establishing optimal directory layouts (cmd/, internal/, pkg/). Use it when starting a new Go application or refactoring a complex codebase to ensure maintainability and scalability.