go-skills-router

Files (1)

• SKILL.md

SKILL.md (first lines)

# Go Skills Router

This repository publishes 35 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 code, order imports, declare and initialise | `go-coding-standards` | `go-documentation` |
| Name a package, type, function, receiver or error | `go-naming` | `go-coding-standards` |
| 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, README, CHANGELOG | `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-test-quality`, `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` |
| Cut a release: GoReleaser, signing, SBOMs, provenance | `go-build-release` | `go-ci`, `go-binary-size` |
| 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/REST handlers, routing, middleware, idempotency,
  health checks, shutdown.
- `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-naming` — what things are called: packages, types, functions,
  receivers, errors.
- `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.

**"Ship it."**

- `go-ci` — the pipeline that gates every change: build, lint, test, scan.
- `go-build-release` — turning a tag into signed, reproducible artifacts.
- `go-binary-size` — making those artifacts smaller.

## Which Tool Answers the Question

From eduardo-sl/go-agent-skills, MIT.

More from eduardo-sl/go-agent-skills