code-optimizer

Detects performance anti-patterns across codebases using parallel pattern-based specialist agents.

Updated Apr 28, 2026
One-click install
npx skills add https://github.com/GregM1991/skills --skill code-optimizer-gregm1991
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: code-optimizer
Source: https://github.com/GregM1991/skills/tree/main/skills/code-optimizer
Command: npx skills add https://github.com/GregM1991/skills --skill code-optimizer-gregm1991

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Finding performance bottlenecks in a codebase is slow and error-prone when done manually, and reading code first creates anchoring bias that hides better solutions. This Skill runs a deep performance-only audit that systematically hunts for anti-patterns across 13 domains without being misled by existing implementations. ## Core Features & Use Cases - Parallel Multi-Agent Audit: Spawns 13 specialist agents simultaneously, each covering a performance domain such as database queries, memory leaks, algorithmic complexity, concurrency, bundle size, caching, and rendering. - Pattern-Based Detection: Agents use Grep/Glob pattern matching guided by reference files instead of reading full source code, avoiding anchoring bias on existing implementations. - Prioritized Consolidated Report: Deduplicates findings, sorts by severity (CRITICAL to LOW), groups by file, and produces an executive summary plus an ordered improvement plan with estimated impact. - Use Case: Ask to "find performance issues in my app" and receive a report flagging an N+1 query in your ORM loop, sequential awaits that should be Promise.all, and a missing database index — each with a concrete fix and expected impact. ## Quick Start Run a performance optimization audit on this project and report all bottlenecks with prioritized fixes.

Frequently Asked Questions about code-optimizer

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

FAQPage Schema
How do I find performance bottlenecks in my codebase?▼

Run a pattern-based performance audit that scans for known anti-patterns like N+1 queries, sequential awaits, and missing memoization using Grep/Glob. This Skill spawns 13 parallel agents, each covering one performance domain, then consolidates findings by severity.

What performance issues can a code optimization audit detect?▼

The audit covers 13 domains: database queries, memory leaks, algorithmic complexity, concurrency, bundle size, dead code, I/O and network, rendering, data structures, error resilience, caching, build configuration, and security-related performance. Each finding includes severity, cause, and a recommended fix.

Does this performance audit work with Python, JavaScript, and other languages?▼

Yes. The audit first detects the tech stack via manifest files like package.json, requirements.txt, go.mod, or Cargo.toml, then agents apply only the patterns relevant to that stack. Optional agents activate for logging frameworks or Docker configs when detected.

How is a performance audit different from a general code review?▼

This audit targets only performance problems such as slow queries, blocking operations, and inefficient algorithms. It does not cover code quality, style, correctness, or general bug hunting — use a dedicated code-review skill for those concerns.

Why does the audit avoid reading source code before searching?▼

Reading code first causes anchoring bias, where reviewers accept the existing implementation as reasonable and miss better alternatives. Agents instead search for anti-patterns first, then read only 5-10 lines of context to confirm each finding.