Golang How To

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.

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

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)

Configure mode

Force-trigger specific skills in a project's CLAUDE.md or AGENTS.md so they always load.

When invoked as /golang-how-to configure, follow project-config.md.

---

This skill is not exhaustive. Refer to individual skill files and the official Go documentation for detailed guidance.

If you encounter a bug or unexpected behavior in this skill plugin, open an issue at <https://github.com/samber/cc-skills-golang/issues>.

Golang skills — full catalog by category

42 skills. Skills marked ⭐️ are recommended for all Go projects. Skills marked ⚙️ can be superseded by a company-specific skill.

---

Code Quality

samber/cc-skills-golang@golang-code-style ⭐️ ⚙️

Golang code formatting, conventions, and project-level style consistency — gofmt, goimports, line length, var declarations, blank lines, comment heuristics.

Use when: the user asks about formatting rules, style review, or project coding standards. Not for naming conventions (→ golang-naming), linter configuration (→ golang-lint), or doc comments (→ golang-documentation).

---

samber/cc-skills-golang@golang-documentation ⭐️ ⚙️

Golang documentation standards — package docs, godoc conventions, example functions, README structure, CHANGELOG, llms.txt, API reference generation.

Use when: writing or reviewing Go doc comments, README files, or API reference. Not for code comments that explain logic (→ golang-code-style).

---

samber/cc-skills-golang@golang-error-handling ⭐️ ⚙️

Golang error handling best practices — error creation, wrapping with fmt.Errorf and errors.Is/As, sentinel errors, custom error types, panic recovery.

Use when: writing or reviewing error propagation, wrapping, logging, or recovery patterns. For samber/oops specifics → golang-samber-oops. For preventing panics → golang-safety.

---

samber/cc-skills-golang@golang-lint

Golang linting — golangci-lint configuration, presets, custom rules, CI integration, nolint suppressions, linter selection and output interpretation.

Use when: setting up or tuning golangci-lint, interpreting lint failures, or deciding which linters to enable. For style conventions not enforced by linters → golang-code-style.

---

samber/cc-skills-golang@golang-naming ⭐️ ⚙️

Golang 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.

Use when: naming a new type, function, package, or constant. Not for broader formatting (→ golang-code-style).

---

samber/cc-skills-golang@golang-safety ⭐️

Defensive Golang coding — prevents panics, silent data corruption, and runtime bugs. Nil safety, append aliasing, map concurrent access, float comparison, zero-value design, numeric overflow.

Use when: writing or reviewing code that could silently produce wrong results or panic. Not for external threats (→ golang-security) or error handling idioms (→ golang-error-handling).

---

samber/cc-skills-golang@golang-security ⭐️ 🧠

Golang security best practices — injection prevention (SQL, command, XSS), cryptography, filesystem/network safety, secrets management, cookie security, tool configuration. Audit and review modes.

Use when: auditing a codebase for vulnerabilities, writing security-sensitive code, or reviewing auth/crypto/secrets handling. Not for runtime correctness bugs (→ golang-safety).

---

samber/cc-skills-golang@golang-structs-interfaces ⚙️

Golang struct and interface design — composition, embedding, type assertions, interface segregation, struct tags (JSON/YAML/DB), pointer vs value receivers.

Use when: designing types, choosing between value vs pointer receivers, writing struct tags, or working with interface hierarchies. For architectural patterns that use interfaces → golang-design-patterns.

---

Architecture & Design

samber/cc-skills-golang@golang-concurrency ⚙️

Golang concurrency patterns — goroutines, channels, sync primitives, context cancellation, worker pools, fan-out/fan-in, pipelines, errgroup.

Use when: writing concurrent code, coordinating goroutines, or reviewing for race conditions. For context propagation specifically → golang-context. When cancelling goroutines via context — load both.

---

samber/cc-skills-golang@golang-context ⚙️

