perf-review

Detect performance regressions in code diffs for database and async issues.

Updated Mar 2, 2026
One-click install
npx skills add https://github.com/supermalang/ai-augmented-coding --skill perf-review-supermalang
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: perf-review
Source: https://github.com/supermalang/ai-augmented-coding/tree/main/.claude/skills/perf-review
Command: npx skills add https://github.com/supermalang/ai-augmented-coding --skill perf-review-supermalang

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill catches performance regressions in code changes before they reach users, helping you spot expensive database access patterns and inefficient async flow early.

Core Features & Use Cases

  • N+1 and query efficiency checks: Finds loops that trigger repeated database calls and recommends eager loading or join-based fixes.
  • Pagination and over-fetching review: Flags unbounded list queries, missing ordering, and oversized selects that waste memory and bandwidth.
  • Schema and concurrency awareness: Checks whether filtered columns need indexes and whether independent async work should run in parallel.
  • Practical use case: Use it when reviewing API routes, server components, or data-access changes so you can ship faster code with clear severity, fix, and handoff guidance.

Quick Start

Ask the skill to review the active task's code changes for performance issues and return prioritized findings with concrete fixes.

Frequently Asked Questions about perf-review

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

FAQPage Schema
How do I detect N+1 queries and unbounded database reads in my code diffs?

To detect N+1 queries and unbounded database reads, review your code diffs for loops triggering repeated database calls and missing pagination limits. This process identifies inefficient data access patterns and recommends eager loading or join-based fixes to prevent performance regressions.

How do I review API routes for over-fetching and missing schema indexes?

Reviewing API routes for over-fetching and missing schema indexes involves inspecting diffs for oversized selects and unfiltered columns. This technique flags unbounded list queries and checks whether filtered columns require database indexes to optimize query performance.

What is the best way to catch sequential async work in server components before shipping?

The best way to catch sequential async work in server components is to audit independent async tasks during task-level code reviews. This approach identifies sequential execution bottlenecks and recommends running independent async operations in parallel for faster response times.

Does this performance audit work on data access layers and hot paths without external dependencies?

Yes, this performance audit works on data access layers and hot paths without external dependencies. It requires only diff inspection and schema awareness to apply severity scoring and actionable fix guidance directly to API routes and server components.

When should I not use an automated performance regression check for code changes?

You should not use an automated performance regression check when you lack schema awareness or diff context for the target code changes. The review mechanism requires inspecting actual diffs and schema structures to accurately score severity and generate actionable fix guidance.

How do I get prioritized findings with concrete fixes for performance regressions?

To get prioritized findings with concrete fixes for performance regressions, request a review of the active task's code changes. The review applies severity scoring to identified issues like missing indexes and over-fetching, returning clear handoff recommendations.