performance-review_skill

Overview

This skill performs performance-focused code reviews to identify runtime bottlenecks, inefficient patterns, and optimization opportunities across backend and frontend code. It surfaces issues in database queries, memory usage, rendering, network behavior, and algorithmic complexity, and classifies findings by severity. The goal is actionable recommendations that reduce latency, memory footprint, and CPU waste while improving scalability.

How this skill works

The review inspects code for common anti-patterns such as N+1 queries, unbounded memory growth, unnecessary re-renders, and high-complexity algorithms. It highlights missing safeguards like indexing, pagination, caching, connection pooling, and request deduplication. Each finding includes a severity level and concrete remediation steps (e.g., add indexes, introduce memoization, batch queries, or virtualize long lists).

When to use it

• Before a major release to catch regressions that impact performance
• When load testing reveals latency or memory spikes
• During architecture or design reviews for new features handling large data
• When build sizes or render times grow unexpectedly
• As part of post-incident analysis for production performance incidents

Best practices

• Prioritize fixes by severity and measurable impact (start with critical and high items)
• Add benchmarks or load tests to verify improvements and avoid regressions
• Introduce limits: pagination, connection pools, timeouts, and bounded caches
• Avoid premature optimization; focus on hotspots and reproducible bottlenecks
• Document changes and add monitoring (metrics/tracing) to validate real-world behavior

Example use cases

• Detecting and replacing N+1 database patterns with batched joins or eager loading
• Identifying unbounded in-memory caches and switching to size-limited LRU caches
• Replacing costly synchronous computations in render paths with web workers or memoization
• Adding pagination and caching for endpoints that previously returned huge payloads
• Refactoring O(n²) algorithms to linear or n log n implementations for large datasets