Performance reviewer

Skill ComeOnOliver/skillshub/skills/TerminalSkills/skills/performance-reviewer

🧠 The right skill, one API call. AI agent skills registry with token-efficient skill resolution. 5,000+ skills from 500+ top repos.From the repository description

Install

npx -y skills add ComeOnOliver/skillshub --skill performance-reviewer

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

SKILL.md

4.8 KB, ~1.1k tokens by cl100k_base, as published. Nobody here has run it

Performance Reviewer

Overview

This skill analyzes code changes for performance regressions and optimization opportunities. It catches common issues like N+1 database queries, unnecessary re-renders in React components, missing database indexes, unoptimized loops, and bundle size increases before they reach production.

Instructions

Analyzing a Diff or PR

Get the diff: git diff main...HEAD or git diff <base>...<head>
For each changed file, evaluate against these performance categories:

Database & Queries:

Look for queries inside loops (N+1 pattern)
Check for missing WHERE clauses or full table scans
Identify missing indexes on columns used in WHERE, JOIN, or ORDER BY
Flag SELECT * when only specific columns are needed
Watch for unbounded queries without LIMIT

Frontend & Rendering:

React: Check for missing useMemo/useCallback on expensive computations passed as props
Look for state updates that trigger unnecessary re-renders of large component trees
Flag inline object/array creation in render (creates new reference every render)
Check for large bundle imports (import moment → suggest dayjs)

Algorithm & Data Structures:

Flag O(n²) or worse algorithms when O(n log n) alternatives exist
Look for repeated array searches that should use a Set or Map
Identify string concatenation in loops (suggest StringBuilder/join)

Memory & Resources:

Check for missing cleanup in useEffect (event listeners, intervals, subscriptions)
Look for growing arrays/objects that are never trimmed
Flag missing connection pool limits or unclosed file handles

Network & I/O:

Identify sequential API calls that could be parallelized (Promise.all)
Check for missing pagination on list endpoints
Flag missing caching for expensive or repeated operations

Output Format

For each issue found, report:

File and line number
Category (Database, Frontend, Algorithm, Memory, Network)
Severity (Critical, Warning, Info)
What's wrong (specific description)
Suggested fix (concrete code suggestion)

Severity Guidelines

Critical: Will cause visible degradation in production (N+1 in a loop, O(n²) on large datasets, memory leak)
Warning: May cause issues at scale (missing index, unnecessary re-renders, sequential API calls)
Info: Optimization opportunity, not urgent (bundle size suggestion, minor refactor)

Examples

Example 1: N+1 Query Detection

Input diff:

# api/views.py
def list_orders(request):
    orders = Order.objects.filter(user=request.user)
    result = []
    for order in orders:
        items = OrderItem.objects.filter(order=order)  # ← query per order
        result.append({
            "id": order.id,
            "total": order.total,
            "items": [{"name": i.product.name, "qty": i.quantity} for i in items]
        })
    return JsonResponse(result, safe=False)

Output:

🔴 Critical — Database N+1 Query
  File: api/views.py:5-8
  Issue: OrderItem query executes once per order, plus each i.product.name
         triggers another query. For 50 orders with 3 items each = 201 queries.
  Fix: Use select_related and prefetch_related:
    orders = Order.objects.filter(user=request.user).prefetch_related(
        Prefetch('items', queryset=OrderItem.objects.select_related('product'))
    )
  Result: Reduces to 3 queries regardless of order count.

Example 2: React Re-render Issue