Code Performance Review

Analyze source code for performance bottlenecks and optimization opportunities.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/MS33834/AI-SKILL --skill code-performance-review
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Code Performance Review
Source: https://github.com/MS33834/AI-SKILL/tree/main/skills/code-performance-review
Command: npx skills add https://github.com/MS33834/AI-SKILL --skill code-performance-review

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you identify code paths that waste time, memory, or concurrency headroom so you can improve performance with confidence instead of guessing.

Core Features & Use Cases

  • Bottleneck Analysis: Detect algorithmic, I/O, memory, and concurrency issues in a code snippet or function.
  • Measured Optimization: Suggest practical changes with expected impact and a clear before-and-after measurement plan.
  • Hot Path Review: Use it for latency regressions, throughput issues, or scaling preparation where small inefficiencies matter.
  • Avoid Premature Optimization: It also explains when a change is not worth the complexity cost.

Quick Start

Ask the Skill to review the provided code for performance bottlenecks, explain the likely impact, and suggest measured optimizations.

Frequently Asked Questions about Code Performance Review

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

FAQPage Schema
How do I find performance bottlenecks in my source code?

To identify performance bottlenecks, analyze source code for algorithmic, I/O, memory, and concurrency issues. It targets hot-path functions and memory-intensive routines, recommending profiling methods and measured code changes for optimization.

What is the best way to optimize latency regressions in throughput-sensitive services?

Optimizing latency regressions involves reviewing hot-path functions where small inefficiencies matter. The process detects throughput bottlenecks and suggests practical changes with expected impact alongside a clear before-and-after measurement plan.

How does profiling help with memory-intensive routines?

Profiling memory-intensive routines identifies exact code paths wasting memory headroom. It detects memory issues and recommends measured optimizations, ensuring performance improvements are based on confidence rather than guessing.

When should I avoid premature optimization during code review?

Avoid premature optimization when a change is not worth the complexity cost. The review evaluates optimization opportunities and explicitly explains when skipping unnecessary complexity outweighs marginal performance gains.

Can I analyze concurrency issues in my code without setting up external dependencies?

Yes, you can analyze concurrency issues directly from the provided source code snippet or function. It identifies concurrency headroom waste without requiring external profiling dependencies or environment setup.