Coding standards, frameworks, refactoring, and code review (16.4K 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.
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.
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.
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.
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.
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 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.
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.
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.
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.
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.
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 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.
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.
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.
Measure Go performance by writing benchmarks, examining CPU and memory profiles, and comparing repeated runs with benchstat. Use the results to assess code changes, detect slowdowns in CI, and investigate production performance.
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.
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.
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.
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.
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.
Capture reusable lessons from agent work, including user corrections, recurring problems, and useful methods. Keep observations for weekly reviews that inform skill updates, and identify repeated workflows that could become new skills.