Idiomatic context.Context usage — creation, cancellation, timeouts, values, propagation patterns, WithoutCancel, common anti-patterns.

Use when: propagating deadlines and cancellation signals, or passing request-scoped values. Not for code that merely accepts ctx as first parameter.

---

samber/cc-skills-golang@golang-data-structures ⭐️

Golang data structures internals and usage — slices (capacity growth, append aliasing), maps, channels, sync primitives, container/\*, generic collections, and when to use each.

Use when: choosing a data structure, understanding slice/map performance characteristics, or using container/list, container/heap, or ring.

---

samber/cc-skills-golang@golang-database ⭐️ ⚙️

Golang database access patterns — parameter binding, connection pooling, transactions, migrations, sqlboiler/sqlc code generation, query builders.

Use when: writing SQL queries, designing repository patterns, or configuring database connections. For security aspects of queries (injection) → also consult golang-security.

---

samber/cc-skills-golang@golang-dependency-injection ⚙️

Dependency injection patterns in Golang — constructor injection, interface-based DI, wire/dig/fx comparison, and when DI is worth the complexity.

Use when: deciding whether to use DI, designing constructor signatures, or comparing DI libraries. For a specific DI library → golang-google-wire, golang-uber-dig, golang-uber-fx, or golang-samber-do.

---

samber/cc-skills-golang@golang-design-patterns ⭐️ ⚙️

Idiomatic Golang design patterns — functional options, constructors, builder pattern, middleware chains, circuit breaker, and architecture guides.

Use when: choosing architectural patterns, designing APIs, or implementing resilience patterns. For type-level design (embedding, receivers) → golang-structs-interfaces.

---

samber/cc-skills-golang@golang-modernize ⭐️

Modernize Golang code using 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.

Use when: upgrading a codebase to a newer Go version or replacing pre-generics patterns. Not for lint rule enforcement (→ golang-lint).

---

QA & Performance

samber/cc-skills-golang@golang-benchmark 🧠

Golang benchmarking, profiling, and performance measurement — pprof, trace, CPU/memory/block profiles, flame graphs, benchstat, CI regression detection, continuous profiling.

Use when: measuring performance, capturing profiles, comparing benchmark runs, or setting up CI regression detection. For applying optimization patterns → golang-performance. For debugging a crash → golang-troubleshooting.

---

samber/cc-skills-golang@golang-observability ⚙️

Golang production observability — structured logging (slog), Prometheus metrics, OpenTelemetry tracing, pprof profiling endpoints, alerting, Grafana dashboards.

Use when: instrumenting a service for production monitoring. Not for temporary deep-dive investigation (→ golang-benchmark, golang-performance).

---

samber/cc-skills-golang@golang-performance 🧠

Golang performance optimization — allocation reduction, CPU efficiency, memory layout, GC tuning, pooling, caching, hot-path optimization.

Use when: applying optimization patterns after profiling. Not for measurement methodology (→ golang-benchmark) or debugging workflow (→ golang-troubleshooting).

---

samber/cc-skills-golang@golang-testing ⭐️ 🧠 ⚙️

Production-ready Golang tests — table-driven tests, fuzzing, fixtures, goroutine leak detection (goleak), snapshot testing, code coverage, integration tests, parallel tests.

Use when: writing or reviewing tests. For testify-specific APIs → golang-stretchr-testify. For measurement methodology → golang-benchmark.

---

samber/cc-skills-golang@golang-troubleshooting ⭐️ 🧠

Systematic Golang debugging — common pitfalls, test-driven debugging, pprof capture, Delve debugger, race detection, GODEBUG tracing, production debugging.

Use when: debugging a panic, unexpected output, or hard-to-reproduce bug. Not for interpreting profiles (→ golang-benchmark) or applying optimization patterns (→ golang-performance).

---

Project Setup

samber/cc-skills-golang@golang-cli

Golang CLI application development — project layout, exit codes, signal handling, I/O patterns, argument parsing, terminal UX.

