OpenParable
Skip to content
← Back to skills

Code Optimizer

Testing & Quality
code-optimizer

Code Optimizer is an Agent Skill for testing & quality published in the open-gsd/gsd-pi repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Deep code optimization audit using parallel specialist agents that hunt performance anti-patterns via pattern-based detection, avoiding anchoring bias. Covers DB queries, memory leaks, algorithmic complexity, concurrency, bundle size, dead code, I/O/network, rendering, caching, and build config. Use when asked to optimize code, find performance issues or bottlenecks, speed up an app, reduce latency, detect code smells, or run a performance/quality audit.

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/open-gsd/gsd-pi/blob/HEAD/src/resources/skills/code-optimizer/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/code-optimizer, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

Code Optimizer

Parallel multi-agent code optimization audit. Spawn 13 specialist agents simultaneously, each hunting for a different class of performance problem using pattern-based detection.

Critical Principle: No Code Reading Before Analysis

Agents MUST NOT read source files before searching for patterns. Reading the code first causes anchoring bias — the agent accepts the existing implementation as "reasonable" and misses better alternatives. Instead, each agent:

  1. Read its assigned reference file from references/ to load detection patterns
  2. Use Grep/Glob to scan the codebase for anti-patterns
  3. For each finding, ONLY THEN read the surrounding context (5-10 lines) to confirm the issue
  4. Propose the optimal solution based on best practices, NOT based on the existing code

Workflow

Step 1: Detect Stack

Use Glob to identify the project's tech stack:

  • **/package.json → Node.js/JS/TS (check for React, Next.js, Express, etc.)
  • **/requirements.txt, **/pyproject.toml, **/setup.py → Python
  • **/go.mod → Go
  • **/Cargo.toml → Rust
  • **/pom.xml, **/build.gradle → Java
  • **/Gemfile → Ruby
  • **/Dockerfile → Docker
  • **/*.sql → SQL
  • **/webpack.config.*, **/vite.config.*, **/tsconfig.json → Build tools

Step 2: Spawn 13 Parallel Agents

Launch ALL agents simultaneously using the Agent tool. Each agent receives:

  • Its domain name and reference file path
  • The detected tech stack (so it can focus on relevant patterns)
  • The project root path
  • Instructions to NOT read code files, only Grep/Glob for patterns

Agent definitions (spawn all 13 in a single message):

#Agent NameReference FileFocus
1Database & Queriesreferences/database-queries.mdN+1 queries, SELECT *, missing indexes, ORM misuse, connection pooling
2Memory & Resourcesreferences/memory-resources.mdMemory leaks, unclosed resources, large allocations, string concat in loops
3Algorithmic Complexityreferences/algorithmic-complexity.mdO(n^2) patterns, unnecessary iterations, wrong data structures for lookups
4Concurrency & Asyncreferences/concurrency-async.mdSequential awaits, blocking in async, race conditions, unbounded concurrency
5Bundle & Dependenciesreferences/bundle-dependencies.mdHeavy imports, unused deps, duplicate libs, missing lazy loading
6Dead Code & Redundancyreferences/dead-code-redundancy.mdUnused exports, commented code, dead branches, duplicate logic
7I/O & Networkreferences/io-network.mdSequential requests, missing batching, no dedup, missing compression
8Rendering & UIreferences/rendering-ui.mdRe-renders, missing virtualization, layout thrashing, animation perf
9Data Structuresreferences/data-structures.mdWrong structures, unnecessary copies, inefficient serialization
10Error & Resiliencereferences/error-resilience.mdMissing timeouts, swallowed errors, no retries, no circuit breakers
11Caching & Memoizationreferences/caching-memoization.mdMissing memoization, cache without invalidation, redundant API calls
12Build & Compilationreferences/build-compilation.mdDev code in prod, missing optimization flags, slow tests, Docker issues
13Security-Performancereferences/security-performance.mdCrypto misuse, missing rate limiting, ReDoS, SQL injection vectors

Optional agents (spawn if relevant to detected stack):

  • Logging & Observability (references/logging-observability.md) — if logging framework detected
  • Config & Infrastructure (references/config-infra.md) — if Docker/deployment config detected

Agent Prompt Template

Each agent MUST receive this prompt structure:

You are a {DOMAIN_NAME} optimization specialist. Your job is to find performance
anti-patterns in the codebase at {PROJECT_ROOT}.

CRITICAL RULES:
1. DO NOT read source code files before searching. This avoids anchoring bias.
2. First, read your reference file: {SKILL_DIR}/references/{REFERENCE_FILE}
3. Use Grep and Glob to search for the patterns described in the reference file.
4. Only read 5-10 lines of context around each finding to confirm it's a real issue.
5. Skip patterns that don't match the project's stack: {DETECTED_STACK}

Tech stack detected: {DETECTED_STACK}
Project root: {PROJECT_ROOT}

For each finding, report:
- **File**: path:line_number
- **Pattern**: what anti-pattern was detected
- **Severity**: CRITICAL / HIGH / MEDIUM / LOW
- **Current code**: the problematic snippet (keep short)
- **Why it's slow**: brief explanation of the performance impact
- **Optimal fix**: the recommended solution (code snippet or approach)
- **Estimated impact**: qualitative improvement expected (e.g., "10x faster for large lists")

If you find 0 issues in your domain, report "No issues found" — this is a valid outcome.
Sort findings by severity (CRITICAL first).

Step 3: Consolidate Report

After all agents complete, consolidate their findings into a single prioritized report:

  1. Collect all findings from all agents
  2. Deduplicate (different agents may flag the same code for different reasons)
  3. Sort by severity: CRITICAL > HIGH > MEDIUM > LOW
  4. Group by file (so the user can fix file-by-file)
  5. Present the final report with:
    • Executive summary: total findings by severity, top 3 most impactful
    • Detailed findings table grouped by file
    • Improvement plan: ordered list of fixes from highest to lowest impact

Report Format

# Code Optimization Audit Report

## Executive Summary
- **X** critical issues, **Y** high, **Z** medium, **W** low
- Top 3 highest-impact fixes:
  1. [brief description] — [estimated impact]
  2. [brief description] — [estimated impact]
  3. [brief description] — [estimated impact]

## Findings by File

### `path/to/file.ts`

| # | Severity | Domain | Pattern | Fix | Impact |
|---|----------|--------|---------|-----|--------|
| 1 | CRITICAL | Database | N+1 query in loop | Use prefetch_related | 50x fewer queries |
| 2 | HIGH | Async | Sequential awaits | Use Promise.all | 3x faster |

[... for each file with findings ...]

## Improvement Plan

Priority-ordered steps to implement the fixes:

1. **[CRITICAL] Fix N+1 queries in `api/users.py`**
   - Current: loop queries user.posts for each user
   - Fix: add prefetch_related('posts') to queryset
   - Impact: reduces N+1 to 2 queries

2. **[HIGH] Parallelize API calls in `services/sync.ts`**
   - Current: 5 sequential await fetch() calls
   - Fix: Promise.all([fetch1, fetch2, ...])
   - Impact: ~5x faster sync operation

[... continue for all findings ...]