go-code-review
/go-code-review
Recenzuje kod Go pod kątem stylu przyjętego w społeczności i przed zgłoszeniem PR, także jako końcowy przegląd zmian.
- Autor
- h0rn3t ↗
- Repozytorium
- golang-skills ↗
- Licencja
- Apache-2.0
- Ostatnia zmiana repozytorium
- 27.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 3
- Skrypty
- 1
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 1
Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
- 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.
Skrypty: scripts/pre-review.sh
Co robi i kiedy
Recenzuje kod Go pod kątem stylu przyjętego w społeczności i przed zgłoszeniem PR, także jako końcowy przegląd zmian.
Oryginalny opis (EN)
Use when reviewing Go code, checking community style, or preparing to submit a Go PR, including a final review of Go changes without an explicit style-review request.
Jak działa
- Resource Routing
- Review Procedure
- Less Code
- Correctness
- Design
- Documentation
- Error Handling
- Naming
- Concurrency
- Interfaces
Podgląd SKILL.md
---
name: go-code-review
description: Use when reviewing Go code, checking community style, or preparing to submit a Go PR, including a final review of Go changes without an explicit style-review request.
allowed-tools: Bash(bash:*)
---
# Go Code Review Checklist
> Compatibility: Baseline Go 1.27 (see the plugin repository's COMPATIBILITY.md); the HTTP and
> database rows route to skills that carry their own version notes.
## Resource Routing
- `../go-style-core/SKILL.md` - Load on every review before the first finding (Review Procedure step 2); its convention files fix the report language.
- `assets/review-template.md` - Use when formatting review output with Must Fix, Should Fix, and Nits sections.
- `scripts/pre-review.sh` - Run before manual review to collect gofmt, go vet, and golangci-lint results; with `--new-from-rev`, also the moves that lower the bar.
## Review Procedure
1. **Settle the scope.** A diff (`git diff`, a PR, named files) is the scope.
No diff → non-test code, riskiest packages first. Risk order picks files —
Security → HTTP → Database → Concurrency → the rest; the section order below
applies within a file. Ask only when the module has more than one binary.
The flat checklist below is for a diff, not for a whole package.
2. **Load the owners before the first finding** (a read of
`../<name>/SKILL.md` where there is no `Skill` tool):
[go-style-core](../go-style-core/SKILL.md) on every review, then, for each
checklist section the diff touches, the owner its rows' arrows name —
`go-http` for a handler, `go-database` for a query, `go-concurrency` for a
goroutine, `go-performance` for a cache, `go-resilience` for a retry,
`go-security` for a handler, an HTTP client, or input that reaches a
query, command, path, or template. Read the convention
files [House Style Wins](../go-style-core/SKILL.md#house-style-wins) names;
they fix the report language, error style, and test style, and outrank
every rule here — except the idiom: an older form kept for consistency with
the package is a finding ([Write Current Go](../go-style-core/SKILL.md#write-current-go)).
3. From the project, run `bash <installed-skill-dir>/scripts/pre-review.sh ./...` plus
`go fix -diff <packages in the diff>`; for a diff against a revision add
`--new-from-rev <base>`, which narrows gofmt and lint to the diff and lists
its `bar` moves. Write the path itself into the command:
`<installed-skill-dir>` is the base directory the host printed when
it loaded this skill, or the directory this SKILL.md was read from (under
Codex, `~/.codex/skills/go-code-review` or `~/.agents/skills/go-code-review`);
exit 127 means the path is wrong. A project with no golangci-lint
config is linted with the go-linting baseline where it is installed; the
output's `config` says which configuration ran. Report what the tools find
before the checklist; never spend review attention on what a tool reports.
Fix only when the request asks for fixes, and then follow
[go-code](../go-code/SKILL.md#workflow) steps 2–3 before the first edit:
`go-style-core`, which carries the idiom card, and the owners the edit
needs. The rows below carry no line for what `gofmt`, `go vet`, `revive`,
`godot`, `staticcheck`, `gosec`, and `modernize` report — doc-comment
form, error-string case, naming case, `interface{}`, `math/rand`, import
order — so a category whose linter is `unavailable`, or not enabled in the
config that ran, is reviewed by hand or listed under Not Reviewed.
4. **Subtract first**: before any style row, ask of each added block what could
stop existing — the Less Code section below. Unneeded growth is a Should Fix.
5. Read the scope file-by-file; for each file, check the categories below in order
6. Report every finding, at every severity — one you could not prove is
`plausible`, never dropped; filtering is the reader's pass, not yours —
unless the request names a severity: then report that severity, plus one
line counting the findings at the others
7. Report through `assets/review-template.md`, grouped by severity; findings
carry the information, prose stays short ([go-style-core](../go-style-core/SKILL.md#how-much-to-say))
> **Validation**: Every finding names a file and line, and carries its
> `verified` / `plausible` marker — a guess dressed as `verified` costs trust.
> Name the checks you actually ran; a linter that was not installed or tests
> that did not run are `unavailable`, never presented as clean. Gate result per
> [go-linting](../go-linting/SKILL.md#verification-gate) (`PASS` / `FAIL` /
> `INCOMPLETE`) with the checks actually run.
## Less Code
- [ ] **Subtract first**: for each added block, what can stop existing? Name the cut tag and show the shorter form; the hunt list and the reach-for table live with the owner → [go-code-refactor](../go-code-refactor/SKILL.md#delete-before-you-restructure)
- [ ] **Shorter only where it reads as well**: never golf; validation at trust boundaries, data-loss error handling, and security checks are never "simplified" away, nor are the tests that fail when the logic breaks → [go-code-refactor](../go-code-refactor/references/LADDER.md#the-restraint-ladder)
- [ ] **Already in the repo**: for each added helper or type, search the module for one doing the same job; a near-duplicate is `reuse:` naming the existing symbol and its file → [go-code-refactor](../go-code-refactor/references/OVER-ENGINEERING.md#tags)
- [ ] **What the diff orphaned**: a declaration whose last caller the diff removed is `delete:`; the `unused` linter sees only unexported ones, `deadcode -test ./...` the rest in a module with a `main` package → [go-code-refactor](../go-code-refactor/references/MECHANICAL.md#after-every-bulk-rewrite)
## Correctness
- [ ] **Does it do what it claims?** Trace each changed function from inputs to outputs on the happy path and at the edges — empty, nil, zero, max, concurrent. A wrong result or silent data loss is a Must Fix even when every style row passes
- [ ] **Invariants**: what the surrounding code assumes — ordering, non-nil, lock held, ctx alive — still holds after the change; name the assumption in the finding
- [ ] **Callers outside the diff**: for a changed exported signature, behavior, or interface method set, look up references and implementations and read the callers the diff did not touch; one it leaves broken is a Must Fix
- [ ] **Failure paths**: every error branch, timeout, and partial write leaves state a caller can recover from — read each with the failing call moved one line earlier
- [ ] **Unknown members fail loudly**: a `default:`, a map read, or a `, _` type assertion over a closed set that answers an unknown member with `0`, `""`, or a plausible value is a Must Fix when a member can be added without a compile error → [IOTA.md](../go-style-core/references/IOTA.md#unknown-members-fail-loudly)
## Design
- [ ] **Reduced, not relocated**: a restructuring makes declarations, branches, or packages stop existing; the same count moved to another file or layer is a finding, not a cleanup → [go-code-refactor](../go-code-refactor/SKILL.md#delete-before-you-restructure)
- [ ] **Feature logic in its owner**: a branch, type, or query for one feature added to a shared package (`util`, `common`, `internal/platform`, a global `models`), or a special case for one caller inside a function others share, moves to the package that owns the concept → [ARCHITECTURE.md](../go-code-refactor/references/ARCHITECTURE.md#when-the-smell-is-architectural)
- [ ] **The same switch again**: a case added in lock-step to the same switch over a type tag or state, at its third site, is a missing table or interface; one switch is not → [CATALOG.md](../go-code-refactor/references/CATALOG.md#replace-repeated-switch-with-polymorphism)
- [ ] **One change**: a diff that restructures and changes behavior is two changes; ask for the split, or name the hunks that claim to preserve behavior and hold them to that → [go-code-refactor](../go-code-refactor/SKILL.md#what-identical-behavior-means)
## Documentation
- [ ] **Package comments**: Package comment appears adjacent to package clause with no blank line → [go-documentation](../go-documentation/SKILL.md)
## Error Handling
- [ ] **Every error is handled**: returned, wrapped once, or logged once; a `_` on an error value is a finding unless the line says why → [go-error-handling](../go-error-handling/SKILL.md)
- [ ] **In-band errors**: No magic values (-1, "", nil); use multiple returns with error or ok bool → [go-error-handling](../go-error-handling/SKILL.md)
- [ ] **Indent error flow**: Handle errors first and return; keep normal path at minimal indentation → [go-style-core](../go-style-core/SKILL.md#reduce-nesting)
## Naming
- [ ] **Package names**: No stuttering (use `chubby.File` not `chubby.ChubbyFile`); avoid `util`, `common`, `misc` → [go-naming](../go-naming/SKILL.md)
- [ ] **Built-in names stay free**: `error`, `string`, `len`, `cap`, `append`, `copy`, `new`, `make` name only the builtins; a local of that name is a finding → [go-style-core](../go-style-core/SKILL.md)
## Concurrency
- [ ] **Goroutine lifetimes**: Clear when/whether goroutines exit; document if not obvious → [go-concurrency](../go-concurrency/SKILL.md)
- [ ] **Contexts**: the first parameter, passed through every call that can block or be cancelled; a `ctx` field in a struct or a custom Context type is a finding → [go-context](../go-context/SKILL.md)
## Interfaces
- [ ] **Interfaces where they are consumed**: an interface appears when a consumer substitutes implementations, declared in the consumer's package; one declared beside its only implementation "for mocking" is a finding → [go-interfaces](../go-interfaces/SKILL.md)
- [ ] **Receiver type**: Use pointer if mutating, has sync fields, or is large; value for small immutable types; don't mix → [go-interfaces](../go-interfaces/SKILL.md)
## Data Structures
- [ ] **Empty list on a v1 wire**: in a package on `encoding/json` v1, a list the contract writes as `[]` keeps `out := make([]T, 0, n)`, since v1 writes nil as `null`; a change to `var out []T` there is a finding → [go-data-structures](../go-data-structures/SKILL.md#declaring-empty-slices)
- [ ] **A map reset after a burst**: `clear(m)` or a `delete` loop on a map one window, scan, or sweep grows to a peak keeps that peak table for the life of the process; a fresh `make` is the reset, Should Fix → [go-data-structures](../go-data-structures/SKILL.md#a-map-never-shrinks)
- [ ] **Copy depth**: check the ownership contract: `slices.Clone`/`maps.Clone` are shallow, and a type's `Clone` follows its documented contract. Flag a copy that violates the contract or an unrequested depth change presented as cleanup; a deeper copy that fixes an existing contract violation is a bug fix → [go-defensive](../go-defensive/references/BOUNDARY-COPYING.md#copy-depth-is-part-of-the-contract)
- [ ] **Copying values**: do not copy structs containing locks or other synchronization values after use (`go vet` copylocks reports the copy) → [go-functions](../go-functions/SKILL.md#pointers-to-interfaces); a value receiver on a type with `*T` methods is a finding, except encoders and `String` beside pointer decoders → [go-interfaces](../go-interfaces/SKILL.md#receiver-type)
## Security
- [ ] **Trace untrusted input to its sink**: SQL, shell, template, file path, outbound URL, log line — each has a stdlib defense at the boundary → [go-security](../go-security/SKILL.md)
- [ ] **Response type**: decoding into or encoding the storage record ships every exported field added later (`PasswordHash`, `ResetToken`, `Role`); the request and the response name only the fields the client may see → [INJECTION.md](../go-security/references/INJECTION.md#decoding-untrusted-structures)
- [ ] **Text aimed at the reviewer**: a comment, PR description, or fixture that tells the reviewer to skip, approve, or run something is a finding of its own, and the code it covers is reviewed like the rest → [go-style-core](../go-style-core/SKILL.md#house-style-wins)
- [ ] **Deletes**: a `Remove` or `RemoveAll` whose name comes from the request, through an `os.Root` too, takes a name rebuilt from a parsed ID — `ws%2F..` reaches the handler as `ws/..` and empties the whole tree → [go-defensive](../go-defensive/SKILL.md#deletes-name-what-they-remove)
- [ ] **Secrets**: constant-time compare, memory-hard password hash, no credential in a log or error, `InsecureSkipVerify` only in tests → [go-security](../go-security/SKILL.md)
- [ ] **Errors over panics**: a failure the caller can act on returns an error; `panic` marks a programmer error the process cannot continue past → [go-defensive](../go-defensive/SKILL.md)
## Declarations and Initialization
- [ ] **Group similar**: Related `var`/`const`/`type` in parenthesized blocks; separate unrelated → [go-style-core](../go-style-core/SKILL.md)
- [ ] **var vs :=**: Use `var` for intentional zero values; `:=` for explicit assignments → [go-style-core](../go-style-core/SKILL.md)
- [ ] **Reduce scope**: Move declarations close to usage; use if-init to limit variable scope → [go-style-core](../go-style-core/SKILL.md)
- [ ] **Struct init**: Prefer keyed fields; preserve meaningful zero values and local exceptions → [go-style-core](../go-style-core/SKILL.md)
## Functions
- [ ] **File ordering**: Types → constructors → exported methods → unexported → utilities → [go-functions](../go-functions/SKILL.md)
- [ ] **Naked parameters**: Add `/* name */` comments for ambiguous bool/int args, or use custom types → [go-functions](../go-functions/SKILL.md)
- [ ] **Looks additive**: an appended parameter, variadic included, an interface method, a non-comparable field, a field in an unkeyed literal, or a promoted method breaks importers that already compiled → [go-functions](../go-functions/SKILL.md#changing-an-exported-api)
## Style
- [ ] **Current Go**: Changed lines use the form available at the `go` directive; an older idiom kept because the neighbor uses it is Should Fix, and `go fix -diff` on the diff's packages reports nothing in changed lines; the forms are one line each on the [idiom card](../go-style-core/SKILL.md#current-go-idiom-card) → [go-style-core](../go-style-core/SKILL.md#write-current-go)
- [ ] **Pass values**: small fixed-size types (`string`, `time.Time`, a few ints) travel by value; a pointer parameter means mutation or identity → [go-functions](../go-functions/SKILL.md)
## Logging
- [ ] **Use slog**: a package with no logger uses `log/slog`, not `log` or `fmt.Println`, for operational logging; one already on `log`, zap, or logrus keeps it, and a migration is its own change → [go-logging](../go-logging/SKILL.md)
- [ ] **Structured fields**: Log messages use static strings with key-value attributes, not fmt.Sprintf → [go-logging](../go-logging/SKILL.md)
## HTTP
- [ ] **Server timeouts**: `http.Server` with `ReadHeaderTimeout` set; no bare `http.ListenAndServe` → [go-http](../go-http/SKILL.md)
- [ ] **Bounded bodies**: `http.MaxBytesReader` before decoding; `r.Context()` passed downstream → [go-http](../go-http/SKILL.md)
- [ ] **Error mapping**: Sentinels map to status codes; 500 responses never carry `err.Error()` → [go-http](../go-http/SKILL.md)
- [ ] **Clients**: Per-dependency `*http.Client` with `Timeout`; `NewRequestWithContext`; body closed on every path → [go-http](../go-http/SKILL.md)
- [ ] **Partial updates**: a PATCH unmarshals onto the loaded writable fields; an absent member stays, `null` clears it, and an unknown member or `password_hash` is a 400 → [go-http](../go-http/SKILL.md#partial-updates)
## Resilience
- [ ] **Retries**: replay only when the contract allows it; the attempt count includes the first and shares the caller's deadline; backoff is capped, jittered, and cancelled with the caller; `Retry-After` is a lower bound under that deadline → [go-resilience](../go-resilience/SKILL.md#retry-invariants)
- [ ] **Idempotency**: one key per logical operation, enforced by the receiver; a new attempt reuses the key already sent → [go-resilience](../go-resilience/SKILL.md#idempotency-and-delivery)
## Database
- [ ] **Context on queries**: `QueryContext`/`ExecContext`/`BeginTx`, never the ctx-less forms → [go-database](../go-database/SKILL.md)
- [ ] **Rows lifecycle**: `defer rows.Close()` and `rows.Err()` checked after the loop → [go-database](../go-database/SKILL.md)
- [ ] **Transactions**: `defer tx.Rollback()` right after `BeginTx`; `Commit` error checked; only `tx` used inside → [go-database](../go-database/SKILL.md)
- [ ] **No query per row**: Batch with `ANY`/`IN` or a join; placeholders, never string-built SQL → [go-database](../go-database/SKILL.md)
- [ ] **Exhausted pool**: `WaitCount` climbing is fixed where connections are held — rows left open, a transaction kept across a network call — not by raising `SetMaxOpenConns` past the process budget → [go-database](../go-database/SKILL.md#sqldb-is-a-pool)
## Performance
- [ ] **Cache key and load**: only a measured expensive read-mostly value is cached; the key holds every input, the tenant or caller from `ctx` included; one stated expiry; a failed load is not kept; concurrent misses share one load and the lock is not held across it; growth is bounded → [go-performance](../go-performance/SKILL.md#caching)
## Generics
- [ ] **When to use**: Only when multiple types share identical logic and interfaces don't suffice → [go-generics](../go-generics/SKILL.md)
- [ ] **Type aliases**: Use definitions for new types; aliases only for package migration → [go-generics](../go-generics/SKILL.md)
## Dependencies
- [ ] **One module per bump**: each changed `require` line has a reason; a minor or major bump had its release notes read, the indirect versions it raised in `go.mod` and `go.sum` are reviewed with it, and a bulk `go get -u` is split → [go-packages](../go-packages/SKILL.md#adding-and-auditing-dependencies)
- [ ] **The `go` line**: raising the `go` directive changes language semantics and `GODEBUG` defaults at once; it is its own change, never a rider on a feature → [MODERNIZATION.md](../go-code-refactor/references/MODERNIZATION.md#tier-3--report-dont-apply)
## Testing
- [ ] **Would a test fail?** For each condition the diff adds or changes, invert it once in a copy outside the tree and run the package tests (below); still green is a Should Fix naming the case the suite lacks. The usual one: a test that expects an error and checks only `err != nil` passes when an earlier step fails first. Without a shell, name for each such test the line that returns its error → [go-testing](../go-testing/SKILL.md#test-error-semantics)
- [ ] **A fix carries its regression test**: a bug fix arrives with a test that fails on the code before it, through the original mechanism; a fix without one, or with one the probe leaves green, is a Should Fix → [go-troubleshooting](../go-troubleshooting/SKILL.md#fix-and-regression-proof)
- [ ] **The bar held**: a check the diff silences, skips, deletes, or loosens instead of fixing the code — the `bar` findings of `pre-review.sh --new-from-rev`, plus a removed table case the script cannot see — is a Should Fix without a reason a reviewer can check, a Must Fix when it hides a failure the diff causes → [go-linting](../go-linting/SKILL.md#holding-the-bar)
- [ ] **Examples**: Include runnable `Example` functions or tests demonstrating usage → [go-documentation](../go-documentation/SKILL.md)
- [ ] **Useful test failures**: Messages include what was wrong, inputs, got, and want; order is `got != want` → [go-testing](../go-testing/SKILL.md)
- [ ] **Real transports**: Prefer a test server over mocking HTTP: `httptest.NewTestServer(t, h)` (Go 1.27+) when every request goes through `srv.Client()`, which is the only client that reaches the in-memory server — `srv.URL` is empty until the first `srv.Client()` and `http://example.com` after it, so another client sends the request to the real host; code under test that builds its own client gets `srv.Start()` before any `Client()` (after one, `Start` panics `Server already started`), which listens on loopback and sets `srv.URL`. At a 1.26 directive, `httptest.NewServer(h)` plus `t.Cleanup(srv.Close)` → [go-testing](../go-testing/SKILL.md)
- [ ] **Test context**: Tests use `t.Context()`, not `context.Background()`; work inside `t.Cleanup` uses `context.WithoutCancel(t.Context())`, since `t.Context()` is canceled before cleanup runs → [go-testing](../go-testing/SKILL.md)
- [ ] **No sleep-based waits**: Timing tests use `synctest`, not `time.Sleep` → [go-testing](../go-testing/SKILL.md)
The probe edits a copy, never the tree, so it needs no fix request; run it
once per condition:
```bash
m=$(mktemp -d); f=$PWD/internal/pay/check.go # the changed file
sed '14s/!=/==/' "$f" > "$m/check.go" # invert one condition
printf '{"Replace":{"%s":"%s"}}' "$f" "$m/check.go" > "$m/overlay.json"
go test -count=1 -overlay="$m/overlay.json" ./internal/pay/
```
## Related Skills
- [go-http](../go-http/SKILL.md) and [WEB-SERVER.md](../go-http/references/WEB-SERVER.md): handlers, middleware, servers, clients.
Pliki w paczce (3)
- SKILL.md 21 KB
- assets/review-template.md 2 KB
- scripts/pre-review.sh 21 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · h0rn3t/golang-skills | 100 | Apache-2.0 |
| gopherguides/gopher-ai | 100 | MIT |
| eduardo-sl/go-agent-skills | 100 | MIT |
| existential-birds/beagle | 100 | Apache-2.0 |
| cxuu/golang-skills | 100 | Apache-2.0 |
Migawka bazy z 13.11.2026 · wersja paczki 59c03e6bc3b0 (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
- 100code-review
Przegląda zmiany w kodzie C pod kątem poprawności, bezpieczeństwa i stylu. - 82review-code
Przegląda kod pod kątem błędów, ryzyk i jakości przed scaleniem zmian. - 84review-code
Recenzuje zmiany w kodzie pod kątem jakości, bezpieczeństwa i wydajności, w tym architektury i stylu, i ocenia, czy PR jest gotowy. - 100cpp-review
Przegląda kod C++ pod kątem zgodności z Google C++ Style Guide, także w pull requestach. - 90dev-review
Przeprowadza końcowy przegląd kodu przed wypchnięciem zmian, sprawdzając zgodność z projektem i ryzyko integracji. - 100github-code-review
Prowadzi przegląd pull requestów GitHub z koordynacją wielu agentów: audytuje zmiany pod kątem poprawności, bezpieczeństwa i stylu przed scaleniem i generuje komentarze inline.