Skip to content
OpenAgentSkill
Browsing is open · Catalog captured 2026-11-21 · Automatic updates and account services are paused.
Data & analytics

go-performance-review

Review Go code for performance issues including slice/map pre-allocation, string concatenation, N+1 queries, connection pool configuration, sync.Pool, memory alignment, lock scope, buffered I/O, and HTTP transport tuning. Trigger when code contains make(), loops, database queries, string building, sync primitives, HTTP clients, or hot-path operations. Use for performance-focused review.

johnqtcg · Static checks on file

Installation

Read the source and dependencies before running a command. Copying does not install or execute anything.

npx skills add johnqtcg/awesome-skills --skill go-performance-review

About this skill


name: go-performance-review description: Review Go code for performance issues including slice/map pre-allocation, string concatenation, N+1 queries, connection pool configuration, sync.Pool, memory alignment, lock scope, buffered I/O, and HTTP transport tuning. Trigger when code contains make(), loops, database queries, string building, sync primitives, HTTP clients, or hot-path operations. Use for performance-focused review. allowed-tools: Read, Grep, Glob, Bash(go build*), Bash(go vet*), Bash(go test -bench*)

Go Performance Review

Purpose

Identify performance issues and resource inefficiency in Go code. This skill exists because performance findings are almost all Medium severity and get systematically crowded out when mixed with High-severity Security/Concurrency findings.

Important distinction: lock contention is performance (here); race condition is concurrency (go-concurrency-review).

This skill does NOT cover: security, concurrency correctness, code style, test quality, error handling, or business logic — those belong to sibling vertical skills.

When To Use

  • Code contains make([]T, ...) or make(map[K]V, ...)
  • Code builds strings in loops
  • Code queries DB/Redis inside loops
  • Code configures connection pools or HTTP clients
  • Code runs on hot paths (per-request, high-frequency)

When NOT To Use

  • Security vulnerabilities → go-security-review
  • Race conditions, goroutine leaks → go-concurrency-review
  • Code style/lint → go-quality-review
  • Error handling → go-error-review

Mandatory Gates

1) Go Version Gate

Read go.mod. Key: strings.Clone (1.20+), slices.Clone (1.21+).

2) Anti-Example Suppression Gate

MUST quote specific evidence. Category match alone insufficient.

Embedded anti-examples:

  • "Should pre-allocate slice" — when slice is small (<16 elements) or size is truly unknown at creation time. Must cite evidence the slice is large and size is known.
  • "Should use sync.Pool" — when object is small and allocated infrequently (cold path, startup, config).
  • "Struct fields should be reordered" — when struct has <4 fields or alignment savings <8 bytes.
  • "Should use strings.Clone" — when both substring and parent are short-lived locals in same GC scope.
  • "Add Count-First guard" — when the business domain guarantees the query always returns rows (e.g., seeded reference data, system-level lookups). Must cite evidence that total==0 is impossible in practice.
  • Hot-path rule: Do NOT flag performance issues in cold-path code (startup, one-time init, config loading, test setup, CLI argument parsing). Must cite evidence of hot-path execution: "called per HTTP request", "inside for loop over N items", "in handler serving N QPS".

3) Generated Code Exclusion Gate

Exclude: *.pb.go, *_gen.go, mock_*.go.

Workflow

  1. Define scope — files/diff under review. Apply Generated Code Exclusion Gate.
  2. Gather evidence — read changed files, identify performance-relevant patterns: make(), append(), loops, DB queries, strings.Builder, sync.Pool, HTTP clients.
  3. Load references — always load go-performance-patterns.md; load go-database-patterns.md when DB code present.
  4. Classify hot-path vs cold-path — only flag issues in frequently executed code. Cite execution frequency evidence.
  5. Evaluate ALL 13 checklist items with quantification → suppress cold-path items → format output.

Grep-Gated Execution Protocol

This skill uses mechanical grep pre-scanning to guarantee zero missed checklist items. 11 of 13 items are grep-gated; 2 are semantic-only.

Execution Order

  1. Identify target files (from dispatch prompt, or write raw snippet to $TMPDIR/review_snippet.go)
  2. Run grep for all grep-gated checklist items against target files
  3. HIT → run semantic analysis to confirm or reject (verify hot-path, quantify impact)
  4. MISS → auto-mark NOT FOUND, skip semantic analysis
  5. For compound patterns: run primary grep, then check secondary condition
  6. For semantic-only items (items 6, 9): full model reasoning
  7. Report only FOUND items

Grep Audit Line

Include in Execution Status: Grep pre-scan: X/11 items hit, Z confirmed as findings (2 semantic-only)

Key Compound Pattern: Slice Pre-allocation (Item 1)

This is the highest-priority compound pattern — it catches the most common performance miss:

  • Primary: make\(\[\] HIT
  • Secondary: check if the make call has only 2 args (no capacity) AND an upper bound is known (e.g., len(input))
  • Example: make([]*User, 0) when len(userKeys) is available → FINDING

Performance Checklist (12 Items)

All Medium severity unless marked (Low).

#ItemQuantification PatternGrep Pattern
1Missing slice pre-allocationmake([]T, 0) when upper bound known → "N grow-and-copy → 1 allocation"make\(\[\] (compound: AND NOT 3-arg make with capacity — check for make\(\[\][^,]+,\s*\d+,\s*\d+\) absent)
2String concatenation in loop+= in loop → strings.Builder + Grow() — "N allocations + N copies → 1"\+=\s*""|\+=\s*\w+\s*$ (compound: inside for loop — semantic confirmation)
3N+1 queryIndividual DB/Redis calls in loop → batch WHERE IN or pipeline — "N round-trips → 1"\.Query|\.Exec|\.Get|\.Set (compound: inside for loop — N+1 detection)
4Missing connection pool configMissing SetMaxOpenConns, SetMaxIdleConns, SetConnMaxLifetime — connection exhaustion riskSetMaxOpenConns|SetMaxIdleConns|SetConnMaxLifetime|sql\.Open|pgx\.Connect
5Missing sync.PoolHot-path allocations without pooling; pool without Reset before Put — quantify allocation frequencysync\.Pool
6Struct memory alignmentFields poorly ordered → fieldalignment tool — quantify savings in bytes per instanceSemantic-Only (struct field alignment requires counting fields and
Read the complete source ↗