algorithm-review

Identify inefficient algorithms and data structures in code with Big-O analysis.

2|Updated Mar 16, 2026

Search Tags:#performance #algorithm #refactoring #optimization #code-review #data-structures #big-o

Ready to run

npx skills add https://github.com/chicongst/agent-skills-installer --skill algorithm-review

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: algorithm-review
Source: https://github.com/chicongst/agent-skills-installer/tree/main/skills/algorithm-review
Command: npx skills add https://github.com/chicongst/agent-skills-installer --skill algorithm-review

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Identifies and improves inefficient algorithms and data structures in code, boosting performance and scalability without over-optimizing.

Core Features & Use Cases

Analyze code to detect common performance antipatterns (e.g., O(n^2) loops, unnecessary duplications).
Propose targeted algorithmic and data-structure improvements with concrete before/after examples.
Provide guidance for readability and maintainability while preserving correctness across typical workloads.

Quick Start

Provide a code snippet and I will return concrete before/after optimization suggestions.

Frequently Asked Questions about algorithm-review

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

FAQPage Schema

How do I identify and fix O(n^2) loops in my code for better performance?▼

To fix O(n^2) loops and improve performance, this tool analyzes your code to detect common antipatterns like nested iterations and proposes targeted algorithmic improvements with concrete before/after examples. It justifies changes using Big-O analysis to ensure scalable solutions.

What is the best way to optimize inefficient data structures in software projects?▼

The best way to optimize inefficient data structures is by analyzing your code to spot bottlenecks and rewriting with smarter algorithms. This approach provides targeted improvements for sorting, searching, and graph-processing tasks while preserving readability and correctness.

Can I get before and after code examples when refactoring for algorithm optimization?▼

Yes, you can get before and after code examples when refactoring for algorithm optimization. By providing a code snippet, you receive concrete optimization suggestions that demonstrate targeted data-structure improvements and explain the underlying techniques applied.

Does code refactoring for scalability work without over-optimizing typical workloads?▼

Code refactoring for scalability works without over-optimizing by focusing on algorithmic and data-structure improvements that boost performance under typical workloads. It preserves correctness and provides guidance for maintainability while applying Big-O analysis to justify necessary changes.

When should I avoid algorithmic refactoring to improve code readability?▼

You should avoid algorithmic refactoring when changes compromise maintainability or introduce unnecessary complexity for typical workloads. This approach prioritizes readability and correctness, ensuring performance improvements do not lead to over-optimization or degrade the software's structural clarity.