Use when: building a CLI tool from scratch. For cobra-specific APIs → golang-spf13-cobra. For viper configuration → golang-spf13-viper.

---

samber/cc-skills-golang@golang-continuous-integration

CI/CD pipeline configuration for Golang projects using GitHub Actions — build, test, lint, and release workflows.

Use when: setting up or improving a CI pipeline for a Go project.

---

samber/cc-skills-golang@golang-dependency-management

Golang module dependency strategies — go.mod conventions, versioning, replace directives, tool dependencies, and multi-module workspaces.

Use when: managing go.mod, dealing with replace directives, or structuring a multi-module repo.

---

samber/cc-skills-golang@golang-popular-libraries

Curated recommendations for production-ready Golang libraries — when the stdlib is enough vs when to reach for a package.

Use when: choosing a library for a new concern (HTTP, logging, testing, etc.). For deep guidance on a specific library → use the library-specific skill.

---

samber/cc-skills-golang@golang-project-layout

Golang project structure and workspace setup — cmd/internal/pkg conventions, monorepo layout, CLI project structure, and when to keep things flat.

Use when: starting a new project or restructuring an existing one. For architectural patterns within the project → golang-design-patterns.

---

samber/cc-skills-golang@golang-stay-updated

Resources to stay current with Golang — official channels, community hubs, key people to follow, learning resources.

Use when: looking for ways to track Go releases, proposals, and community news.

---

APIs

samber/cc-skills-golang@golang-graphql

GraphQL API development in Golang using gqlgen/graphql-go — schema definition, resolvers, subscriptions, dataloader, federation.

Use when: building a GraphQL API in Go.

---

samber/cc-skills-golang@golang-grpc

gRPC in Golang — protobuf organization, service definitions, streaming, interceptors, error codes, code generation workflow.

Use when: building or consuming a gRPC service. For OpenAPI/REST documentation → golang-swagger.

---

samber/cc-skills-golang@golang-swagger

OpenAPI/Swagger docs with swaggo/swag — annotation comments, code generation, framework integrations (gin, echo, fiber, chi), security definitions.

Use when: generating OpenAPI documentation from Go code annotations.

---

Dependency Injection

samber/cc-skills-golang@golang-dependency-injection ⚙️

See "Architecture & Design" section above.

---

samber/cc-skills-golang@golang-google-wire

Compile-time dependency injection with google/wire — provider sets, injector generation, wire.Build, and structured DI patterns.

Use when: the codebase imports github.com/google/wire or the team has chosen compile-time DI. For runtime DI with reflection → golang-uber-dig.

---

samber/cc-skills-golang@golang-uber-dig

Reflection-based DI with uber-go/dig — Provide/Invoke, dig.In/dig.Out, named values, value groups, optional dependencies, Decorate.

Use when: the codebase imports go.uber.org/dig. For higher-level lifecycle and modules → golang-uber-fx.

---

samber/cc-skills-golang@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.

Use when: the codebase imports go.uber.org/fx. For raw DI without lifecycle → golang-uber-dig.

---

samber/cc-skills-golang@golang-samber-do

Dependency injection with samber/do — type-safe service containers, lifecycle management, scopes, health checks, graceful shutdown.

Use when: the codebase imports github.com/samber/do.

---

Frameworks

samber/cc-skills-golang@golang-spf13-cobra

CLI command trees with spf13/cobra — command hierarchy, RunE hooks, flag management, shell completion, usage templates, testing with SetArgs.

Use when: the codebase imports github.com/spf13/cobra. For configuration layering → golang-spf13-viper. For general CLI architecture → golang-cli.

---

samber/cc-skills-golang@golang-spf13-viper

Layered configuration with spf13/viper — flag > env > file > KV > default precedence, BindPFlag, hot reload, test isolation, remote KV integration.

Use when: the codebase imports github.com/spf13/viper. For CLI command structure → golang-spf13-cobra. For general CLI architecture → golang-cli.

