code-optimizer

Coordinate 13 specialist agents to detect performance anti-patterns in codebases.

Updated May 25, 2026
One-click install
npx skills add https://github.com/cmetech/otto-cli --skill code-optimizer-cmetech
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: code-optimizer
Source: https://github.com/cmetech/otto-cli/tree/main/src/resources/skills/code-optimizer
Command: npx skills add https://github.com/cmetech/otto-cli --skill code-optimizer-cmetech

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Detects and mitigates code performance bottlenecks by orchestrating a 13-agent workflow that patterns scans before reading full sources, enabling fast, scalable performance improvement.

Core Features & Use Cases

  • Parallel 13-specialist agent workflow that hunts for a broad range of performance anti-patterns using pattern-based detection.
  • Reference-driven analysis: loads detection patterns from references/ to avoid anchoring to existing implementations and provide diverse mitigations.
  • Actionable outcomes: returns concrete optimization recommendations, including potential impact and follow-up steps.

Quick Start

Provide the project root path and run the code-optimizer skill to start the parallel optimization audit.

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 bottlenecks?

To audit your codebase for performance bottlenecks, provide your project root path to initiate a parallel multi-agent scan. The workflow identifies anti-patterns across databases, memory, CPU, I/O, and concurrency using pattern-based detection.

What is the best way to detect performance anti-patterns across multiple programming languages?

Detecting performance anti-patterns across multiple languages is handled by a coordinated 13-specialist agent workflow. It applies reference-driven pattern scanning across diverse project types to identify bottlenecks without anchoring to existing implementations.

How does pattern-based code optimization scanning work?

Pattern-based code optimization scanning works by loading detection patterns from reference files and using Grep and Glob to hunt for issues. This approach scans for bottlenecks before reading full source code, enabling fast and scalable analysis.

Can I use this multi-agent optimization audit for any project type?

Yes, you can use this multi-agent optimization audit for any project type because it applies across diverse languages. It requires no external dependencies and only needs your project root path to start the parallel agent workflow.

What results should I expect from a code performance audit?

From a code performance audit, you should expect concrete optimization recommendations with estimated impact levels. The coordinated agents report identified bottlenecks alongside actionable mitigations and suggested follow-up steps.

Why is my code running slow and how do I find the specific bottleneck?

If your code is running slow, finding the specific bottleneck is achieved by scanning for performance anti-patterns in databases, memory, CPU, I/O, and concurrency. The 13-agent workflow pinpoints these issues using targeted grep patterns.