Set up a Go service
Give the assistant guidance on package layout, dependency injection, and module management, then use the GitHub Actions skill to build a pipeline for tests, linting, and releases.
Overview
cc-skills-golang is a plugin of instructions for AI assistants working on Go projects. It covers language conventions, application design, testing, debugging, performance, and specific libraries. Skill descriptions help the agent select relevant guidance, with detailed instructions loaded on demand. The golang-how-to skill is designed to coordinate related skills when a task spans several areas.
In Claude Code, most skills also support manual invocation. The GraphQL skill is available for the agent to select, with manual invocation disabled. Skills refer to one another, so the author recommends installing the general-purpose guidance together.
Use Cases
Restructure an existing codebase
Plan a refactor around the project's test coverage, inspect references with gopls, and break the changes into small reviews. Separate guidance covers package splits, naming, and adopting newer Go idioms.
Investigate a panic or deadlock
Use the troubleshooting methodology to reproduce the failure and narrow its cause with tests, Delve, or race detection. Safety and concurrency guidance help assess the code involved.
Reduce latency or memory use
Measure the problem with benchmarks and profiles, then use the performance guidance to choose changes to allocations, caching, pooling, or memory layout.
Build a configurable command-line tool
Combine guidance on exit codes, signals, and terminal I/O with Cobra command trees and Viper configuration from flags, environment variables, and files.
Check a dependency before adopting it
Compare library choices, then use the package lookup skill to inspect published APIs, versions, licenses, and known vulnerabilities. That lookup needs godig through its CLI or MCP server and internet access.
Components
Skills
This plugin's skills 46What you’ll need
Showing all 46
Project setup and dependencies
golang-continuous-integration
Configure GitHub Actions for Go builds, tests, linting, security checks, and releases.
golang-dependency-management
Manage Go modules, dependency versions, replacements, workspaces, and vulnerability checks.
golang-how-to
Select related Go skills for a task and configure project-specific loading instructions.
golang-lint
Configure golangci-lint, choose checks, and interpret or suppress findings.
golang-pkg-go-dev
Look up package APIs, versions, licenses, and vulnerabilities; requires godig and internet access.
golang-popular-libraries
Compare Go libraries and decide when the standard library is sufficient.
golang-project-layout
Organize packages, application entry points, modules, and multi-module workspaces.
golang-stay-updated
Find Go release news, learning resources, communities, and contributors to follow.
Language and code design
golang-code-style
Review declarations, control flow, line breaks, and comments for readability.
golang-concurrency
Design goroutine lifecycles, synchronization, worker pools, and channel pipelines.
golang-context
Propagate cancellation, deadlines, and request-scoped values across application layers.
golang-data-structures
Choose and use slices, maps, containers, and generic collections.
golang-dependency-injection
Design constructor injection and compare Go dependency injection approaches.
golang-design-patterns
Choose Go patterns for constructors, configuration, resilience, and application architecture.
golang-documentation
Write package documentation, API comments, executable examples, and project guides.
golang-error-handling
Create, wrap, inspect, and log errors with useful context.
golang-gopls
Navigate and refactor local Go code; requires gopls v0.20+ on PATH.
golang-modernize
Update older Go idioms to use newer language and standard-library features.
golang-naming
Choose consistent names for packages, types, functions, errors, and tests.
golang-refactoring
Plan behavior-preserving changes around test coverage; requires gopls and git.
golang-safety
Review nil handling, slice aliasing, numeric conversions, and resource lifecycles.
golang-structs-interfaces
Design structs and interfaces using composition, embedding, tags, and appropriate receivers.
Application development and operations
golang-cli
Design Go command-line tools with clear arguments, I/O, signals, and exit codes.
golang-database
Write database access code with parameterized queries, transactions, and connection pooling.
golang-observability
Instrument production services with structured logs, metrics, tracing, and alerts.
golang-security
Review Go code for injection, unsafe cryptography, exposed secrets, and network risks.
Testing, debugging, and performance
golang-benchmark
Measure performance with benchmarks, profiles, traces, and benchstat comparisons.
golang-performance
Choose optimization patterns for allocations, CPU use, memory, caching, and pooling.
golang-testing
Design table-driven, parallel, fuzz, and integration tests with coverage checks.
golang-troubleshooting
Investigate crashes, deadlocks, races, and unexpected behavior using tests and debugging tools.
Library-specific guidance
golang-google-wire
Generate dependency wiring at compile time with provider sets and injectors.
golang-graphql
Build GraphQL schemas, resolvers, subscriptions, and dataloaders with gqlgen or graphql-go.
golang-grpc
Build gRPC services with protobuf definitions, streaming, interceptors, and status codes.
golang-samber-do
Wire services with samber/do containers, scopes, health checks, and shutdown handling.
golang-samber-hot
Configure samber/hot caches with eviction policies, TTLs, loaders, and metrics.
golang-samber-lo
Transform collections with samber/lo helpers, including parallel and mutable variants.
golang-samber-mo
Model optional values, results, and functional composition with samber/mo types.
golang-samber-oops
Attach stack traces, codes, and structured context to errors with samber/oops.
golang-samber-ro
Build reactive event pipelines with samber/ro observables, operators, and backpressure.
golang-samber-slog
Build slog pipelines with routing, sampling, formatting, middleware, and backend handlers.
golang-spf13-cobra
Build Cobra command trees with flags, validation, completion, and command tests.
golang-spf13-viper
Layer Viper configuration from flags, environment variables, files, and defaults.
golang-stretchr-testify
Write assertions, mocks, and test suites with stretchr/testify.
golang-swagger
Generate Swagger documentation from Go annotations; requires Go and the swag CLI.
golang-uber-dig
Wire dependencies at runtime with dig containers, named values, and groups.
golang-uber-fx
Organize Fx applications with modules, dependency wiring, lifecycle hooks, and shutdown.
No matching results.
Install
Install the full collection for your AI tool so that skills can refer to the related guidance they need.
Claude Code
- 01
In your Claude Code session, add the samber marketplace.
/plugin marketplace add samber/cc - 02
Open cc-skills-golang in the marketplace, choose user, project, or local scope, and install it.
/plugin install cc-skills-golang@samber - 03
Read the installation summary. If it says the plugin is active, no reload is needed. If it requests a reload, close the panel to apply it; if Claude Code leaves it pending after a prompt-cache warning, follow the panel's reload guidance.
To confirm installation, find cc-skills-golang in the plugin manager's Installed tab. Type a slash in the prompt to look for its skills under the cc-skills-golang prefix.
This method installs the collection's skills without registering a Claude Code plugin. The Skills CLI supports Claude Code and installs into the current project by default.
- 04
In a terminal, open the project where you want the skills available, then install the full collection.
npx skills add https://github.com/samber/cc-skills-golang --all - 05
In Claude Code, open the available-skills list and check for golang-how-to. Changes under an existing project skills directory load automatically; if the installer created the top-level directory during your session, use Claude Code's skill reload action to discover it.
- 04
In your GitHub Copilot CLI session, install the plugin from its repository.
/plugin install https://github.com/samber/cc-skills-golang
Use Copilot CLI's available-skills list to check for golang-how-to.
- 04
In a terminal, clone the collection into your Cursor skills directory.
git clone https://github.com/samber/cc-skills-golang.git ~/.cursor/skills/cc-skills-golang - 05
Start Cursor so it discovers the skills in your personal skills directory.
In Agent chat, type a slash and search for golang-how-to to find the skill.
- 04
In a terminal, clone the collection into the shared agent skills directory.
git clone https://github.com/samber/cc-skills-golang.git ~/.agents/skills/cc-skills-golangOpenCode discovers skills in this directory.
- 05
Ask the OpenCode agent to load golang-how-to with its skill tool. Check that the tool loads the skill's instructions.
OpenCode lists permitted skills at each model step and loads them on demand. Its documentation does not specify whether newly added skills need a new session, and it documents no skills-list command.
- 04
In a terminal, install the collection as a Gemini CLI extension.
gemini extensions install https://github.com/samber/cc-skills-golang - 05
Restart your Gemini CLI session to load the extension.
Check that cc-skills-golang appears in Gemini CLI's installed extensions list.
- 04
In a terminal, clone the collection into your OpenClaw skills directory.
git clone https://github.com/samber/cc-skills-golang.git ~/.openclaw/skills/cc-skills-golang - 05
Start a new OpenClaw session so its skill discovery includes the collection.
Use OpenClaw's available-skills list to check for golang-how-to.