---

samber/\*

samber/cc-skills-golang@golang-samber-do

See "Dependency Injection" section above.

---

samber/cc-skills-golang@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.

Use when: the codebase imports github.com/samber/hot.

---

samber/cc-skills-golang@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.

Use when: the codebase imports github.com/samber/lo. Not for streaming pipelines (→ golang-samber-ro).

---

samber/cc-skills-golang@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.

Use when: the codebase imports github.com/samber/mo.

---

samber/cc-skills-golang@golang-samber-oops

Structured error handling with samber/oops — error builders, stack traces, error codes, context attributes, public vs developer messages, panic recovery, APM integration.

Use when: the codebase imports github.com/samber/oops.

---

samber/cc-skills-golang@golang-samber-ro 🧠

Reactive streams with samber/ro — 150+ type-safe operators, cold/hot observables, 5 subject types, 40+ plugins, automatic backpressure, Go context integration.

Use when: the codebase imports github.com/samber/ro. Not for finite slice transforms (→ golang-samber-lo).

---

samber/cc-skills-golang@golang-samber-slog

Structured logging pipeline with samber/slog-\* packages — multi-handler routing (slog-multi), sampling, formatting, HTTP middleware, 20+ backend sinks.

Use when: the codebase imports any github.com/samber/slog-* package.

---

Testing

samber/cc-skills-golang@golang-stretchr-testify

Testing with stretchr/testify — assert, require, mock, and suite packages. Assertions, mock expectations, argument matchers, suite lifecycle, custom matchers.

Use when: the codebase imports github.com/stretchr/testify. For test architecture and strategy → golang-testing.

---

samber/cc-skills-golang@golang-testing ⭐️ 🧠 ⚙️

See "QA & Performance" section above.

Competing clusters — deep disambiguation

Eleven clusters where skills overlap. Each cluster includes a boundary table, concrete routing examples, and notes on gap cases not yet explicit in source skill descriptions.

---

1. Performance cluster

Four skills form a "deep analysis" cluster. golang-observability is the always-on counterpart; the other three are activated on demand.

Routing examples:

• "My HTTP handler is slow in production" → start with golang-observability (check metrics/traces), then golang-benchmark (capture profiles), then golang-performance (apply fixes).
• "My benchmark regressed by 20%" → golang-benchmark (benchstat comparison, detect root cause via pprof).
• "I need to reduce allocations in the hot path" → golang-performance (pooling, struct layout, escape analysis).
• "The process crashes after 10 minutes under load" → golang-troubleshooting (race detector, memory leak, Delve attach).

---

2. Dependency injection cluster

Start with golang-dependency-injection for library selection. Then use the library-specific skill once the choice is made.

Routing examples:

• "Should I use DI in my project?" → golang-dependency-injection.
• "My project uses google/wire, wire.Build is failing" → golang-google-wire.
• "I want lifecycle hooks with my DI container" → golang-uber-fx (not golang-uber-dig — dig is lower-level).
• "I want type-safe DI without code generation" → golang-samber-do or golang-uber-dig.

---

3. samber/\* functional cluster

The three core skills cover three distinct programming models. They rarely compete in the same task.

Routing examples:

• "Transform a slice of users into a map by ID" → golang-samber-lo (lo.KeyBy).
• "Stream events from a channel with backpressure and rate limiting" → golang-samber-ro.
• "Return an optional value without using nil" → golang-samber-mo (mo.Some/mo.None).
• "Compose error-returning functions without if-err chains" → golang-samber-mo (mo.Result[T]).

Note: golang-samber-mo is currently absent from the mutual cross-reference between lo and ro in their descriptions. The boundary above reflects the intended design.

---

4. Error handling cluster

Routing examples:

• "How should I wrap errors so callers can match them?" → golang-error-handling.
• "I want structured errors with HTTP codes and stack traces" → golang-samber-oops.
• "My service panics on nil pointer dereference" → golang-safety (defensive coding) AND golang-troubleshooting (debugging the existing crash).

