review-performance

Audits Go code performance risks including allocation hotspots and benchmark coverage across pull requests and full codebases.

9|Updated Mar 22, 2026
One-click install
npx skills add https://github.com/paultyng/skill-issue --skill review-performance-paultyng
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: review-performance
Source: https://github.com/paultyng/skill-issue/tree/main/skills/review-performance
Command: npx skills add https://github.com/paultyng/skill-issue --skill review-performance-paultyng

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill eliminates unstructured, inconsistent performance reviews that often miss critical allocation hotspots, algorithmic regressions, and missing benchmark coverage, preventing latency regressions and unnecessary resource costs in code changes.

Core Features & Use Cases

  • Structured perf analysis: Flags Go-specific allocation hotspots, O(n²) algorithmic issues, concurrency inefficiencies, and insufficient benchmark coverage, with cross-language support for TypeScript, Python, and Rust.
  • Tool integration: Leverages static analysis tools like staticcheck and gocyclo to surface risks without running noisy benchmarks by default, and supports subagent-powered deep dives into in-scope code.
  • Use case: For a PR touching a high-traffic RPC handler, use this skill to identify unpooled per-request allocations, missing large-input benchmark coverage, and unbounded goroutine fan-out before merging.

Quick Start

Use the review-performance skill to audit the performance of the changed files in your current PR, including allocation patterns, algorithmic complexity, and benchmark coverage.

Frequently Asked Questions about review-performance

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I catch performance regressions before merging a pull request?

To catch performance regressions pre-merge, you can review code changes for allocation hotspots and algorithmic complexity without running noisy benchmarks by default. This approach uses static analysis to flag latency risks and missing benchmark coverage.

How do I identify allocation hotspots in a Go codebase?

You identify allocation hotspots in a Go codebase by applying structured performance audits that flag unpooled per-request allocations and concurrency inefficiencies. The review integrates static analysis tools like staticcheck to surface these risks.

Can I use static analysis to audit algorithmic complexity instead of running benchmarks?

Yes, you can audit algorithmic complexity using static analysis instead of running benchmarks. This measurement-focused workflow surfaces O(n²) issues and concurrency inefficiencies by leveraging tools like gocyclo, avoiding noisy benchmark execution by default.

Does this performance review workflow support languages other than Go?

Yes, the performance review workflow supports languages other than Go with cross-language support for TypeScript, Python, and Rust. It applies structured analysis to assess performance-sensitive features across these codebases.

When do I need a code performance audit for high-traffic services?

You need a code performance audit for high-traffic services when changes touch hot paths, batch jobs, or RPC handlers. An audit identifies unbounded goroutine fan-out and missing large-input benchmark coverage before deployment.

Why does my performance review miss critical latency regressions?

Unstructured performance reviews miss critical latency regressions because they lack measurement-focused workflows and explicit evidence requirements. Implementing a structured audit flags algorithmic regressions and insufficient benchmark coverage effectively.