Coding standards, frameworks, refactoring, and code review (16.1K skills)
Turn reviewed wiki knowledge into a reusable Agent Skill package with SKILL.md, supporting references, and source records. Output goes to a review directory so a person can inspect it before choosing to install it.
Turn recurring tasks into reusable agent skills, or improve skills you already have. Draft instructions, compare test outputs with and without a skill, review quality and resource use, and refine descriptions so skills trigger for appropriate requests.
Choose and use Go data structures based on access patterns, memory use, and copying behavior. It covers slices, maps, arrays, standard containers, string building, generic collections, and pointer types, with guidance on allocation and shared data.
Build Go services with uber-go/fx by connecting components and managing startup and shutdown. This skill covers dependency injection, which supplies components with what they need, plus reusable modules, signal handling, logging, and tests with substitute dependencies.
Design Go services with dependency injection: passing required components in from outside. Compare manual wiring with DI libraries, generate setup code, and plan changes to tightly coupled services so their dependencies and lifecycle are explicit.
Design and review Go structs and interfaces with clear responsibilities. Get guidance on small interfaces, embedding, dependency injection—passing in components a type needs—field tags, safe type checks, and pointer or value receivers.
Choose and review Go design patterns for APIs and application structure. Get guidance on constructors, explicit initialization, resource cleanup, graceful shutdown, timeouts, and retries, with patterns matched to project requirements and the developer’s preferred architecture.
Helps wire Go applications with uber-go/dig using dependency injection, which supplies the components each function needs. Covers constructor registration, named values, groups, and validation so startup dependencies can be organized and checked in tests.
Build Go application initialization with google/wire, which generates constructor calls from declared dependencies. Covers reusable provider groups, interface bindings, cleanup functions, and keeping generated code synchronized so missing dependencies surface during generation.
Build Go logging pipelines with samber/slog-* packages to control log volume, mask personal information, and route records to different destinations. It also guides HTTP request logging and shutdown handling for destinations that buffer records.
Build and extend Go command-line tools with spf13/cobra. Organizes commands and options, validates arguments, adds shell completion suggestions, customizes help, and tests command behavior with captured output and isolated command instances.
Build, extend, or review Go command-line tools with clear commands, flags, and configuration priorities. It guides output formats, exit codes, shell completion, cancellation, and tests so tools behave predictably in scripts and terminals.
Write and review Go error handling so failures carry useful context and are handled once. Covers error creation, wrapping, inspection, panic usage, and structured logging, where named fields help organize and search production logs.
Review older Go code and plan updates to language features, standard libraries, tests, and CI. The skill checks the project's Go version, prioritizes safety and correctness, and guides changes with linting and tests.
Improve Go code after profiling identifies a bottleneck. This skill guides memory allocation, CPU, caching, and garbage collection changes, with benchmark comparisons to check results. It also supports performance reviews of functions, packages, and services.
Restructure existing Go code while preserving its behavior. Uses gopls, Go's code analysis tool, to map affected code and apply changes, with targeted tests and small pull requests for renaming, extracting functions, and moving code between packages.
Write, review, and debug Go database access code with guidance on parameterized queries, transactions, connection pools, and tests. Covers database/sql, sqlx, and pgx, while leaving schema creation and migration SQL outside its scope.
Helps implement structured error handling in Go with samber/oops. Add diagnostic attributes, stack traces showing the call path, and error codes, while keeping user-facing messages separate from technical details and integrating errors with logging.
Implement Go collection transformations with samber/lo, including filtering, grouping, aggregation, and deduplication. Choose between standard library functions and helpers, and assess parallel processing, input mutation, or lazy evaluation when data size and measured performance justify them.
Design how Go requests carry cancellation signals, time limits, and request metadata through application layers. Helps investigate work that continues after cancellation, choose suitable context types, and separate background tasks from the request lifecycle.
Navigate and refactor Go code with gopls, the official service for understanding Go source. Find definitions, references, and package APIs, then rename or restructure code and check diagnostics against the locally resolved project and dependencies.
Create and review Go API documentation with swaggo/swag. Adds comments describing inputs, responses, and authentication, generates machine-readable API specifications, and connects Swagger UI so API users can inspect the documented endpoints.
Manage dependencies in Go projects, from evaluating a new package to updating versions and resolving conflicts. It covers module files, known vulnerability checks, dependency size audits, and workspaces for developing multiple modules together.
Build and review Go services using gRPC, a framework for calling functions across services. Covers communication definitions, clients and servers, error codes, timeouts, encrypted connections, streaming, and tests that run without a network.