---

name: go-skills-router description: > Index and routing table for this repository's Go skills: maps a task to the skill that owns it, names the secondary skills worth loading alongside, and draws the boundary between skills whose triggers overlap. Use when it is unclear which Go skill applies, when a task spans several concerns at once, when two skills seem to cover the same ground, or when the user asks what Go skills are available. Trigger examples: "which skill should I use", "what Go skills do you have", "is this concurrency or performance", "go-performance-review or go-troubleshooting". Not for: a task that already maps cleanly to one skill — load that skill directly. user-invocable: true license: MIT compatibility: Designed for Claude Code or similar AI coding agents working on Go projects. Indexes the skills published in eduardo-sl/go-agent-skills; it names them, it does not require them. allowed-tools: Read Glob Grep metadata: author: eduardo-sl version: "1.0.1"

Go Skills Router

This repository publishes 33 Go skills. Their triggers necessarily overlap — "this is slow" could be performance, concurrency, database, or a leak. Use the tables below to pick the owner, then load the secondary skills in the same pass rather than discovering them one at a time.

This is an index. Every skill it names stands alone and can be read without this one.

Routing Table

Task	Primary	Also load
Format, name, or lay out code	go-coding-standards	go-documentation
Review a diff or a PR	go-code-review	the skill owning the domain under review
Return, wrap, or inspect errors	go-error-handling	go-defensive-coding for nil-heavy code
Pass deadlines, cancel work	go-context	go-concurrency-review if goroutines are involved
Adopt newer Go features	go-modernize	go-ci to raise the toolchain in CI
Slices, maps, sets, preallocation	go-data-structures	go-performance-review
Write godoc, examples, deprecations	go-documentation	go-coding-standards
Guard against panics and silent corruption	go-defensive-coding	go-error-handling
Review package layout and dependency direction	go-architecture-review	go-interface-design
Start a new project or service	go-project-layout	go-dependency-injection, go-ci
Design an interface or a type	go-interface-design	go-design-patterns
Apply a known pattern	go-design-patterns	go-interface-design
Wire dependencies, remove globals	go-dependency-injection	go-project-layout
Build an HTTP API	go-api-design	go-openapi, go-observability
Work from an OpenAPI spec	go-openapi	go-api-design, go-test-quality
Build a GraphQL API	go-graphql	go-database, go-api-design
Build a gRPC service	go-grpc	go-api-design, go-observability
Build a CLI	go-cli	go-project-layout, go-binary-size
Query a database, manage transactions	go-database	go-error-handling, go-security-audit
Write goroutines, channels, sync	go-concurrency-review	go-context, go-test-quality
Audit for vulnerabilities	go-security-audit	go-dependency-audit, go-defensive-coding
Reduce allocations, optimise a hot path	go-performance-review	go-data-structures
Shrink a binary or image	go-binary-size	go-ci
Add logs, metrics, traces	go-observability	go-context
Debug a panic, leak, or deadlock	go-troubleshooting	go-concurrency-review, go-performance-review
Write or improve tests	go-test-quality	go-test-table-driven
Structure a test matrix	go-test-table-driven	go-test-quality
Audit go.mod, check CVEs	go-dependency-audit	go-security-audit
Set up CI, linting, coverage gates	go-ci	go-dependency-audit
Restructure existing code safely	go-refactoring	go-semantic-tools, plus the skill owning the target shape
Find callers, implementers, rename	go-semantic-tools	go-refactoring
Write a commit message	git-commit	—

Boundaries Between Overlapping Skills

Load the one that owns the question being asked, not the one that matches a keyword in the code.

"It is slow."

• go-performance-review — the code allocates or copies too much. Owns benchmarks, pprof, and optimisation patterns.
• go-concurrency-review — the code contends on a lock or serialises work that could run in parallel.
• go-database — the query is the problem: missing index, N+1, pool exhaustion.
• go-troubleshooting — you do not yet know which of the three it is. Start here to find out, then hand off.

"It crashed."

• go-troubleshooting — a panic, deadlock, or leak already happened. Diagnosis, profiles, delve.
• go-defensive-coding — prevention. Nil traps, aliasing, overflow, the constructs that make the next crash impossible.
• go-concurrency-review — a data race or a goroutine lifecycle bug.

"Is this secure?"

• go-security-audit — external threats: injection, auth, secrets, TLS.
• go-dependency-audit — known CVEs in modules you import.
• go-defensive-coding — internal correctness bugs that are not attacks.

"How should this be structured?"

• go-architecture-review — the shape of an existing codebase.
• go-project-layout — the shape of a new one.
• go-interface-design — the shape of one type or contract.
• go-refactoring — the process of getting from the current shape to the target shape. Load it alongside whichever skill above owns that target.

"How do I expose this?"

• go-api-design — HTTP handlers, middleware, shutdown. Protocol-agnostic server concerns.
• go-openapi — the contract is a spec and code is generated from it.
• go-graphql — the client picks the shape of the response.
• go-grpc — protobuf contract, interceptors, streaming.

"Tests."

• go-test-quality — what to test, how to isolate it, what to mock, synctest, goleak, benchmarks.
• go-test-table-driven — the table pattern specifically: when it helps, how to shape the case struct, when to stop using it.

"Style."

• go-coding-standards — the rules the code should follow.
• go-code-review — applying rules to someone else's change, with severity.
• go-modernize — rules that changed because the language moved.
• go-ci — making a machine enforce them.

Multi-Concern Tasks

A real task usually crosses three skills. Load them together at the start rather than sequentially.

Request	Load
"Build a gRPC service with tests"	go-grpc + go-test-quality + go-error-handling
"This endpoint is slow under load"	go-troubleshooting + go-performance-review + go-database
"Harden this service before launch"	go-security-audit + go-dependency-audit + go-defensive-coding + go-ci
"Split this monolith"	go-architecture-review + go-refactoring + go-semantic-tools
"Scaffold a new CLI"	go-project-layout + go-cli + go-ci + go-binary-size
"Migrate this to the current Go release"	go-modernize + go-test-quality + go-ci

Full Catalogue

Category	Skills
Code Quality	go-coding-standards go-code-review go-error-handling go-context go-modernize go-data-structures go-documentation
Architecture	go-architecture-review go-project-layout go-interface-design go-api-design go-openapi go-graphql go-grpc go-design-patterns go-dependency-injection go-cli
Data	go-database
Safety & Performance	go-concurrency-review go-security-audit go-defensive-coding go-performance-review go-observability go-troubleshooting
Testing	go-test-quality go-test-table-driven
Workflow	go-dependency-audit go-ci go-refactoring go-semantic-tools go-binary-size git-commit go-skills-router

Verification Checklist

1. The primary skill matches the question being asked, not a keyword in the code
2. Secondary skills were loaded in the same pass, not discovered one at a time
3. For a diagnosis task, go-troubleshooting ran before an optimisation skill
4. For a restructuring task, go-refactoring was paired with the skill owning the target shape
5. If exactly one skill applies, it was loaded directly without routing