Development
Plugin
cc-skills-golang
AI agent skills are reusable instruction sets that extend your coding assistant with domain-specific expertise, loaded on demand so they don't bloat your context. This repository covers Go-specific skills only (language, testing, security, observability, etc.)
Plugin Signal88/100Strong
maintained95
capable80
documented100
adopted74
Install
$ npx -y skills add samber/cc-skills-golang --agent claude-code
Run the curl in your terminal, the rest in Claude Code.
In this plugin
- golang-benchmark
- golang-cli
- golang-code-style
- golang-concurrency
- golang-context
- golang-continuous-integration
- golang-data-structures
- golang-database
- golang-dependency-injection
- golang-dependency-management
- golang-design-patterns
- golang-documentation
- golang-error-handling
- golang-google-wire
- golang-gopls
- golang-graphql
- golang-grpc
- golang-how-to
- golang-lint
- golang-modernize
- golang-naming
- golang-observability
- golang-performance
- golang-pkg-go-dev
- golang-popular-libraries
- golang-project-layout
- golang-refactoring
- golang-safety
- golang-samber-do
- golang-samber-hot
- golang-samber-lo
- golang-samber-mo
- golang-samber-oops
- golang-samber-ro
- golang-samber-slog
- golang-security
- golang-spf13-cobra
- golang-spf13-viper
- golang-stay-updated
- golang-stretchr-testify
- golang-structs-interfaces
- golang-swagger
- golang-testing
- golang-troubleshooting
- golang-uber-dig
- golang-uber-fx
What's inside
Skills
46/golang-benchmarkGolang benchmarking, profiling, and performance measurement. Use when writing, running, or comparing Go benchmarks, profiling hot paths with pprof, interpreting CPU/memory/trace profiles, analyzing results with benchstat, setting up CI benchmark regression detection, or/golang-cliGolang CLI application development. Use when building, modifying, or reviewing a Go CLI tool — especially for command structure, flag handling, configuration layering, version embedding, exit codes, I/O patterns, signal handling, shell completion, argument validation, and CLI/golang-code-styleGolang code style conventions — line length and breaking, variable declarations, control flow clarity, when comments help vs hurt. Use when writing or reviewing Go code, asking about style or clarity, or establishing project coding standards. Not for naming conventions (→ See/golang-concurrencyGolang concurrency patterns. Use when writing or reviewing concurrent Go code involving goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, or fan-out/fan-in pipelines. Also triggers when you detect goroutine leaks, race conditions,/golang-contextIdiomatic context.Context usage in Golang — propagation through API boundaries, cancellation, timeouts and deadlines, request-scoped values, context.WithoutCancel for background work outliving requests. Apply when designing context propagation across layers, debugging leaked or/golang-continuous-integrationCI/CD pipeline configuration using GitHub Actions for Golang projects — testing, linting, SAST, security scanning, code coverage, Dependabot, Renovate, GoReleaser, code review automation, and release pipelines. Use when setting up or improving Go project CI, configuring GitHub
Show all 46 skillsShow fewer
/golang-data-structuresGolang data structures — slices (internals, capacity growth, preallocation, slices package), maps (internals, hash buckets, maps package), arrays, container/list/heap/ring, strings.Builder vs bytes.Buffer, generic collections, pointers (unsafe.Pointer, weak.Pointer), and copy/golang-databaseComprehensive guide for Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context propagation, and migration tooling. Use when writing, reviewing, or debugging/golang-dependency-injectionComprehensive guide for dependency injection (DI) in Golang. Covers why DI matters (testability, loose coupling, separation of concerns, lifecycle management), manual constructor injection, and DI library comparison (google/wire, uber-go/dig, uber-go/fx, samber/do). Use this/golang-dependency-managementDependency management strategies for Golang projects — go.mod management, installing/upgrading packages, Minimal Version Selection, vulnerability scanning, outdated dependency tracking, binary size analysis, Dependabot/Renovate setup, conflict resolution, and go.work workspaces./golang-design-patternsIdiomatic Golang design patterns — functional options, constructors, error flow and cascading, resource management and lifecycle, graceful shutdown, resilience, architecture, dependency injection, data handling, streaming, and more. Apply when explicitly choosing between/golang-documentationComprehensive documentation guide for Golang projects, covering godoc comments, README, CONTRIBUTING, CHANGELOG, Go Playground, Example tests, API docs, and llms.txt. Use when writing or reviewing doc comments, documentation, adding code examples, setting up doc sites, or/golang-error-handlingIdiomatic Golang error handling — creation, wrapping with %w, errors.Is/As, errors.Join, custom error types, sentinel errors, panic/recover, the single handling rule, structured logging with slog, HTTP request logging middleware, and samber/oops for production errors. Built to/golang-google-wireCompile-time dependency injection in Golang using google/wire — wire.NewSet, wire.Build, wire.Bind (interface→concrete), wire.Struct, wire.Value, wire.InterfaceValue, wire.FieldsOf, cleanup functions, //go:build wireinject injector files, and generated wire_gen.go. Apply when/golang-goplsGolang semantic code intelligence via `gopls`, the official Go language server — go-to-definition, find references, call/implementation hierarchy, workspace symbol search, package API discovery, diagnostics, safe rename, refactors (extract/inline/fill/rewrite code actions),/golang-graphqlImplements GraphQL APIs in Golang using gqlgen or graphql-go. Apply when building GraphQL servers, designing schemas, writing resolvers, handling subscriptions, or integrating GraphQL with existing Go HTTP services. Also apply when the codebase imports/golang-grpcProvides gRPC usage guidelines, protobuf organization, and production-ready patterns for Golang microservices. Use when implementing, reviewing, or debugging gRPC servers/clients, writing proto files, setting up interceptors, handling gRPC errors with status codes, configuring/golang-how-toGolang skills orchestrator — always active on any Golang coding, review, debug, or setup task. Reads the task context and loads the most relevant skills from samber/cc-skills-golang, often multiple at once: writing a gRPC service loads golang-grpc + golang-testing +/golang-lintLinting best practices and golangci-lint configuration for Golang projects — running linters, configuring .golangci.yml, suppressing warnings with nolint directives, interpreting lint output, and selecting linters. Use when configuring golangci-lint, asking about lint warnings/golang-modernizeModernize Golang code to use recent language features, standard library improvements, and idiomatic patterns. Trigger proactively when writing or reviewing Go code and old-style patterns are detected, or when encountering a deprecation warning. Also use when the user explicitly/golang-namingGo (Golang) naming conventions — covers packages, constructors, structs, interfaces, constants, enums, errors, booleans, receivers, getters/setters, functional options, acronyms, test functions, and subtest names. Use this skill when writing new Go code, reviewing or/golang-observabilityGolang everyday observability — the always-on signals in production. Covers structured logging with slog, Prometheus metrics, OpenTelemetry distributed tracing, continuous profiling with pprof/Pyroscope, server-side RUM event tracking, alerting, and Grafana dashboards. Apply/golang-performanceGolang performance optimization patterns and methodology - if X bottleneck, then apply Y. Covers allocation reduction, CPU efficiency, memory layout, GC tuning, pooling, caching, and hot-path optimization. Use when profiling or benchmarks have identified a bottleneck and you/golang-pkg-go-devGolang package and module documentation and exploration via `godig`, a pkg.go.dev API client (CLI + MCP server) — package docs, API references, symbols, code examples, available versions, importers (who imports a package), licenses, and known vulnerabilities. Read-only, no auth./golang-popular-librariesRecommends production-ready Golang libraries and frameworks. Apply when the user explicitly asks for library suggestions, wants to compare alternatives, needs to choose a library for a specific task, or when a new dependency is being added to the project./golang-project-layoutProvides a guide for setting up Golang project layouts and workspaces. Use when starting a new Go project, organizing an existing codebase, setting up a monorepo with multiple packages, creating CLI tools with multiple main packages, deciding between cmd/internal/pkg directory/golang-refactoringGolang refactoring — the safe, at-scale process for restructuring existing Go code: a coverage-adaptive safety net, tool-driven behavior-preserving transforms (gopls Rename/Inline/Extract, `gofmt -r`, `eg`, `gopatch`, `go/analysis` fixers), the Fowler catalog mapped to Go,/golang-safetyDefensive Golang coding to prevent panics, silent data corruption, and subtle runtime bugs. Use when encountering nil panics, append aliasing, map concurrent access, float comparison pitfalls, or zero-value design questions. Also use when reviewing code for nil-safety, numeric/golang-samber-doDependency injection in Golang using samber/do — service containers, lifecycle management, scopes, health checks, graceful shutdown, and module organization. Apply when using or adopting samber/do, when the codebase imports github.com/samber/do or github.com/samber/do/v2, or/golang-samber-hotIn-memory caching in Golang using samber/hot — eviction algorithms (LRU, LFU, TinyLFU, W-TinyLFU, S3FIFO, ARC, TwoQueue, SIEVE, FIFO), TTL, cache loaders, sharding, stale-while-revalidate, missing key caching, and Prometheus metrics. Apply when using or adopting samber/hot, when/golang-samber-loFunctional programming helpers for Golang using samber/lo — 500+ type-safe generic functions for slices, maps, channels, strings, math, tuples, and concurrency (Map, Filter, Reduce, GroupBy, Chunk, Flatten, Find, Uniq, etc.). Core immutable package (lo), concurrent variants/golang-samber-moMonadic types for Golang using samber/mo — Option, Result, Either, Future, IO, Task, and State types for type-safe nullable values, error handling, and functional composition with pipeline sub-packages. Apply when using or adopting samber/mo, when the codebase imports/golang-samber-oopsStructured error handling in Golang with samber/oops — error builders, stack traces, error codes, error context, error wrapping, error attributes, user-facing vs developer messages, panic recovery, and logger integration. Apply when using or adopting samber/oops, or when the/golang-samber-roReactive streams and event-driven programming in Golang using samber/ro — ReactiveX implementation with 150+ type-safe operators, cold/hot observables, 5 subject types (Publish, Behavior, Replay, Async, Unicast), declarative pipelines via Pipe, 40+ plugins (HTTP, cron, fsnotify,/golang-samber-slogStructured logging extensions for Golang using samber/slog-**** packages — multi-handler pipelines (slog-multi), log sampling (slog-sampling), attribute formatting (slog-formatter), HTTP middleware (slog-fiber, slog-gin, slog-chi, slog-echo), and backend routing (slog-datadog,/golang-securitySecurity best practices and vulnerability prevention for Golang. Covers injection (SQL, command, XSS), cryptography, filesystem safety, network security, cookies, secrets management, memory safety, and logging. Apply when writing, reviewing, or auditing Go code for security, or/golang-spf13-cobraGolang CLI command tree library using spf13/cobra — cobra.Command, RunE vs Run, PersistentPreRunE hook chain, Args validators (NoArgs, ExactArgs, MatchAll, custom), persistent vs local flags, command groups, ValidArgsFunction, RegisterFlagCompletionFunc, ShellCompDirective,/golang-spf13-viperGolang configuration library using spf13/viper — layered precedence (flag > env > file > KV > default), BindPFlag/BindPFlags, SetEnvPrefix + SetEnvKeyReplacer + AutomaticEnv, ReadInConfig + ConfigFileNotFoundError, Unmarshal + mapstructure struct tags, Sub for sub-trees,/golang-stay-updatedProvides resources to stay updated with Golang news, communities and people to follow. Use when seeking Go learning resources, discovering new libraries, finding community channels, or keeping up with Go language changes and releases./golang-stretchr-testifyComprehensive guide to stretchr/testify for Golang testing. Covers assert, require, mock, and suite packages in depth. Use when writing tests with testify, creating mocks, setting up test suites, or choosing between assert and require. Covers testify assertions, mock/golang-structs-interfacesGolang struct and interface design patterns — composition, embedding, type assertions, type switches, interface segregation, dependency injection via interfaces, struct field tags, and pointer vs value receivers. Use this skill when designing Go types, defining or implementing/golang-swaggerGolang OpenAPI/Swagger documentation with swaggo/swag — annotation comments (@Summary, @Param, @Success, @Router, @Security), swag init code generation, framework integrations (gin, echo, fiber, chi, net/http), security definitions (Bearer/JWT, OAuth2, API key), and struct tags/golang-testingProduction-ready Golang tests — table-driven tests, testify suites and mocks, parallel tests, fuzzing, fixtures, goroutine leak detection with goleak, snapshot testing, code coverage, integration tests, idiomatic test naming. Use when writing or reviewing Go tests, choosing a/golang-troubleshootingTroubleshoot Golang programs systematically - find and fix the root cause. Use when encountering bugs, crashes, deadlocks, or unexpected behavior in Go code. Covers debugging methodology, common Go pitfalls, test-driven debugging, pprof setup and capture, Delve debugger, race/golang-uber-digImplements dependency injection in Golang using uber-go/dig — reflection-based container, Provide/Invoke, dig.In/dig.Out parameter and result objects, named values, value groups, optional dependencies, scopes, and Decorate. Apply when using or adopting uber-go/dig, when the/golang-uber-fxGolang application framework using uber-go/fx — fx.New, fx.Provide, fx.Invoke, fx.Module, fx.Lifecycle hooks, fx.Annotate (name/group/As), fx.Decorate, fx.Supply, fx.Replace, fx.WithLogger, and signal-aware Run(). Apply when using or adopting uber-go/fx, when the codebase
README
1Agent Skills for production-ready Golang projects
AI agent skills are reusable instruction sets that extend your coding assistant with domain-specific expertise, loaded on demand so they don't bloat your context. This repository covers Go-specific skills only (language, testing, security, observability, etc.); for dev workflow skills (git conventions, CI/CD, PR reviews) you'll want to add a separate skills plugin.
For generic skills, please visit cc-skills.
[!IMPORTANT] Bootstrapped with Claude Code by distilling my Go project commits. Edited, tested, reviewed and reworked by a human.
No AI slop here. AI-made skills are useless.
🚀 How to use
Install with skills CLI (universal, works with any Agent Skills-compatible tool):
npx skills add https://github.com/samber/cc-skills-golang --all
# or a single skill:
npx skills add https://github.com/samber/cc-skills-golang --skill golang-performance
/plugin marketplace add samber/cc
/plugin install cc-skills-golang@samber
Copy skills into the cross-client discovery directory:
git clone https://github.com/samber/cc-skills-golang.git ~/.openclaw/skills/cc-skills-golang
# or in workspace:
git clone https://github.com/samber/cc-skills-golang.git ~/.openclaw/workspace/skills/cc-skills-golang
gemini extensions install https://github.com/samber/cc-skills-golang
Update with gemini extensions update cc-skills-golang.
Copy skills into the cross-client discovery directory:
git clone https://github.com/samber/cc-skills-golang.git ~/.cursor/skills/cc-skills-golang
Cursor auto-discovers skills from .agents/skills/ and .cursor/skills/.
Copy skills into the cross-client discovery directory:
/plugin install https://github.com/samber/cc-skills-golang
# or
git clone https://github.com/samber/cc-skills-golang.git ~/.copilot/skills/cc-skills-golang
Copilot auto-discovers skills from .copilot/skills/.
Copy skills into the cross-client discovery directory:
git clone https://github.com/samber/cc-skills-golang.git ~/.agents/skills/cc-skills-golang
OpenCode auto-discovers skills from .agents/skills/, .opencode/skills/, and .claude/skills/.
Clone into the cross-client discovery path:
git clone https://github.com/samber/cc-skills-golang.git ~/.agents/skills/cc-skills-golang
Codex auto-discovers skills from ~/.agents/skills/ and .agents/skills/. Update with cd ~/.agents/skills/cc-skills-golang && git pull.
Clone and symlink into the cross-client discovery path:
git clone https://github.com/samber/cc-skills-golang.git ~/.antigravity/skills/cc-skills-golang
Update with cd ~/.antigravity/skills/cc-skills-golang && git pull.
🧩 Skills
These skills are designed as atomic, cross-referencing units. A skill may reference conventions defined in another (e.g. error-handling rules that affect logging live in golang-error-handling, not golang-observability). Installing only a subset will give you a partial and potentially inconsistent view of the guidelines. For best results, install all general-purpose skills together.
┌────────────────────────────────────────┐
│ Golang Skills │
└──────────────────┬─────────────────────┘
│
┌─────────────────┬──────────────────────┼──────────────────────┐
▼ ▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌─────────────────┐ ┌──────────────────────┐
│ Code Quality │ │ Arch & Design│ │ QA & Perf │ │ Project Start │
├──────────────┤ ├──────────────┤ ├─────────────────┤ ├──────────────────────┤
│ code-style │ │ design-patt │ │ testing │ │ project-layout │
│ naming │ │ concurrency │ │ benchmark │ │ popular-libs │
│ error-handl │ │ context │ │ performance │ │ cli │
│ safety │ │ dep-inject │ │ troubleshoot │ │ continuous-integ. │
│ structs-iface│ │ data-structs │ │ observability │ │ stay-updated │
│ documentation│ │ database │ │ │ │ dep-management │
│ lint │ │ modernize │ │ │ │ gopls │
│ security │ │ refactoring │ │ │ │ pkg-go-dev │
└──────────────┘ └──────────────┘ └─────────────────┘ └──────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ Framework / Library Skills │
├──────────────┬────────────────┬──────────────┬─────────────┬───────────┤
│ APIs │ DI │ Frameworks │ samber/* │ Testing │
├──────────────┼────────────────┼──────────────┼─────────────┼───────────┤
│ grpc │ google-wire │ spf13-cobra │ samber-lo │ stretchr- │
│ graphql │ uber-dig │ spf13-viper │ samber-mo │ testify │
│ swagger │ uber-fx │ │ samber-ro │ │
│ │ │ │ samber-do │ │
│ │ │ │ samber-hot │ │
│ │ │ │ samber-slog │ │
│ │ │ │ samber-oops │ │
└──────────────┴────────────────┴──────────────┴─────────────┴───────────┘
- ⭐️ Recommended
- ✅ Published
- 👷 Work in progress
- ❌ To-do
- ⚡ Command available
- 🧠 Ultrathink automatically
- 🤖 Ultracode automatically
- ⚙️ Overridable (see doc below)
- Description (tok): weight of the
descriptionfield from YAML frontmatter, always loaded into Claude's context for skill triggering - SKILL.md (tok): weight of the full
SKILL.mdfile loaded when the skill triggers - Directory (tok): weight of all files in the skill directory (SKILL.md + referenced markdown files)
General purpose:
| Skill | Flags | Error rate gap | Description (tok) | SKILL.md (tok) | Directory (tok) | |
|---|---|---|---|---|---|---|
| ⭐️ | ✅ golang-code-style | ⚡ 🤖 ⚙️ | -40% | 115 | 2,341 | 2,957 |
| ⭐️ | ✅ golang-data-structures | ⚡ | -39% | 93 | 2,599 | 6,318 |
| ⭐️ | ✅ golang-database | ⚡ ⚙️ | -38% | 97 | 2,712 | 7,234 |
| ⭐️ | ✅ golang-design-patterns | ⚡ ⚙️ | -37% | 80 | 2,685 | 9,391 |
| ⭐️ | ✅ golang-documentation | ⚡ 🤖 ⚙️ | -53% | 75 | 3,078 | 11,177 |
| ⭐️ | ✅ golang-error-handling | ⚡ 🤖 ⚙️ | -26% | 141 | 1,718 | 4,677 |
| ⭐️ | ✅ golang-how-to | ⚡ | — | 165 | 4,017 | 13,853 |
| ⭐️ | ✅ golang-modernize | ⚡ 🤖 | -61% | 68 | 2,920 | 9,233 |
| ⭐️ | ✅ golang-naming | ⚡ ⚙️ | -23% | 159 | 3,022 | 7,390 |
| ⭐️ | ✅ golang-refactoring | ⚡ 🧠 🤖 ⚙️ | — | 246 | 3,708 | 20,216 |
| ⭐️ | ✅ golang-safety | ⚡ | -58% | 78 | 2,605 | 5,375 |
| ⭐️ | ✅ golang-testing | ⚡ 🧠 🤖 ⚙️ | -32% | 115 | 4,234 | 7,341 |
| ⭐️ | ✅ golang-troubleshooting | ⚡ 🧠 🤖 | -32% | 128 | 2,894 | 16,577 |
| ⭐️ | ✅ golang-security | ⚡ 🧠 🤖 | -32% | 85 | 3,160 | 21,596 |
✅ golang-benchmark | ⚡ 🧠 | -50% | 102 | 3,042 | 30,224 | |
✅ golang-cli | ⚡ | -43% | 125 | 2,329 | 6,144 | |
✅ golang-concurrency | ⚡ 🤖 ⚙️ | -39% | 72 | 2,180 | 6,810 | |
✅ golang-context | ⚡ ⚙️ | -34% | 82 | 1,202 | 4,012 | |
✅ golang-continuous-integration | ⚡ | -59% | 82 | 3,291 | 12,553 | |
✅ golang-dependency-injection | ⚡ 🤖 ⚙️ | -47% | 178 | 2,994 | 5,265 | |
✅ golang-dependency-management | ⚡ | -54% | 77 | 2,361 | 5,499 | |
✅ golang-structs-interfaces | ⚡ ⚙️ | -35% | 111 | 3,067 | 3,067 | |
✅ golang-lint | ⚡ 🤖 | -41% | 98 | 1,853 | 6,181 | |
✅ golang-observability | ⚡ 🤖 ⚙️ | -37% | 164 | 3,096 | 18,583 | |
✅ golang-performance | ⚡ 🧠 🤖 | -39% | 130 | 2,190 | 18,190 | |
✅ golang-gopls | ⚡ | — | 219 | 2,308 | 12,188 | |
✅ golang-pkg-go-dev | ⚡ | — | 230 | 3,428 | 5,242 | |
✅ golang-popular-libraries | ⚡ | -30% | 51 | 1,044 | 4,438 | |
✅ golang-project-layout | ⚡ | -38% | 69 | 1,563 | 5,778 | |
✅ golang-stay-updated | ⚡ | -56% | 44 | 1,801 | 1,801 |
Tools:
| Skill | Flags | Error rate gap | Description (tok) | SKILL.md (tok) | Directory (tok) |
|---|---|---|---|---|---|
✅ golang-google-wire | ⚡ | -16% | 122 | 2,661 | 7,391 |
✅ golang-graphql | -16% | 76 | 3,061 | 7,932 | |
✅ golang-grpc | ⚡ | -41% | 70 | 2,332 | 5,148 |
✅ golang-spf13-cobra | ⚡ | — | 176 | 2,571 | 7,342 |
✅ golang-spf13-viper | ⚡ | — | 170 | 2,542 | 7,089 |
✅ golang-swagger | ⚡ | — | 144 | 2,333 | 3,338 |
✅ golang-uber-dig | ⚡ | -10% | 107 | 2,576 | 6,248 |
✅ golang-uber-fx | ⚡ | -5% | 118 | 2,816 | 7,051 |
✅ golang-samber-do | ⚡ | -81% | 71 | 1,877 | 3,392 |
✅ golang-samber-hot | ⚡ | -54% | 119 | 1,977 | 7,407 |
✅ golang-samber-lo | ⚡ | -40% | 167 | 2,601 | 10,279 |
✅ golang-samber-mo | ⚡ 🧠 | -48% | 82 | 2,943 | 11,358 |
✅ golang-samber-oops | ⚡ | -59% | 70 | 2,535 | 2,847 |
✅ golang-samber-ro | ⚡ 🧠 | -50% | 154 | 2,952 | 11,168 |
✅ golang-samber-slog | ⚡ | -19% | 119 | 3,111 | 9,833 |
❌ golang-temporal | — | 0 | 0 | 0 | |
✅ golang-stretchr-testify | ⚡ | -47% | 92 | 1,849 | 2,668 |
🧪 Skill evaluations
| With Skill | Without Skill | Delta | |
|---|---|---|---|
| Overall | 3315/3395 (98%) | 1915/3395 (56%) | +41pp |
See EVALUATIONS.md for the full per-skill breakdown.
📖 Skills description
Code Quality
golang-code-style
Go code formatting and conventions. gofmt, goimports, linting rules, comment conventions, and project-level style consistency. Overridable by company skills.
golang-documentation
Go documentation standards. Package docs, godoc conventions, code comments, example functions, README structure, and API reference generation. Overridable.
golang-error-handling
Go error handling best practices. Error creation, wrapping with fmt.Errorf and errors.Is/As, sentinel errors, custom error types, error codes, and panic recovery. Overridable.
golang-lint
Go linting best practices and golangci-lint configuration. Presets, custom rules, CI integration, inline suppression, and output interpretation.
golang-naming
Go naming conventions across all identifier types. Packages, constructors, structs, interfaces, constants, errors, receivers, acronyms, test functions. Covers MixedCaps rules, Get-prefix, and utils/helpers anti-patterns. Overridable.
golang-safety
Defensive Go coding. Prevents panics, silent data corruption, and runtime bugs. nil safety, append aliasing, map concurrent access, float comparison, zero-value design, numeric overflow.
golang-security
Go security best practices. Injection prevention (SQL, command, XSS), cryptography, filesystem/network safety, secrets management, cookie security, and tool configuration. Audit and review modes.
golang-structs-interfaces
Go struct and interface design. Composition, embedding, type assertions, interface segregation, struct tags (JSON/YAML/DB), pointer vs value receivers. Overridable.
Architecture & Design
golang-concurrency
Go concurrency patterns. Goroutines, channels, sync primitives, context cancellation, worker pools, fan-out/fan-in, pipelines. Overridable.
golang-context
Idiomatic context.Context usage. Creation, cancellation, timeouts, values, propagation patterns, and common anti-patterns. Overridable.
golang-data-structures
Go data structures internals and usage. Slices (capacity growth, append aliasing), maps, channels, sync primitives, and when to use each.
golang-database
Go database access patterns. Parameter binding, connection pooling, transactions, migrations, sqlboiler/sqlc code generation, query builders. Overridable.
golang-dependency-injection
Dependency injection patterns in Go. Constructor injection, interface-based DI, wire/dig/fx comparison, and when DI is worth the complexity. Overridable.
golang-design-patterns
Idiomatic Go design patterns. Functional options, constructors, builder pattern, middleware chains, circuit breaker, and architecture guides with file trees and code. Overridable.
golang-modernize
Modernize Go code to use recent language features. Range-over-int, min/max builtins, iterators, slices/maps/cmp/slog stdlib packages, testing patterns (t.Context, b.Loop, synctest), and tooling upgrades.
golang-refactoring
Safe, at-scale refactoring process for existing Go code. Coverage-adaptive safety net, tool-driven behavior-preserving transforms (gopls Rename/Inline/Extract, gofmt -r, eg, gopatch), the Fowler catalog mapped to Go, breaking import cycles, type-alias gradual code repair, and a human-in-the-loop workflow of staged PRs on a refactoring branch.
QA & Performance
golang-benchmark
Go benchmarking, profiling, and performance measurement. pprof, trace, CPU/memory/block profiles, flame graphs, benchmark comparison (benchstat), continuous profiling.
golang-observability
Go production observability. Structured logging (slog), Prometheus metrics, OpenTelemetry tracing, pprof profiling, RUM tracking, alerting, Grafana dashboards. Overridable.
golang-performance
Go performance optimization. Allocation reduction, CPU efficiency, memory layout, GC tuning, pooling, caching, hot-path optimization. Review and hot-path modes.
golang-testing
Production-ready Go tests. Table-driven tests, fuzzing, fixtures, goroutine leak detection (goleak), snapshot testing, code coverage, integration tests, parallel tests. Overridable.
golang-troubleshooting
Systematic Go debugging methodology. Common pitfalls, test-driven debugging, pprof capture, Delve debugger, race detection, GODEBUG tracing, production debugging.
Project Setup
golang-cli
Go CLI application development. Project layout, exit codes, signal handling, I/O patterns, argument parsing, and terminal UX.
golang-continuous-integration
CI/CD pipeline configuration for Go projects using GitHub Actions. Build, test, lint, and release workflows.
golang-dependency-management
Go module dependency strategies. go.mod conventions, versioning, replace directives, tool dependencies, and multi-module workspaces.
golang-gopls
Semantic code intelligence for your local build via gopls, the official Go language server. Go-to-definition, find references, call/implementation hierarchy, workspace symbol search, diagnostics, safe rename, and refactors (extract/inline/fill/rewrite). Reachable via gopls's own MCP server, Claude Code's native LSP tool, or the gopls CLI.
golang-pkg-go-dev
Go package and module exploration via godig, a pkg.go.dev API client (CLI + MCP server). Package docs, API references, symbols, code examples, versions, importers, licenses, and known vulnerabilities. Prefer over Context7 for Go packages.
golang-popular-libraries
Curated recommendations for production-ready Go libraries and frameworks. When the stdlib is enough vs when to reach for a package.
golang-project-layout
Go project structure and workspace setup. cmd/internal/pkg conventions, monorepo layout, CLI project structure, and when to keep things flat.
golang-stay-updated
Resources to stay current with Go. Official channels, community hubs, key people to follow, and learning resources.
APIs
golang-graphql
GraphQL API development in Go using gqlgen/graphql-go. Schema definition, resolvers, subscriptions, dataloader, and federation.
golang-grpc
gRPC in Go. Protobuf organization, service definitions, streaming, interceptors, error codes, and code generation workflow.
golang-swagger
OpenAPI/Swagger docs with swaggo/swag. Annotation comments, code generation, framework integrations (gin, echo, fiber, chi), security definitions.
Dependency Injection
golang-google-wire
Compile-time dependency injection with google/wire. Provider sets, injector generation, wire.Build, and structured DI patterns.
golang-uber-dig
Reflection-based DI with uber-go/dig. Provide/Invoke, dig.In/dig.Out, named values, value groups, optional dependencies, and Decorate.
golang-uber-fx
Application framework with uber-go/fx. fx.New, fx.Provide/Invoke, fx.Module, lifecycle hooks, fx.Annotate, fx.Decorate, signal-aware Run.
Frameworks
golang-spf13-cobra
CLI command trees with spf13/cobra. Command hierarchy, RunE hooks, flag management, shell completion, usage templates, and testing with SetArgs.
golang-spf13-viper
Layered configuration with spf13/viper. Flag > env > file > KV > default precedence, BindPFlag, hot reload, test isolation, and remote KV integration.
samber/*
golang-samber-do
Dependency injection with samber/do. Type-safe service containers, lifecycle management, scopes, health checks, and graceful shutdown.
golang-samber-hot
In-memory caching with samber/hot. 9 eviction algorithms (LRU, LFU, TinyLFU, W-TinyLFU, S3FIFO, ARC, SIEVE...), TTL, loaders, sharding, stale-while-revalidate, Prometheus metrics.
golang-samber-lo
Functional programming helpers with samber/lo. 500+ type-safe generic functions for slices, maps, channels, strings. Immutable (lo), parallel (lop), mutable (lom), iterators (loi), SIMD.
golang-samber-mo
Monadic types with samber/mo. Option, Result, Either, Future, IO, Task, State for type-safe nullable values, error handling, and functional composition.
golang-samber-oops
Structured error handling with samber/oops. Error builders, stack traces, error codes, context attributes, public vs developer messages, panic recovery, and APM integration.
golang-samber-ro
Reactive streams with samber/ro. 150+ type-safe operators, cold/hot observables, 5 subject types, 40+ plugins, automatic backpressure, and Go context integration.
golang-samber-slog
Structured logging pipeline with samber/slog-**** packages. Multi-handler routing (slog-multi), sampling, formatting, HTTP middleware, and 20+ backend sinks.
Testing
golang-stretchr-testify
Testing with stretchr/testify. assert, require, mock, and suite packages. Assertions, mock expectations, argument matchers, suite lifecycle, and custom matchers.
🕵 Use in CI for AI-driven reviews
Add AI agents as PR reviewers alongside traditional static analysis. When configured with this skill plugin, the agent applies the relevant Go skills per review area — catching architectural drift, logic bugs, and concurrency hazards that linters cannot detect.
See GOLANG-AI-DRIVEN-REVIEW.md for full setup instructions (Claude Code Action and GitHub Copilot).
🎯 Tuning Skill Triggers
If a skill triggers too often or not often enough, please open an issue suggesting a description change. The description field in SKILL.md frontmatter is the primary triggering mechanism — small wording adjustments can significantly improve trigger accuracy. Some SKILL.md files might have a When to use section which is another level of exclusion. Finally, SKILL.md files are an entrypoint for lazy loading references with deep knowledge located in references/.
🔄 Overlap
Claude reports very little overlap between skills in this repo, thanks to cross-reference. I suggest enabling most of the skills and leveraging lazy loading. The recommended ⭐️ skills load ~1,100 tokens of descriptions at startup; full skill content is only pulled in when relevant. Note:
- I estimate that 50% of
golang-namingandgolang-code-styleoverlap with linters (golangci-lint). - A large part of the security rules in
golang-securityhave been distilled from the Bearer (SAST) checklist. The skill is still useful for methodology. - If your team has its own conventions, create a company skill and declare the override explicitly near the top of its body:
This skill supersedes samber/cc-skills-golang@golang-naming skill for [company] projects.Skills marked ⚙️ in the table above support this mechanism.
✍️ Contribute
- 100 tokens per skill description - what? when to use this skill?
- 1.000–2.500 tokens per SKILL.md — keep the main file focused on essentials
- Use secondary markdown files for depth — reference them from SKILL.md with relative links (e.g.,
[Logging](./logging.md)). Claude reads these on demand when the topic is relevant, so they don't count against the context budget until needed - Up to 10.000 tokens for full skill and secondary files
- 2–4 skills loaded simultaneously in a typical session — design skills to coexist
- Stay below ~10k tokens of total loaded SKILL.md anytime to avoid degrading response quality
For more guidelines, please check CLAUDE.md.
💫 Fuel the Revolution
- ⭐️ Star this repo - Your star powers the caffeine engine!
- ☕️ Buy me a coffee - I'll literally use it to build more skills while drinking actual coffee
📝 License
Copyright © 2026 Samuel Berthe.
This project is under MIT license.
File tree
313samber/cc-skills-golangView on GitHub
.claude-plugin/
plugin.json
.cursor-plugin/
plugin.json
.github/
dependabot.yml
FUNDING.yml
workflows/
dependabot-automerge.yaml
lint.yml
publish-clawhub.yml
security-scan.yml
update-library-skill.yml
update-modernize-skill.yml
validate.yml
.gitignore
.markdownlint-cli2.jsonc
.prettierrc
CLAUDE.md
clawhub-publish.sh
EVALUATIONS.md
gemini-extension.json
GOLANG-AI-DRIVEN-REVIEW.md
LICENSE
README.md
skills/
golang-benchmark/
evals/
evals.json
references/
benchstat.md
ci-regression.md
compiler-analysis.md
investigation-session.md
pprof.md
prometheus-go-metrics.md
tools.md
trace.md
SKILL.md
golang-cli/
assets/
examples/
args.go
cli_test.go
completion.go
config.go
exit_codes.go
flags.go
main.go
output.go
root.go
serve.go
signal.go
version.go
evals/
evals.json
SKILL.md
golang-code-style/
evals/
evals.json
references/
details.md
SKILL.md
golang-concurrency/
evals/
evals.json
references/
channels-and-select.md
pipelines.md
sync-primitives.md
SKILL.md
golang-context/
evals/
evals.json
references/
cancellation.md
http-services.md
values-tracing.md
SKILL.md
golang-continuous-integration/
assets/
claude-code-review.yml
codecov.yml
codeql-config.yml
copilot-review-instructions.md
dependabot-auto-merge.yml
dependabot.yml
docker.yml
goreleaser-cli.yml
goreleaser-lib.yml
goreleaser-monorepo.yml
integration.yml
lint.yml
release.yml
renovate.json
security.yml
test.yml
evals/
evals.json
references/
repo-security.md
SKILL.md
golang-data-structures/
evals/
evals.json
references/
containers.md
generics.md
map-internals.md
pointers.md
slice-internals.md
SKILL.md
golang-database/
evals/
evals.json
references/
performance.md
scanning.md
testing.md
transactions.md
SKILL.md
golang-dependency-injection/
evals/
evals.json
references/
google-wire.md
manual-di.md
samber-do.md
uber-dig-fx.md
SKILL.md
golang-dependency-management/
evals/
evals.json
references/
auditing.md
automated-updates.md
conflicts.md
versioning.md
visualization.md
workspaces.md
SKILL.md
golang-design-patterns/
evals/
evals.json
references/
architecture.md
clean-architecture.md
data-handling.md
ddd.md
hexagonal-architecture.md
resource-management.md
SKILL.md
golang-documentation/
assets/
templates/
CHANGELOG.md
CONTRIBUTING.md
llms.txt
README.md
evals/
evals.json
references/
application.md
code-comments.md
library.md
project-docs.md
SKILL.md
golang-error-handling/
evals/
evals.json
references/
error-creation.md
error-handling.md
error-wrapping.md
SKILL.md
golang-google-wire/
evals/
evals.json
references/
advanced.md
recipes.md
testing.md
SKILL.md
golang-gopls/
references/
cli.md
features.md
matrix.md
mcp.md
settings.md
SKILL.md
golang-graphql/
evals/
evals.json
references/
gqlgen.md
graphql-go.md
testing.md
SKILL.md
golang-grpc/
evals/
evals.json
references/
protoc-reference.md
testing.md
SKILL.md
golang-how-to/
references/
by-category.md
disambiguation.md
project-config.md
SKILL.md
golang-lint/
assets/
.golangci.yml
evals/
evals.json
references/
linter-reference.md
nolint-directives.md
SKILL.md
golang-modernize/
evals/
evals.json
references/
tooling.md
versions.md
SKILL.md
golang-naming/
evals/
evals.json
references/
functions-methods.md
identifiers.md
packages-files.md
testing.md
types-errors.md
SKILL.md
golang-observability/
evals/
evals.json
references/
alerting.md
dashboards.md
logging.md
metrics.md
profiling.md
rum.md
tracing.md
SKILL.md
golang-performance/
assets/
prometheus-alerts.yml
evals/
evals.json
references/
caching.md
cpu.md
io-networking.md
memory.md
observability.md
runtime.md
SKILL.md
golang-pkg-go-dev/
references/
sample-output.md
SKILL.md
golang-popular-libraries/
evals/
evals.json
references/
libraries.md
stdlib.md
tools.md
SKILL.md
golang-project-layout/
assets/
.gitignore
Makefile
evals/
evals.json
references/
config.md
directory-layouts.md
testing-layout.md
workspaces.md
SKILL.md
golang-refactoring/
references/
catalog.md
go-tooling.md
safety-net.md
structural.md
workflow.md
SKILL.md
golang-safety/
evals/
evals.json
references/
nil-safety.md
slice-map-safety.md
SKILL.md
golang-samber-do/
evals/
evals.json
references/
advanced.md
testing.md
SKILL.md
golang-samber-hot/
evals/
evals.json
references/
algorithm-guide.md
api-reference.md
production-patterns.md
SKILL.md
golang-samber-lo/
evals/
evals.json
references/
advanced-patterns.md
api-reference.md
package-guide.md
SKILL.md
golang-samber-mo/
evals/
evals.json
references/
advanced-types.md
either.md
monads-guide.md
option.md
pipelines.md
result.md
SKILL.md
golang-samber-oops/
evals/
evals.json
references/
advanced.md
SKILL.md
golang-samber-ro/
evals/
evals.json
references/
operators-guide.md
patterns.md
plugin-ecosystem.md
subjects-guide.md
SKILL.md
golang-samber-slog/
evals/
evals.json
references/
backend-handlers.md
http-middlewares.md
pipeline-patterns.md
sampling-strategies.md
SKILL.md
golang-security/
evals/
evals.json
references/
architecture.md
checklist.md
cookies.md
cryptography.md
filesystem.md
injection.md
logging.md
memory-safety.md
network.md
secrets.md
third-party.md
threat-modeling.md
SKILL.md
golang-spf13-cobra/
evals/
evals.json
references/
commands-and-args.md
completions.md
flags.md
generators.md
testing.md
SKILL.md
golang-spf13-viper/
evals/
evals.json
references/
binding-and-env.md
sources-and-formats.md
testing-and-isolation.md
unmarshal.md
watch-and-reload.md
SKILL.md
golang-stay-updated/
evals/
evals.json
... 57 moreFAQ
cc-skills-golang is a Claude Code plugin with 46 hand-picked skills for development work, indexed on Flowy. Install it with the command on its page. It includes golang-benchmark, golang-cli, golang-code-style. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.
- What is cc-skills-golang?
- AI agent skills are reusable instruction sets that extend your coding assistant with domain-specific expertise, loaded on demand so they don't bloat your context. This repository covers Go-specific skills only (language, testing, security, observability, etc.)
- How do I install cc-skills-golang?
- Run these in Claude Code: npx -y skills add samber/cc-skills-golang --agent claude-code. Then prompt normally.
- Does cc-skills-golang auto-invoke its skills?
- Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.
- Is cc-skills-golang free?
- Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.