performance-review

Analyze source code for performance anti-patterns in code review workflows.

3|Updated May 12, 2026
One-click install
npx skills add https://github.com/gao-hongnan/omniagents --skill performance-review-gao-hongnan
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: performance-review
Source: https://github.com/gao-hongnan/omniagents/tree/main/plugins/reviewer/skills/performance-review
Command: npx skills add https://github.com/gao-hongnan/omniagents --skill performance-review-gao-hongnan

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill addresses the gap between functional code and production-ready performance by identifying algorithmic inefficiencies, resource leaks, and blocking operations that cause system degradation at scale.

Core Features & Use Cases

  • Performance Hunt Protocols: Systematic auditing for N+1 queries, unbounded memory usage, and event-loop stalls.
  • Severity Calibration: Provides a structured rubric to distinguish between critical blockers and minor suggestions based on blast radius and call frequency.
  • Use Case: Use this during a pull request review to automatically detect if a new database query lacks an index or if a loop contains an unbounded memory allocation that could lead to an OOM error.

Quick Start

Run the performance-review skill on the current diff to identify potential bottlenecks and scalability issues.

Frequently Asked Questions about performance-review

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

FAQPage Schema
How do I detect performance bottlenecks and N+1 queries in my code review?

To detect performance bottlenecks during code review, systematically audit source code for algorithmic inefficiencies, N+1 queries, and blocking I/O operations that cause system degradation at scale.

What are common performance anti-patterns causing latency in high-traffic services?

Common performance anti-patterns causing latency include unbounded memory usage leading to OOM errors, event-loop stalls, database inefficiencies lacking proper indexes, and algorithmic complexity issues.

How do I evaluate concurrency bounds and blocking I/O operations for production stability?

Evaluate concurrency bounds and blocking I/O operations by systematically assessing growth variables, query shapes, and event-loop stalls to ensure production stability in resource-constrained environments.

Can I use this performance review process for resource-constrained environments and async code?

Yes, this performance review process is explicitly designed for async code in resource-constrained environments and high-traffic services, evaluating event-loop stalls and concurrency bounds.

How do I distinguish critical performance blockers from minor suggestions during a pull request review?

Distinguish critical performance blockers from minor suggestions using a structured severity rubric that calibrates findings based on the blast radius and call frequency of the identified bottleneck.

What is the best way to identify unbounded memory allocation and scalability issues?

The best way to identify unbounded memory allocation and scalability issues is running a systematic performance hunt protocol on the current diff to detect loops lacking memory bounds and algorithmic complexity.