go
/go
Prowadzi przy pisaniu i przeglądzie kodu Go: idiomy, gorutyny, moduły, testy i profilowanie wycieków oraz wyścigów.
- Autor
- lynricsy ↗
- Repozytorium
- hyperskills ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 04.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 30
- Skrypty
- 11
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 04.11.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
- 11 skryptów w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.
Skrypty: evals/files/cache_test.go, evals/files/cfglib/cfglib-config.go, evals/files/fetcher.go, evals/files/modernize/linkutil-link.go, evals/files/modernize/svc-orders.go, evals/files/poller/poller.go, evals/files/poller/poller_test.go, evals/files/relay/relay.go, evals/files/store.go, evals/files/webhook/webhook.go, evals/files/webhook/webhook_test.go
Co robi i kiedy
Prowadzi przy pisaniu i przeglądzie kodu Go: idiomy, gorutyny, moduły, testy i profilowanie wycieków oraz wyścigów.
Oryginalny opis (EN)
Guides Go development: idioms, goroutines, modules, go test and pprof profiling. Use when writing, reviewing or modernising .go code or go.mod, a goroutine leaks, a data race or flaky test appears, context cancellation does not propagate, or allocations dominate a profile.
Jak działa
- Scope
- Core rules
- Workflows
- Topic router
- Output format
- Environment
Podgląd SKILL.md
---
name: go
description: "Guides Go development: idioms, goroutines, modules, go test and pprof profiling. Use when writing, reviewing or modernising .go code or go.mod, a goroutine leaks, a data race or flaky test appears, context cancellation does not propagate, or allocations dominate a profile."
license: MIT (upstream attributions in NOTICE.md)
metadata:
author: HyperSkills
version: "2026.11.04"
category: framework
---
# go
## Scope
Covers the Go language and its own toolchain: idioms and type design, interfaces and
composition, generics, the modern standard library, concurrency and the memory model,
error handling, package layout, modules and workspaces, `go test` in all its forms,
pprof/trace performance work, and `go vet` plus `golangci-lint`. Third-party packages
appear only where the standard library has no answer and the ecosystem has converged on
one: `golang.org/x/sync/errgroup`, `github.com/google/go-cmp/cmp`, `go.uber.org/goleak`.
Not covered: cloud provider SDKs (AWS, GCP, Azure — use the `aws`, `azure` or `gcp`
skill) and Kubernetes operators, controllers and client-go, which have no skill in this
repository yet, so work from the vendor's own documentation. The MCP surface of a Go MCP
server belongs to the `mcp-server` skill. Deploying the binary (container images,
Kubernetes manifests, cloud infrastructure) belongs to `containers` and `terraform`.
Web frameworks (Gin, Echo, Fiber) and ORMs
are out of scope by design; the `net/http` and `database/sql` guidance here is about the
standard library. Reviewing a diff, commit range or pull request is the `code-review`
skill's job. The test-first loop as a methodology belongs to the
`test-driven-development` skill; what is here is the Go testing API and its traps.
Diagnosing a reproducible local failure systematically is the `debugging` skill.
Paths below are relative to this skill's directory.
## Core rules
1. Read the `go` directive in `go.mod` before proposing anything version-gated. Every
`(Go 1.x+)` marker below is a build-breaking constraint on a module pinned lower, and
`go test` runs the `stdversion` vet check that catches it (Go 1.27+).
2. Every goroutine has a visible exit: a context, a closed channel, or a bounded loop.
The garbage collector never reclaims a goroutine blocked on an unreachable channel, so
a leak accumulates until the process dies. An unstopped `Timer` or `Ticker` is not a
leak once unreferenced: Go 1.27 removed `asynctimerchan`, so every build collects it
whatever the `go` line (on Go 1.23–1.26 only with a `go` line of 1.23 or later).
3. Do not start goroutines in `init()` or in a library constructor. Expose `Start`/`Close`
so the caller owns the lifetime and can wait for it.
4. Replace hand-rolled worker pools with `errgroup.WithContext` plus `g.SetLimit(n)`: it
propagates the first error, cancels the siblings and caps concurrency in three lines.
Where no error travels back, `wg.Go(func(){...})` (Go 1.25+) replaces the `Add`/`Done`
pair.
5. Only the sender closes a channel, and sending hands over ownership — the sender must
not touch the value afterwards. Closing from the receiver panics the next send.
6. A channel's buffer is 0, or a number you can name (the exact producer or worker count).
An arbitrary buffer hides backpressure until the queue is the outage.
7. `context.Context` is the first parameter, named `ctx`, never a struct field. Every
`select` that can block includes `case <-ctx.Done():`.
8. Wrap with `%w` and inspect with `errors.Is` / `errors.AsType[T](err)` (Go 1.26+;
`errors.As(err, &target)` below that). `err == ErrX` and `err.(*T)` both stop matching
the moment anything in the chain wraps the error, and that happens silently.
9. An error is either logged or returned, never both, and never discarded with `_`. Two
handlers means two log lines for one failure and no owner.
10. Error strings are lowercase and unpunctuated: they get printed inside a larger
sentence.
11. Design the zero value to be usable (`sync.Mutex`, `bytes.Buffer` are the models), and
prefer `var t []T` for an empty slice. Reach for `[]T{}` or `make` only when the
difference is observable — JSON encodes a nil slice as `null`, and a nil map panics on
write.
12. The consumer declares the interface it needs, one or two methods wide; accept
interfaces, return concrete types. An interface exported next to its only
implementation is coupling with extra steps.
13. Keep a type's receivers consistent — all pointer or all value. Mixed receivers make
the method set depend on how the value was obtained.
14. Name packages after the domain (`auth`, `billing`, `jobs`), one level deep. `utils`,
`common`, `helpers` and layer names (`service`, `repository`, `controller`) create
import cycles and tell a reader nothing. `internal/` exists to stop *other modules*
importing code, not to model layers.
15. Check the standard library before adding a dependency, and prefer the current API:
`slices`, `maps`, `cmp`, `iter`, `math/rand/v2`, typed `atomic.Int64`, `any`,
`//go:build`, the `tool` directive over `tools.go`. Details in
`references/stdlib-modern-apis.md`.
16. Introduce generics only when the same algorithm already exists for three or more
types. A generic `Repository[T]` is a Java class hierarchy wearing Go syntax.
17. Table tests name every case and run it through `t.Run`; the failure message prints
what was called, what came back and what was wanted. `t.Errorf("bad")` costs a
debugging session.
18. In a parallel test, register cleanup with `t.Cleanup` or `t.TempDir` — never a `defer`
in the parent. The parent function returns *before* its `t.Parallel()` subtests run,
so the parent's `defer` fires first. [verified]
19. No `time.Sleep` in tests. Use `testing/synctest` (Go 1.25+) for anything involving
timers, timeouts or context deadlines: its fake clock advances only when every
goroutine in the bubble is blocked. A real server never blocks durably, so inside a
bubble use `httptest.NewTestServer` (Go 1.27+), not `httptest.NewServer` or a stub
`RoundTripper`.
20. Profile before optimising, change one thing, measure again with `benchstat`. Write
benchmarks as `for b.Loop()` (Go 1.24+), which keeps setup out of the timed region and
stops the compiler eliding the call.
21. Never blame the Go toolchain. `go build` is deterministic and the build cache is keyed
by source content; a persisting error means the edit was wrong, in the wrong file, or
there is a second call site.
22. Finish every change with the gate: `gofmt -l .` empty, `go vet ./...` clean,
`golangci-lint run` clean, `go test -race ./...` green.
## Workflows
### implement
- [ ] Read `go.mod`: module path, `go` directive, and which of `errgroup`, `go-cmp`,
`testify`, `goleak` the project already depends on. Follow what is there.
- [ ] State the local contract before typing: inputs, zero-value behaviour, what is
aliased, what mutates, which errors callers must distinguish, whether it is safe for
concurrent use, and whether the identifier is exported (and therefore frozen).
- [ ] Pick the representation from that contract: value when copying is meaningful,
pointer when identity, mutation or absence is part of the contract. Copy an incoming
slice or map at the ownership boundary if you keep it.
- [ ] Write the concrete type first. Add an interface only when a second implementation or
a test seam actually requires one, and declare it in the consuming package.
- [ ] Return errors with `%w` and enough context to locate the call; define a sentinel or
a typed error only when a caller has to branch on it (`references/errors.md`).
- [ ] Add concurrency only when there is a measured reason. When you do, answer rule 2
first, then reach for `errgroup` (`references/concurrency.md`).
- [ ] Document every exported identifier with a sentence starting with its name.
- [ ] Write the tests (see `add-tests`).
- [ ] **Gate:** `gofmt -l .` prints nothing, `go vet ./...` is clean, and
`go test -race ./...` passes.
### add-tests
- [ ] Put the test in `foo_test.go` next to `foo.go`. Use `package foo_test` when you can
exercise the exported API only; stay in `package foo` when the test genuinely needs
unexported state.
- [ ] Write it table-driven with a named case per row, and assert observable behaviour —
returned values, returned error identity via `errors.Is`, emitted output. A test
pinned to internals fails on every refactor and proves nothing.
- [ ] Compare structs with `cmp.Diff(want, got)` and print the diff, not
`reflect.DeepEqual`.
- [ ] Add `t.Parallel()` only when the case owns its state; then apply rules 18 and 19.
- [ ] Cover the error paths and one boundary case per input dimension. For parsers and
decoders add `FuzzXxx` with the known-tricky inputs seeded.
- [ ] Packages that spawn goroutines get `goleak.VerifyTestMain(m)` in `TestMain`.
- [ ] **Gate:** `go test -race -count=2 ./...` passes, and the new test fails when you
break the behaviour it claims to cover.
### fix-race-or-leak
- [ ] Reproduce under the detector: `go test -race -run <Test> -count=10 ./...`. The race
detector only reports races it observes, so make the suspect path run many times.
- [ ] Read the report top down: the two stacks are the conflicting accesses and the third
is where the goroutine was started. That third stack is usually the actual bug.
- [ ] Fix by removing the sharing first (give each worker its own slot or value), by a
channel handoff second, and by a mutex only when shared mutable state is genuinely
required. Adding a lock to keep dead shared state alive is not a fix.
- [ ] For a suspected leak, count first: `runtime.NumGoroutine()` around the operation, or
`curl <host>/debug/pprof/goroutine?debug=2` for a live process. On Go 1.27+ the
`goroutineleak` profile names goroutines blocked on unreachable primitives directly.
- [ ] Pin the fix with a regression test: `defer goleak.VerifyNone(t)`, or a `synctest`
bubble that asserts the worker exits when the context is cancelled.
- [ ] **Gate:** `go test -race -count=10` on the affected package is green and the
goroutine count returns to its pre-operation value.
### profile-hot-path
- [ ] Rule out the world outside the process first: if most of the latency is a database
round trip or an upstream call, allocation work changes nothing.
- [ ] Get a baseline benchmark with `for b.Loop()` and
`go test -run '^$' -bench . -benchmem -count=10 > old.txt`.
- [ ] Collect the profile that matches the symptom — CPU, `-memprofile` for allocations,
block/mutex for contention, `runtime/trace` for scheduling and GC
(`references/performance-profiling.md`).
- [ ] Read `top -cum` before `top`: a high `cum` with a low `flat` is an orchestrator, so
drill into its children with `list <func>`. `runtime.mallocgc`, `runtime.growslice`
and `runtime.mapassign` at the top are symptoms of allocation in your code, not the
cause.
- [ ] Change one thing. Re-run the benchmark into `new.txt` and judge it with
`benchstat old.txt new.txt` — a single run is noise.
- [ ] Leave the reason in a comment next to the optimisation, with the delta. Otherwise
the next reader reverts it as pointless complexity.
- [ ] **Gate:** `benchstat` shows a statistically significant improvement (its `p` column),
and `go test -race ./...` is still green.
### upgrade-modules
- [ ] `go list -m -u all` to see what moved, and read the changelog of anything with a
major bump before touching `go.mod`.
- [ ] Upgrade within existing constraints first (`go get -u ./... && go mod tidy`), then
majors one module per commit so a regression has one suspect.
- [ ] Run `govulncheck ./...` — it reports only vulnerabilities your code actually reaches,
so a finding is real work.
- [ ] Track dev tools with `go get -tool <pkg>` and run them via `go tool <name>`
(Go 1.24+). Delete any `tools.go` blank-import file you find.
- [ ] Keep `go.sum` committed; `go mod verify` is what detects a tampered module cache.
- [ ] Use a `go.work` file for local multi-module development and never commit a `replace`
directive that points at a developer's disk.
- [ ] **Gate:** `go mod tidy` leaves the tree clean, `govulncheck ./...` reports nothing
reachable, and `go test -race ./...` passes on the new graph.
### review
Judging existing Go code without a base ref to diff against — a file, a package, a change
someone asks you to look over. Report using the Output format below.
- [ ] Read `go.mod` first: the `go` directive decides which of the rules below even apply,
and the dependency list tells you which conventions the package already follows.
- [ ] Run the tooling before reading, and skip anything it already reports:
`gofmt -l .`, `go vet ./...`, `golangci-lint run` if the repository configures it.
- [ ] Read the tests first. A missing test for a changed behaviour, or an assertion that
only replays a stub, is the most expensive thing to miss.
- [ ] Walk the Core rules in order; they are ordered by how often each one is the actual
defect. Concurrency and error handling produce the findings that matter.
- [ ] Reproduce anything you claim: `go test -race -count=10` for a suspected race, a
goroutine count around the operation for a suspected leak, a benchmark for a
performance claim. A finding you did not verify does not go in the report.
- [ ] For every leak or race you report, name the regression guard that keeps it fixed —
`goleak.VerifyNone(t)` in the package's tests, a `synctest` bubble that asserts the
exit, or the `goroutineleak` profile in production. A one-off script you delete
leaves nothing behind.
- [ ] Check the boundary the code presents to callers: exported surface, sentinel and
typed errors, whether `ctx` is threaded through, whether timeouts exist on every
outbound call.
- [ ] **Gate:** every finding carries `path:line`, a one-line reason, a concrete fix and a
severity, and the report ends with a verdict.
## Topic router
| Topic | Read when | File |
|---|---|---|
| Zero values, receivers, interfaces, generics, control flow, naming | Designing a type or an API, or judging idiom in existing code | `references/language-idioms.md` |
| `slices`/`maps`/`cmp`/`iter`, `math/rand/v2`, `log/slog`, `net/http` server and client, `encoding/json` | Reaching for a helper, writing an HTTP server or client, or modernising older code | `references/stdlib-modern-apis.md` |
| Goroutine lifetime, channels, `select`, sync primitives, `errgroup`, pipelines, race detector | Writing or reviewing concurrent code, or chasing a leak or a race | `references/concurrency.md` |
| Wrapping, sentinels, typed errors, `errors.Join`, panic/recover, error logging | Creating, wrapping, inspecting or logging errors | `references/errors.md` |
| Table tests, parallel traps, `synctest`, fuzzing, benchmarks, golden files, `httptest` | Writing, fixing or reviewing tests | `references/testing.md` |
| pprof, `runtime/trace`, `benchstat`, allocation reduction, GC tuning | Something is slow, allocating too much, or contended | `references/performance-profiling.md` |
| Package boundaries, `internal/`, `go.mod`, workspaces, versioning, `govulncheck` | Starting a project, moving code between packages, or upgrading dependencies | `references/modules-and-layout.md` |
| `gofmt`, `go vet`, `golangci-lint`, `go fix` modernizers, `gopls`, build cache | Setting up or interpreting tooling, or suppressing a lint warning | `references/tooling-and-lint.md` |
## Output format
When reporting on existing code rather than editing it, group findings by file, order them
by severity within a file, and skip preamble:
```
internal/fetch/fetcher.go
L31 blocking - package-level `cache` map written from N worker goroutines; `go test -race`
reports it and production hits a fatal `concurrent map writes`.
fix: drop the map, or guard it with a mutex owned by the type.
L52 blocking - `time.Sleep(100ms)` used as synchronization; the collector goroutine also
leaks because `out` is never closed.
fix: errgroup.WithContext + g.SetLimit(workers), collect after g.Wait().
L57 important - `http.Get` uses http.DefaultClient, which has no timeout.
fix: http.NewRequestWithContext with a client that sets one.
internal/fetch/parse.go
✓ pass
```
Severities: `blocking` (data race, leak, silently dropped error, wrong behaviour),
`important` (missing timeout, unbounded growth, API that will hurt callers), `minor`
(naming, dead code, an idiom the linter would catch). End with one line: ship, ship after
blocking fixes, or rework. Name the commands you actually ran; a finding you did not verify
does not go in the report.
## Environment
Go toolchain on `PATH`. Commands used by the workflows:
```bash
go vet ./... # always available; go test runs a subset automatically
go test -race ./... # the race detector needs cgo and a supported platform
go test -run '^$' -bench . -benchmem -count=10
gofmt -l . # non-empty output is a failure
go mod tidy && go mod verify
```
Installed on demand, each one line:
```bash
go get -tool golang.org/x/vuln/cmd/govulncheck # then: go tool govulncheck ./...
go get -tool golang.org/x/perf/cmd/benchstat # then: go tool benchstat old.txt new.txt
go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest
```
`golangci-lint` is the one tool worth a project config: a committed `.golangci.yml` is the
source of truth for which linters run, and CI must run the same file. `-race` roughly
doubles runtime and increases memory use, so run it on the package under change locally and
on the whole tree in CI.
Pliki w paczce (30)
- NOTICE.md 6 KB
- SKILL.md 18 KB
- SOURCES.yaml 13 KB
- evals/evals.json 11 KB
- evals/files/cache_test.go 1 KB
- evals/files/fetcher.go 1 KB
- evals/files/store.go 2 KB
- evals/files/cfglib/cfglib-config.go 1 KB
- evals/files/cfglib/cfglib-go.mod 1 KB
- evals/files/modernize/linkutil-go.mod 1 KB
- evals/files/modernize/linkutil-link.go 1 KB
- evals/files/modernize/svc-go.mod 1 KB
- evals/files/modernize/svc-orders.go 2 KB
- evals/files/poller/go.mod 1 KB
- evals/files/poller/poller.go 1 KB
- evals/files/poller/poller_test.go 1 KB
- evals/files/relay/go.mod 1 KB
- evals/files/relay/relay.go 1 KB
- evals/files/relay/review.md 1 KB
- evals/files/webhook/go.mod 1 KB
- evals/files/webhook/webhook.go 1 KB
- evals/files/webhook/webhook_test.go 1 KB
- references/concurrency.md 13 KB
- references/errors.md 8 KB
- references/language-idioms.md 10 KB
- references/modules-and-layout.md 9 KB
- references/performance-profiling.md 10 KB
- references/stdlib-modern-apis.md 10 KB
- references/testing.md 13 KB
- references/tooling-and-lint.md 9 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · lynricsy/hyperskills | 100 | MIT |
| ericrisco/rsc-harness | 100 | MIT |
| terrylica/cc-skills | 100 | MIT |
| maragudk/fabrik | 100 | MIT |
| znlgis/opengis-skills | 100 | MIT |
| dilhanz/ship | 100 | MIT |
| chrs-myrs/livespec | 100 | MIT |
| nimadorostkar/Claude-Skills-collection | 100 | MIT |
| appwrite/claude-plugin | 100 | BSD-3-Clause |
Migawka bazy z 13.11.2026 · wersja paczki 1698deaff870 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100go-pprof-cpu-memory-goroutine-profiling
Analizuje zużycie CPU, alokacje pamięci i wycieki gorutyn w aplikacjach Go za pomocą runtime/pprof. - 100go-concurrency
Pomaga pisać i przeglądać współbieżny kod Go: goroutines, kanały, errgroup, anulowanie przez context i wycieki goroutines. - 90performant-go
Pomaga pisać wydajne systemy w Go: gorutyny, kanały, profilowanie przez pprof, pamięć i wyrównanie struktur. - 100profile-memory
Profiluje zużycie pamięci sidecara w Go przez pprof: szuka wycieków pamięci i goroutin, nadmiaru deskryptorów oraz kosztownego CPU. - 100go-troubleshooting
Diagnozuje problemy runtime w programach Go: paniki i stack trace, deadlocki, wycieki goroutines i pamięci, OOM, raporty race oraz debugowanie z delve i pprof. - 100sota-golang
Stosuje zasady pisania i audytu kodu w Go: obsługa błędów, projekt interfejsów, goroutines i kanały, utwardzanie net/http, bezpieczeństwo, wydajność z pprof oraz narzędzia i CI.