code-optimizer

Detect performance anti-patterns across codebases using parallel specialist agents.

7.8k|770|Updated Mar 11, 2026
One-click install
npx skills add https://github.com/gsd-build/gsd-2 --skill code-optimizer-gsd-build
Or copy as Structured Prompt for Agentā–¼
Please help me install this Agent Skill.
Skill: code-optimizer
Source: https://github.com/gsd-build/gsd-2/tree/main/src/resources/skills/code-optimizer
Command: npx skills add https://github.com/gsd-build/gsd-2 --skill code-optimizer-gsd-build

SYSTEM DOCUMENTATION & REQUIREMENTS

šŸ’” This Skill includes references (resource) components.

What problem does it solve?

Quickly identify performance anti-patterns and inefficiencies across large codebases by coordinating parallel specialist agents that analyze patterns rather than reading code upfront, reducing anchoring bias and speeding up optimization.

Core Features & Use Cases

  • Parallel agent audit: Spawns 13 specialized agents, each scanning for a different class of performance problems using pattern-based detection (Grep/Glob).
  • No prior code reading bias: Agents analyze references first, then inspect surrounding context to confirm findings.
  • End-to-end optimization workflow: Generates actionable insights for bottlenecks such as N+1 queries, memory leaks, excessive allocations, I/O bottlenecks, and concurrency issues.

Quick Start

Run code-optimizer to start a parallel multi-agent audit that identifies performance anti-patterns across your project.

Frequently Asked Questions about code-optimizer

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

FAQPage Schema
How do I audit my codebase for performance anti-patterns without reading every source file?ā–¼

You can audit codebases for performance anti-patterns by spawning 13 parallel specialist agents that use pattern-based detection via Grep and Glob, analyzing references first to identify inefficiencies without reading source files upfront, reducing anchoring bias and speeding up optimization.

What types of performance bottlenecks can be detected using parallel code optimization agents?ā–¼

Parallel code optimization agents detect N+1 queries, memory leaks, unnecessary allocations, blocking I/O, concurrency issues, and large bundle sizes across multi-language codebases, reporting findings with severity, file location, explanation, fix, and estimated impact.

How does pattern-based code review compare to traditional manual code audits?ā–¼

Pattern-based code review uses parallel specialist agents that load detection patterns from references and scan using Grep and Glob, avoiding the upfront code reading bias of manual audits and delivering faster, targeted optimization insights across large repositories.

Can I use parallel agents to find memory leaks and concurrency issues in multi-language repositories?ā–¼

Yes, parallel specialist agents apply to multi-language codebases across repositories, scanning for memory leaks, concurrency issues, and other performance problems using pattern-based detection before inspecting surrounding context to confirm findings.

What is the best way to identify N+1 queries and excessive allocations across a large codebase?ā–¼

The best way to identify N+1 queries and excessive allocations is running a parallel multi-agent audit that spawns 13 specialized agents to scan for different performance problem classes using pattern-based detection, generating actionable reports with estimated impact.

How do I generate actionable optimization reports with severity and fix recommendations?ā–¼

You generate actionable optimization reports by running parallel specialist agents that detect performance anti-patterns and report findings with file, pattern, severity, current snippet, explanation, fix, and estimated impact for each identified inefficiency.