---

5. Style / naming / lint / docs cluster

These four skills each own a distinct slice of "code quality". Source descriptions include explicit mutual disclaimers.

Routing examples:

• "How do I name my constructor?" → golang-naming.
• "My golangci-lint run reports exhaustive errors" → golang-lint.
• "How should I format my package-level godoc comment?" → golang-documentation.
• "When should I use a blank line between two function bodies?" → golang-code-style.

---

6. CLI cluster

Routing examples:

• "My CLI should exit with code 2 on bad args" → golang-cli.
• "How do I add shell completion to my cobra command?" → golang-spf13-cobra.
• "How do I override config values with env vars?" → golang-spf13-viper.
• "I'm building a new CLI from scratch" → golang-cli (architecture) + golang-spf13-cobra (command tree) + golang-spf13-viper (config).

---

7. Testing cluster

Routing examples:

• "How do I write a table-driven test in Go?" → golang-testing.
• "How do I assert a mock was called with specific args?" → golang-stretchr-testify.
• "How do I detect goroutine leaks in tests?" → golang-testing (goleak).

---

8. design-patterns vs structs-interfaces

These two skills overlap on "how to design Go types". The split is: type-level design vs. architectural use of types.

Overlap zone: "DI via interfaces" — defining small interfaces is golang-structs-interfaces; wiring multiple components together via those interfaces is golang-design-patterns.

Routing examples:

• "Should my method take a value or pointer receiver?" → golang-structs-interfaces.
• "How do I implement a middleware chain for my HTTP handlers?" → golang-design-patterns.
• "How do I embed a struct without exposing its methods?" → golang-structs-interfaces.
• "How do I implement the functional options pattern?" → golang-design-patterns.

Note: neither skill currently carries a description-level → See disclaimer for this overlap. The boundary above is the intended design, not yet explicit in the source skills.

---

9. concurrency vs context

These skills overlap when goroutines are cancelled via context.

Overlap zone: "cancelling goroutines via context" — load both skills. golang-context owns the context API; golang-concurrency owns the goroutine coordination.

Routing examples:

• "How do I cancel a goroutine from outside?" → both (golang-context for cancel(), golang-concurrency for select { case <-ctx.Done() }).
• "How do I fan out N workers and collect results?" → golang-concurrency.
• "How do I pass a deadline through multiple layers of function calls?" → golang-context.

Note: no description-level disclaimer currently exists between these two skills. Load both when the task involves both concerns.

---

10. safety vs security

Both skills prevent bugs, but with different threat models.

Routing examples:

• "My service panics with nil pointer dereference" → golang-safety.
• "Is this SQL query safe from injection?" → golang-security.
• "I'm using math/rand to generate a token" → golang-security (predictable output; use crypto/rand).
• "My slice grows unexpectedly after append" → golang-safety (append aliasing).

Note: no description-level disclaimer currently exists between these two skills. The source descriptions cross-reference in their bodies but not in the YAML frontmatter.

---

11. modernize vs lint

Both skills suggest code changes, but for different reasons.

Overlap zone: Some linters (govet, deadcode, perfsprint) produce warnings that overlap with modernize suggestions (e.g., "use slog instead of log"). The boundary: lint owns the tool configuration and suppression policy; modernize owns the rewrite patterns to apply once you've decided to adopt the feature.

Routing examples:

• "How do I replace a for i := 0; i < n; i++ loop with the new range syntax?" → golang-modernize.
• "My CI fails on perfsprint lint rule" → golang-lint (interpret the rule and decide whether to fix or suppress).
• "Should I migrate from log to slog?" → golang-modernize.
• "How do I configure golangci-lint to run only security-relevant linters?" → golang-lint.

Configure mode — force-trigger Go skills in a project

