codereview-performance

Name: codereview-performance
Availability: InStock
Author: xinbenlv

Analyze code for performance bottlenecks and concurrency hazards during reviews.

8|Updated Jan 14, 2026

Search Tags:#performance #concurrency #code-review #analyze #memory-leaks #algorithmic-complexity #N+1-queries

Ready to run

npx skills add https://github.com/xinbenlv/codereview-skills --skill codereview-performance

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: codereview-performance
Source: https://github.com/xinbenlv/codereview-skills/tree/main/skills/codereview-performance
Command: npx skills add https://github.com/xinbenlv/codereview-skills --skill codereview-performance

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps reviewers identify performance bottlenecks and inefficiencies in code, focusing on loops, database access, I/O, and concurrency issues to prevent runtime problems at scale.

Core Features & Use Cases

Algorithmic Efficiency: Detect nested loops and costly data transformations that lead to high time complexity.
Resource Management: Identify memory leaks, unbounded allocations, and improper cleanup in long-running processes.
Concurrency Safety: Spot race conditions, deadlocks, and unsafe shared state in parallel code.
Use Case: When reviewing a PR with heavy data processing or widespread DB access, guide optimizations and safer patterns.

Quick Start

Use codereview-performance to analyze the current code changes for performance bottlenecks and concurrency issues, and propose concrete optimizations.

Frequently Asked Questions about codereview-performance

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

FAQPage Schema

How do I find N+1 database queries and nested loops during a code review?▼

To find N+1 database queries and nested loops during a code review, analyze code changes for algorithmic complexity and inefficient database access patterns. This process detects costly data transformations and bottlenecks to prevent runtime problems at scale.

What causes memory leaks in long-running processes and how can I spot them?▼

Memory leaks in long-running processes are caused by unbounded allocations and improper resource cleanup. You can spot them by analyzing code for resource management issues, identifying unbounded allocations, and enforcing checks for proper cleanup.

How do I detect race conditions and deadlocks in parallel code?▼

To detect race conditions and deadlocks in parallel code, analyze concurrency hazards by checking for unsafe shared state and unsafe parallelism strategies. This enforces concurrency safety by spotting race conditions and deadlocks in highly concurrent components.

Does this performance analysis work across different programming languages?▼

Yes, performance analysis works across different programming languages. It applies to review scenarios involving loops, database access patterns, I/O-heavy operations, and highly concurrent components regardless of the specific programming language used.

What is the best way to review I/O-heavy operations for performance bottlenecks?▼

The best way to review I/O-heavy operations for performance bottlenecks is to analyze the code changes for inefficient access patterns and concurrency issues. This approach identifies I/O bottlenecks and proposes concrete optimizations and safer patterns.

When should I not rely on automated code review for performance issues?▼

You should not rely on automated code review for performance issues when dealing with highly subjective algorithmic optimizations or complex business logic requiring human intuition. It targets identifiable bottlenecks like nested loops, N+1 queries, and memory leaks.