Go Turbo Review

go-turbo-review

Review the diff for performance. One line per finding: location, what's wrong, what replaces it. The best outcome is no actionable performance regression and no speculative complexity.

Two directions matter equally here. Reviewers reliably catch the added allocation; they reliably miss the sync.Pool added to a cold path, which costs a lifetime bug and buys nothing. Flag both.

Format

L: . . — or :L: for multi-file diffs.

Tags:

• alloc: avoidable allocation on a path that looks hot. Name the fix.
• escape: value pushed to the heap by code shape. Name the restructure.
• algo: complexity that will not hold at scale — nested scan, repeated

sort, linear lookup in a loop.

• sync: unbounded goroutines, contention, over-wide critical section,

serialization through a channel.

• io: per-item syscall, query, or round trip that should be batched or

buffered.

• net: undrained response body, missing timeout, transport misconfiguration,

per-request client construction.

• leak: goroutine or memory retention — no exit path, unbounded queue,

retained sub-slice of a large buffer.

• premature: optimization with no evidence, costing readability or safety

for an unmeasured win. Replacement: the simpler code.

• layout: struct padding or false sharing worth fixing at this volume.

Examples

Not this:

> "Have you considered whether this slice could be preallocated? It might > improve performance under certain conditions."

This:

• L34: alloc: append into nil slice, len(rows) known. make([]Result, 0, len(rows)).
• L12: escape: measured constructor allocation comes from returning *Point; identity and nil are unused. Return Point by value and remeasure.
• L88: algo: linear scan of routes inside the request loop, O(n·m). Build the map once at startup.
• L51: sync: goroutine per message, unbounded. Use errgroup.SetLimit with a bound derived from the CPU or dependency budget.
• L23: io: db.Exec per row inside the loop. Batch with CopyIn or a multi-value insert.
• L67: net: this bounded HTTP/1 body is not consumed to EOF before Close, so reuse may be lost. Consume it or deliberately forgo reuse.
• `L102: leak: queue allocs/op on the hot path, - round trips per request.

Quantify only what measured evidence can defend. If the diff is clean:
`No actionable performance finding.`

## Boundaries

Performance only. Correctness bugs, security issues, and style go to a normal
review pass — mention them in one line if severe and move on, but don't take
them over. Lists findings, applies nothing. One-shot.

For a whole repository rather than a diff, use `$go-turbo-audit`. To apply
the fixes, `$go-turbo-improve`.
Task-scoped.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [hendriknielaender](https://github.com/hendriknielaender)
- **Source:** [hendriknielaender/go-turbo](https://github.com/hendriknielaender/go-turbo)
- **License:** MIT

Install and usage instructions live in the source repository linked above.