Coding standards, frameworks, refactoring, and code review (16.3K skills)
Build Godot interfaces that adapt to window size using Control and Container nodes. Apply shared themes, connect button actions, and set keyboard or gamepad focus so menus, HUDs, inventories, and settings screens work consistently.
Prepare Godot 4.7 games for desktop, web, and mobile distribution. Covers export templates, platform presets, automated command-line builds, and common setup issues for browser games and servers that run without a window.
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.
Explore an unfamiliar codebase before editing it. Produce a ranked map of important files, functions, callers, and dependencies, with source locations and evidence types to guide code reading and assess the likely impact of changes.
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.
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.
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.
Build Go pipelines with samber/ro for events that arrive over time. Choose how consumers share data, combine multiple sources, and handle retries, timeouts, errors, and cancellation while managing the resources used by ongoing streams.
Look up published Go packages with godig, a client for pkg.go.dev. Retrieve function signatures, documentation, examples, available versions, licenses, known vulnerabilities, and importing packages through read-only queries that require no authentication.
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.
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.
Design and review concurrent Go code with clear goroutine ownership, shutdown paths, and error handling. Choose channels, locks, or atomic operations to protect shared data, and structure worker pools with controlled concurrency and cancellation.
Investigate Go crashes, hangs, intermittent failures, and unexpected behavior through reproducible tests and measured evidence. Use race detection, Delve debugging, and pprof diagnostics to trace root causes, then verify fixes and guard against regressions.
Selects and loads relevant Go skills for coding, review, debugging, and setup tasks. It combines complementary guidance, explains overlapping skill roles, and can configure project agent instructions to load Go skills consistently.
Write and review documentation for Go libraries and applications, from code comments and README files to installation guides and changelogs. Add runnable examples and structured project summaries that help readers and AI agents understand how to use the code.
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.
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.
Review Go code for accidental crashes and silent data corruption. This skill guides safer handling of nil values, shared slice storage, numeric conversions, resource cleanup, and types that work safely without explicit initialization.
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.
Organize Go application dependencies with samber/do v2, a library that supplies services to the code that needs them. Guides service registration, lifecycle management, module organization, and migration from manually wired constructors.
Organize Go projects with directory layouts, naming rules, and configuration files suited to their size and purpose. Supports command-line tools, libraries, services, and workspaces for developing several related modules together.
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.
Build in-memory caches in Go with samber/hot to reduce repeated backend reads. Choose eviction rules, set expiration and capacity, load missing entries, and monitor cache behavior while accounting for memory limits and loading failures.