Coding standards, frameworks, refactoring, and code review (16.2K skills)
Use samber/mo in Go to represent missing values, failures, and alternative value types explicitly. Learn to choose Option, Result, or Either and combine processing steps, including pipelines where each step changes the value's type.
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.
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.
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.
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.
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.
Choose Go libraries and frameworks for web, database, testing, logging, and messaging tasks. Compare candidates with standard library options, checking maintenance, licenses, adoption, and dependency complexity before deciding what to add to a project.
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.
Build GraphQL APIs in Go with gqlgen or graphql-go. Covers schemas, resolvers that fetch field data, authentication, and live subscriptions, plus request-level data batching and query limits to address excessive database calls and resource use.
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.
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, 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.
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.
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.
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.
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.
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.
Consult a historical reference for describing why an agent role is needed, what blocks it, or when it can be released. It separates evidence supplied by the AI session from lifecycle operations owned by the runner script.
Clear the conversation context of one or more CCB-managed agents while preserving project state. The skill runs the matching ccb clear command and reports its output, with specific handling for DSH sessions.
Submit implemented and verified work to its assigned Reviewer, the agent responsible for checking it. Follow a bounded review and repair process, and report completion only after approval, or return a blocked or rework outcome.
Turn a high-level task plan into detailed execution notes, an evidence map, acceptance criteria, and worker handoff instructions. Return the documents and a structured JSON manifest for import by the workflow's scripts.
Carry out one clearly scoped implementation or investigation task, verify the work where possible, and submit evidence to the assigned reviewer. Reports changed paths, verification results, and blockers while preserving controller authority.
Enable or disable disconnect recovery for the current Codex thread running inside tmux, a terminal session manager. Explicit on and off commands control the setting, and the skill reports the command result or error.
Assess a supplied task and execution contract, then propose one to four workgroups with clear scopes, dependencies, and verification references. Returns a structured plan for a controller to validate and use.