code-optimizer

Detect and remediate performance anti-patterns across multi-language codebases.

1.0k|92|Updated May 22, 2026
One-click install
npx skills add https://github.com/open-gsd/gsd-pi --skill code-optimizer-open-gsd
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: code-optimizer
Source: https://github.com/open-gsd/gsd-pi/tree/main/src/resources/skills/code-optimizer
Command: npx skills add https://github.com/open-gsd/gsd-pi --skill code-optimizer-open-gsd

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Deep code optimization auditing by deploying parallel specialist agents to detect and remediate performance anti-patterns across codebases.

Core Features & Use Cases

  • Parallel agent orchestration: spawn multiple specialized detectors that operate on patterns across language ecosystems.
  • Pattern-based detection: identify common performance issues such as N+1 queries, memory leaks, and unnecessary allocations without reading code first.
  • Use Case: optimize a Node.js project by spotting and correcting costly anti-patterns in a distributed manner, reducing runtime latency.

Quick Start

Run the Code Optimizer on your repository to start a multi-agent audit that surfaces the top performance bottlenecks.

Frequently Asked Questions about code-optimizer

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

FAQPage Schema
How do I find code performance anti-patterns in a multi-language codebase?

Code performance anti-patterns are identified using a parallel-agent framework that scans multi-language codebases with non-invasive grep and glob operations. Specialized detectors target known inefficiencies like N+1 queries and memory leaks without reading the full code.

How does pattern-based static analysis detect memory leaks and N+1 queries?

Pattern-based static analysis detects memory leaks and N+1 queries by spawning multiple specialized detector agents that operate on predefined patterns across language ecosystems. It scans for these anti-patterns using grep and glob rather than reading the code directly.

What is the best way to audit code performance bottlenecks without invasive scanning?

Auditing code performance bottlenecks non-invasively requires a configurable reference set and grep/glob based scanning to avoid early code reading. This approach identifies costly anti-patterns across the repository and proposes optimized solutions.

Do I need a reference set to run a parallel code optimization audit?

A configurable reference set is required to run the parallel code optimization audit. The framework uses this reference set to spawn specialized detectors that identify and remediate performance inefficiencies across your codebase.

Can I use this to optimize a Node.js project by spotting unnecessary allocations?

You can optimize a Node.js project by spotting and correcting unnecessary allocations and other costly anti-patterns. The distributed multi-agent audit surfaces performance bottlenecks to reduce runtime latency.

What are the limitations of using grep and glob based scanning for code optimization?

Grep and glob based scanning for code optimization limits detection to predefined patterns rather than semantic data flow analysis. It targets common performance issues like N+1 queries and memory leaks but requires a configured reference set to operate effectively.