This workflow adds a ## Required Go skills block to the project's agent config file so that specific skills always load, regardless of trigger heuristics.

When to use

• The project has a hard requirement on a skill (e.g., golang-security must always apply, not just when the user mentions "security").
• The team has agreed on a fixed set of Go standards to enforce on every AI interaction.
• A company skill overrides a community default (⚙️ skills) and must always win.

Step 1 — Detect the project config file

Check in this precedence order:

1. CLAUDE.md          (Claude Code)
2. AGENTS.md          (OpenAI Codex, OpenCode, multi-agent)
3. .cursor/rules      (Cursor)
4. .github/copilot-instructions.md  (GitHub Copilot)

Use Glob to detect which files exist at the project root. If multiple exist, use all of them (different tools read different files). If none exist, ask the user which one to create with AskUserQuestion.

Step 2 — Idempotency check

Before writing, grep each file for an existing ## Required Go skills block:

grep -n "## Required Go skills" CLAUDE.md

If the block already exists, read it and confirm with the user whether to update it in place (replace the existing list) or skip.

Step 3 — Confirm the skill set with the user

Use AskUserQuestion to confirm which skills to always load. Present the ⭐️ recommended skills as the default selection. Remind the user of the token budget (each always-loaded skill adds its description tokens to every session — the 11 recommended skills add ~1,100 tokens at startup).

Recommended ⭐️ set for most projects:

golang-code-style
golang-data-structures
golang-design-patterns
golang-documentation
golang-error-handling
golang-modernize
golang-naming
golang-safety
golang-security
golang-testing
golang-troubleshooting

Additional skills to suggest based on codebase context:

• Database layer detected (sql, gorm, sqlc) → suggest golang-database
• CI config detected (.github/workflows/) → suggest golang-continuous-integration
• Cobra imports detected → suggest golang-spf13-cobra
• Viper imports detected → suggest golang-spf13-viper
• samber/lo imports detected → suggest golang-samber-lo
• Any other library-specific import → suggest the matching library skill

Step 4 — Write the block

Template

## Required Go skills

The following Go skills from `samber/cc-skills-golang` MUST always be applied when working on this project. Load them at the start of every Go-related task, regardless of whether the user explicitly mentions them.

- `samber/cc-skills-golang@golang-error-handling`
- `samber/cc-skills-golang@golang-security`
- `samber/cc-skills-golang@golang-testing`

Replace the skill list with the confirmed set from Step 3. Use the fully-qualified samber/cc-skills-golang@<name> identifier for each skill.

Insertion point

• If the file is empty: write the block at the top.
• If the file has existing content: append after the last section, separated by a blank line.
• If a ## Required Go skills block already exists: replace only the bullet list inside it, preserving surrounding content.

Edit the file

Use the Edit tool (preferred over a bash script) to apply the change. For append operations:

# Conceptually: read the file, find the insertion point, apply Edit

Perform an idempotency check after writing: re-read the file and verify the block appears exactly once.

Step 5 — Confirm to the user

After writing, summarize:

• Which file(s) were updated
• Which skills were added to the always-load list
• Approximate startup token cost (number of skills × ~100 tokens per description)
• Note: skills marked ⚙️ (overridable) will be superseded if a company skill explicitly declares the override in its body

Notes on company overrides (⚙️ skills)

Skills marked ⚙️ in the README support company overrides. If the project has a company skill that supersedes a community default (e.g., acme/cc-skills@golang-error-handling-acme supersedes samber/cc-skills-golang@golang-error-handling), use the company skill FQN in the block instead — do NOT list both.

To declare an override in a company skill body, add near the top:

> This skill supersedes `samber/cc-skills-golang@golang-error-handling` for [Company] projects.

Overridable skills: golang-code-style, golang-concurrency, golang-context, golang-database, golang-dependency-injection, golang-design-patterns, golang-documentation, golang-error-handling, golang-naming, golang-observability, golang-structs-interfaces, golang-testing.