suggest-performance-fix

Identify performance bottlenecks in codebases and propose concrete optimizations.

3|Updated Jan 1, 2026
One-click install
npx skills add https://github.com/kjgarza/marketplace-claude --skill suggest-performance-fix
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: suggest-performance-fix
Source: https://github.com/kjgarza/marketplace-claude/tree/main/plugins/senior-software-developer/skills/suggest-performance-fix
Command: npx skills add https://github.com/kjgarza/marketplace-claude --skill suggest-performance-fix

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps developers identify performance bottlenecks in codebases and generate targeted optimizations, reducing latency and resource usage.

Core Features & Use Cases

  • Hotspot identification: detects expensive operations, nested loops, inefficient queries, and memory-heavy paths.
  • Analytical guidance: provides Big-O estimates, anti-pattern detection, and concrete refactor suggestions.
  • Actionable fixes: offers code-level recommendations and measurable impact estimates for common bottlenecks (e.g., N+1 queries, algorithmic improvements, batching, caching).

Quick Start

Run the suggest-performance-fix skill on a target codebase to detect bottlenecks and receive concrete optimization recommendations.

Frequently Asked Questions about suggest-performance-fix

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

FAQPage Schema
How do I identify and fix N+1 queries in my backend code?

To fix N+1 queries in backend code, you analyze data-intensive workflows to detect nested fetches and propose batching or caching strategies. This replaces repeated database calls with bulk operations, reducing latency and measurable resource overhead.

What are common backend code optimization anti-patterns I should look for?

Common code optimization anti-patterns include N+1 queries, nested loops, and excessive memory allocations. Detecting these expensive operations allows you to refactor algorithmic paths and apply targeted optimizations to reduce latency and resource usage.

How can I refactor nested loops to improve performance?

Refactoring nested loops requires analyzing their Big-O complexity to identify algorithmic inefficiencies. Replacing heavy iterations with optimized data structures or batching strategies reduces excessive allocations and lowers execution time.

Does this approach work for data-intensive workflows and profiling tasks?

Yes, profiling data-intensive workflows detects expensive operations and memory-heavy execution paths. Applying analytical guidance and code-level recommendations to these bottlenecks yields measurable impact estimates and improved resource usage.

What is the best way to estimate the impact of code optimizations?

Estimating code optimization impact involves assessing Big-O complexity and detecting anti-patterns to project latency reductions. Concrete refactoring suggestions paired with batching or caching strategies provide measurable improvement estimates for backend services.

When should I avoid refactoring code for performance?

Avoid refactoring code for performance when profiling fails to identify measurable bottlenecks or algorithmic anti-patterns. Without clear complexity assessments or actionable fixes, premature optimizations may increase technical debt without reducing latency.