How to use
- Copy the installation command and review the source package before installing it in your own agent environment.
- Check the source document for required tools, credentials and supported hosts.
- Describe your input and desired deliverable; review the output against the source material.
npx skills add https://github.com/eduardo-sl/go-agent-skills --skill go-skills-routerBefore you start
- Installation does not include a model subscription, API allowance or permission to access your files.
- Repository stars and installation counts describe activity, not an independent quality or security test.
Original skill document
Rendered from the source repository. Headings, examples, code, tables, links, and referenced images are preserved.
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
- The primary skill matches the question being asked, not a keyword in the code
- Secondary skills were loaded in the same pass, not discovered one at a time
- For a diagnosis task,
go-troubleshootingran before an optimisation skill - For a restructuring task,
go-refactoringwas paired with the skill owning the target shape - If exactly one skill applies, it was loaded directly without routing
