golang-master — Claude Code skill: what it does, how to install
golang-master — a skill for Claude Code that guides Go implementation and review. It applies to work on errors, concurrency, tests, performance, and module layout.
MIT 115 installs ★ 655 updated 2026-10-20
npx skills add pedronauck/skills --skill golang-master -a claude-codeWhat golang-master does
The skill sets guidance for writing and reviewing Go code, covering error handling, context propagation, goroutines, types, safety, tests, and benchmarks. It selects reference material for the task rather than loading every section whenever Go comes up. Project guidance takes precedence when rules conflict, and applicability depends on the Go versions the project supports.
Its references also cover profiling, modernizing older code, and module structure. The skill flags patterns to investigate, including goroutines without an exit path, defer in loops, and integer conversions without bounds checks. Go 1.21 is the minimum language version; code changes should follow gofmt and the project’s lint and test gates.
What it helps with
- handle and wrap errors in Go code
- spot goroutine leaks and race risks
- review tests and benchmarks
- assess a Go module’s layout
Example prompts for the agent
- Review error handling and context propagation in this Go code.
- Find concurrency problems involving goroutines and cancellation.
- Assess the tests and layout of this Go module.
How to install golang-master
1Skills CLI (Vercel)
npx skills add pedronauck/skills --skill golang-master -a claude-code2Manually: put the files in place
~/.claude/skills/golang-master/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/golang-master/
1Skills CLI (Vercel)
npx skills add pedronauck/skills --skill golang-master -a codex2Manually: put the files in place
.agents/skills/golang-master/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add pedronauck/skills --skill golang-master -a cursor2Manually: put the files in place
.cursor/skills/golang-master/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install pedronauck/skills skills/mine/golang-master2Manually: put the files in place
.github/skills/golang-master/SKILL.md1Skills CLI (Vercel)
npx skills add pedronauck/skills --skill golang-master -a gemini-cli2Platform CLI
gemini skills install https://github.com/pedronauck/skills --path skills/mine/golang-masterManually: put the files in place
.devin/skills/golang-master/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add pedronauck/skills --skill golang-master -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about golang-master
How do I install golang-master in Claude Code?
Run npx skills add pedronauck/skills --skill golang-master -a claude-code. The skill file is placed at ~/.claude/skills/golang-master/SKILL.md.
What does golang-master do?
It guides Go implementation and review, with coverage of errors, concurrency, safety, tests, and module structure. It uses the relevant reference sections for each task.
Which Go version does golang-master require?
The skill targets Go 1.21 and later. Its guidance depends on the Go versions supported by the project.
Source text
SKILL.md · MIT
---
name: golang-master
description: "Write or review production Go: errors, concurrency, context, types, generics, safety, tests, benchmarks, profiling, modernization, and module structure. Project/framework conventions and third-party API lookup have separate owners."
allowed-tools: Read, Grep, Glob, Bash(go:*)
metadata:
author: Pedro Nauck
github: https://github.com/pedronauck
repository: https://github.com/pedronauck/skills
credits: Distilled from samber/cc-skills-golang and Jeffallan's golang-pro (both MIT)
---
# Golang Master
Language-level doctrine for **Go 1.21+** (1.22–1.26 features flagged inline) in any Go codebase. This skill is the generic floor; a project's own guidelines skill overrides it wherever the two conflict, and this skill owns everything the project leaves unsaid.
Use the matching reference sections for a concrete Go concern. Reuse current context; do not load every reference merely because Go appears in the task. Project conventions and supported Go versions govern applicability.
## The floor
Non-negotiables for every line of Go, regardless of branch:
1. Every error is handled or carries a written justification at the discard site — never a bare `_`.
2. Errors wrap with `fmt.Errorf("context: %w", err)` and are matched with `errors.Is`/`errors.As` — never by string comparison.
3. `ctx context.Context` is the first parameter of any function that does I/O, blocks, or crosses an API boundary, and the caller's ctx is propagated — never a fresh `context.Background()` mid-path.
4. Every goroutine has an owner, an exit path, and a way to be waited on.
5. `panic` is reserved for impossible states; expected failures return errors.
6. Check uncertain type assertions. Initialize maps before writes; use nil/zero-value slices when their semantics fit the contract.
7. Use compile-time interface assertions for an intentional implementation contract; do not invent interfaces just to add an assertion.
8. Tests prove the owning invariant. Use tables for multiple cases and race checks for concurrency or when the project requires them.
9. Apply gofmt and the project's owning lint/test gates; reuse current evidence instead of running repository-wide vet for every edit.
10. Operational values (timeouts, limits, addresses) come from configuration or options — never hardcoded.
## Branches
| When the task involves… | Read |
| --- | --- |
| Creating, wrapping, matching, logging, or joining errors; panic/recover policy | [references/errors.md](references/errors.md) |
| Goroutines, channels, select, sync primitives, errgroup, worker pools, races | [references/concurrency.md](references/concurrency.md) |
| Cancellation, timeouts, deadlines, context values, detached background work | [references/context.md](references/context.md) |
| Nil traps, append aliasing, map access, numeric conversion, defer-in-loop, zero values | [references/safety.md](references/safety.md) |
| Designing structs, interfaces, embedding, receivers, field tags, generics | [references/interfaces-generics.md](references/interfaces-generics.md) |
| Naming anything, control-flow shape, constructors, functional options, `init()` | [references/style-naming.md](references/style-naming.md) |
| Writing or reviewing tests, benchmarks, fuzzing, integration build tags | [references/testing.md](references/testing.md) |
| Profiling, allocation hunting, GC tuning, benchmark comparison | [references/performance.md](references/performance.md) |
| Old-style patterns, deprecated APIs, Go version upgrades | [references/modernize.md](references/modernize.md) |
| New module, directory layout, `cmd`/`internal`/`pkg`, workspaces | [references/layout.md](references/layout.md) |
Concurrency work that cancels anything reads both `concurrency.md` and `context.md`. A review reads the relevant sections needed to assess the changed behavior.
## Tripwires
Investigate these signals when they occur in the changed path; they are not categorical defects:
- A goroutine spawned with no `ctx.Done()`, channel close, or `WaitGroup` path — it outlives its caller.
- `time.After` inside a loop — a timer allocation per iteration; use `time.NewTimer` + `Reset`.
- A typed nil pointer returned as an interface — the result is `!= nil`.
- An `append` result kept alongside the original slice — shared backing array, silent co-mutation.
- `defer` inside a loop body — resources accumulate until function exit; extract the body.
- A narrowing integer conversion without a bounds check — silent wraparound.
- An error logged *and* returned — duplicate reports upstream; pick exactly one.
- An interface returned from a constructor, or defined beside its implementation instead of its consumer.
- Tests with unexplained shared mutable state or concurrency behavior without race coverage.
- `any` where a type parameter or concrete type is known.
© Pedro Nauck · MIT · pedronauck/skills