skills.rest
jeickmeier
jeickmeierCOMMUNITY
Explore all skills by this author →
GitHub

performance-reviewer

Review code for algorithmic complexity, memory allocation, and concurrency issues.

1|Updated Jul 2, 2025
Search Tags:#code review#performance#optimization#benchmarking#profiling#rust
One-click install
npx skills add https://github.com/jeickmeier/rfin --skill performance-reviewer-jeickmeier
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: performance-reviewer
Source: https://github.com/jeickmeier/rfin/tree/main/.cursor/skills/performance-reviewer
Command: npx skills add https://github.com/jeickmeier/rfin --skill performance-reviewer-jeickmeier

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

This Skill helps identify and fix performance bottlenecks in code, ensuring applications run faster, use fewer resources, and scale effectively.

Core Features & Use Cases

  • Algorithmic Analysis: Detects inefficient algorithms and suggests optimal alternatives.
  • Memory Optimization: Flags unnecessary allocations and memory leaks.
  • Concurrency Review: Identifies opportunities for parallelization and potential deadlocks.
  • Use Case: When reviewing a critical API endpoint that is experiencing high latency, this Skill can pinpoint the exact lines of code causing the slowdown and provide actionable recommendations for improvement.

Quick Start

Review the provided Rust code snippet for performance issues.

Frequently Asked Questions about performance-reviewer

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

FAQPage Schema
How do I identify performance bottlenecks and high latency in my code?▼

Performance review detects inefficient algorithms and flags unnecessary memory allocations. It prioritizes simple, high-impact optimizations over micro-optimizations, ensuring applications run faster, use fewer resources, and scale effectively without complex refactoring.

What's the best way to optimize Rust code for speed and memory efficiency?▼

Concurrency review identifies opportunities for parallelization and potential deadlocks. It suggests optimal algorithmic alternatives and flags unnecessary allocations to enhance numerical computation and cache efficiency.

Does this performance review approach focus on micro-optimizations or high-impact code changes?▼

This performance review approach explicitly prioritizes simple, high-impact optimizations over micro-optimizations. It targets inefficient algorithms, memory leaks, and concurrency issues to deliver significant speed and resource usage improvements.

When do I need to review code for concurrency and parallelization opportunities?▼

You need to review code for concurrency when optimizing hot paths or addressing throughput and latency in performance-sensitive applications. It identifies parallelization opportunities and potential deadlocks to maximize execution speed.

Why does my critical API endpoint experience high latency despite correct logic?▼

High latency in a critical API endpoint often stems from inefficient algorithms, unnecessary memory allocations, or poor cache efficiency. A performance review pinpoints the exact lines causing the slowdown and recommends improvements.

Related Skills

Explore More Software Engineering Skills→
pproencapproenca
193

rust-optimise

Optimize Rust application performance across memory allocation, ownership, and concurrency.

Community
Intermediate
dj-boltdj-bolt
1.6k

performance-optimization

Optimize Python and Rust code through profiling and algorithmic improvements.

Official
Advanced
CallMeLuigiv2CallMeLuigiv2

m10-performance

Profile Rust code with cargo bench and flamegraph to identify and optimize performance bottlenecks.

Community
Advanced
awinogradovawinogradov
5

pr:monitor

Monitor pull requests for review approval and CI check status.

Community
Intermediate