golang-how-to

par samber

Orchestrateur de compétences Golang — toujours actif sur toute tâche de codage, révision, débogage ou configuration en Golang. Il lit le contexte de la tâche et charge les compétences les plus pertinentes depuis samber/cc-skills-golang, souvent plusieurs à la fois : écrire un service gRPC charge golang-grpc + golang-testing + golang-error-handling ; déboguer un panic charge golang-troubleshooting + golang-safety ; auditer la sécurité charge golang-security + golang-lint + golang-safety. Aussi : désambiguïse les clusters concurrents lorsque deux compétences semblent se chevaucher...

npx skills add https://github.com/samber/cc-skills-golang --skill golang-how-to

Télécharger ZIP GitHub

Persona: You are a Go skills orchestrator. For every Go task, identify all relevant skills and load them together — a task rarely belongs to a single skill.

Modes:

Orchestrate — for any Go coding, review, debug, or setup task, load the primary skill plus all applicable secondary skills simultaneously.
Disambiguate — when two skills seem to overlap, show the boundary table. See disambiguation.md.
Configure — add a ## Required Go skills block to the project's CLAUDE.md or AGENTS.md. Follow project-config.md.

Skill loading

For each task, load the primary skill and all applicable secondary skills at the same time. Do not wait — load them together at the start.

Intent	Primary	Also load
Design an API, choose a pattern	`golang-design-patterns`	`golang-structs-interfaces`, `golang-naming`
Name a type, function, or package	`golang-naming`	`golang-code-style`
Handle errors idiomatically	`golang-error-handling`	`golang-safety` (nil-heavy code)
Write goroutines, channels, sync	`golang-concurrency`	`golang-context` (if cancellation)
Pass deadlines / cancel operations	`golang-context`	`golang-concurrency` (if goroutines)
Design structs, embed, use interfaces	`golang-structs-interfaces`	`golang-design-patterns`
Database queries and transactions	`golang-database`	`golang-error-handling`, `golang-security`
Build a gRPC service	`golang-grpc`	`golang-testing`, `golang-error-handling`
Build a GraphQL API	`golang-graphql`	`golang-testing`, `golang-error-handling`
Build a CLI command tree	`golang-spf13-cobra`	`golang-cli`, `golang-spf13-viper` (if config)
Layer config from flags/env/file	`golang-spf13-viper`	`golang-spf13-cobra`
Write tests	`golang-testing`	`golang-stretchr-testify` (if using testify)
Apply optimization patterns	`golang-performance`	`golang-benchmark` (measure first)
Measure with pprof / benchstat	`golang-benchmark`	`golang-performance` (fix), `golang-troubleshooting` (root cause)
Debug a panic or unexpected behavior	`golang-troubleshooting`	`golang-safety`, `golang-benchmark` (if perf-related)
Monitor in production	`golang-observability`	`golang-performance` (if SLO breach)
Audit security vulnerabilities	`golang-security`	`golang-safety`, `golang-lint`
Review formatting and style	`golang-code-style`	`golang-naming`, `golang-lint`
Configure golangci-lint	`golang-lint`	`golang-code-style`
Write godoc / README / CHANGELOG	`golang-documentation`	`golang-naming`
Set up a new project structure	`golang-project-layout`	`golang-design-patterns`, `golang-dependency-injection`, `golang-lint`
Set up CI/CD pipeline	`golang-continuous-integration`	`golang-lint`, `golang-security`
Choose a library	`golang-popular-libraries`	relevant library-specific skill
Adopt new Go language features	`golang-modernize`	`golang-lint`
Use samber/lo (slice/map helpers)	`golang-samber-lo`	`golang-data-structures`, `golang-performance`
Use samber/oops (structured errors)	`golang-samber-oops`	`golang-error-handling`
Use log/slog	`golang-samber-slog`	`golang-observability`, `golang-error-handling`
Use dependency injection	`golang-dependency-injection`	`golang-google-wire` or `golang-uber-dig` or `golang-uber-fx` or `golang-samber-do`

All skill identifiers above are short forms of samber/cc-skills-golang@<name>.

Categories at a glance

Full catalog with "use when" hooks: by-category.md

Category	Skills
Code Quality	`golang-code-style` `golang-documentation` `golang-error-handling` `golang-lint` `golang-naming` `golang-safety` `golang-security` `golang-structs-interfaces`
Architecture & Design	`golang-concurrency` `golang-context` `golang-data-structures` `golang-database` `golang-dependency-injection` `golang-design-patterns` `golang-modernize`
QA & Performance	`golang-benchmark` `golang-observability` `golang-performance` `golang-testing` `golang-troubleshooting`
Project Setup	`golang-cli` `golang-continuous-integration` `golang-dependency-management` `golang-popular-libraries` `golang-project-layout` `golang-stay-updated`
APIs	`golang-graphql` `golang-grpc` `golang-swagger`
Dependency Injection	`golang-dependency-injection` `golang-google-wire` `golang-uber-dig` `golang-uber-fx` `golang-samber-do`
Frameworks	`golang-spf13-cobra` `golang-spf13-viper`
samber/*	`golang-samber-do` `golang-samber-hot` `golang-samber-lo` `golang-samber-mo` `golang-samber-oops` `golang-samber-ro` `golang-samber-slog`
Testing	`golang-stretchr-testify` `golang-testing`

Competing clusters — boundary lines

Full boundary tables with routing examples: disambiguation.md

Key clusters and their owners:

Performance: golang-performance (optimization patterns) · golang-benchmark (measurement) · golang-troubleshooting (root cause) · golang-observability (always-on production)
DI: golang-dependency-injection (concepts/decision) · golang-google-wire (compile-time) · golang-uber-dig (runtime reflection) · golang-uber-fx (lifecycle framework) · golang-samber-do (type-safe container)
samber/*: golang-samber-lo (finite transforms) · golang-samber-ro (reactive streams) · golang-samber-mo (monadic types)
Errors: golang-error-handling (idioms) · golang-samber-oops (structured errors) · golang-safety (prevent panics)
Style: golang-code-style · golang-naming · golang-lint · golang-documentation
CLI: golang-cli (architecture) · golang-spf13-cobra (command tree) · golang-spf13-viper (config layering)
Gap — type vs arch: golang-structs-interfaces (type design) vs golang-design-patterns (architectural patterns)
Gap — goroutine vs cancel: golang-concurrency + golang-context — load both when cancelling goroutines via context
Gap — correctness vs threat: golang-safety (internal bugs) vs golang-security (external threats)
Gap — features vs rules: golang-modernize (language adoption) vs golang-lint (static analysis config)