code-optimizer

Code Optimizer

Improve code performance, memory usage, and efficiency through systematic optimization.

Core Capabilities

This skill helps optimize code by:

1. Analyzing performance bottlenecks - Identifying slow or inefficient code
2. Suggesting optimizations - Providing concrete improvements with examples
3. Explaining trade-offs - Describing benefits and potential drawbacks
4. Measuring impact - Estimating performance gains
5. Preserving correctness - Ensuring optimizations don't change behavior

Optimization Workflow

Step 1: Identify Optimization Opportunities

Analyze code to find performance bottlenecks.

Look for:

• Nested loops (O(n²) or worse complexity)
• Repeated expensive operations
• Inefficient data structures
• Unnecessary object creation
• Database N+1 queries
• Blocking I/O operations
• Memory leaks or excessive allocation

Quick Analysis Questions:

• What is the time complexity? Can it be reduced?
• Are there repeated calculations that could be cached?
• Is the right data structure being used?
• Are there unnecessary copies or allocations?
• Can operations be batched or parallelized?

Step 2: Categorize the Optimization

Determine the type of optimization needed.

Execution Speed:

• Algorithm optimization (better complexity)
• Loop optimization
• Caching/memoization
• Lazy evaluation
• Parallel processing

Memory Usage:

• Reduce object creation
• Use generators/streams instead of lists
• Clear references to enable garbage collection
• Use appropriate data structures
• Avoid memory leaks

Database Operations:

• Query optimization (indexes, joins)
• Batch operations
• Connection pooling
• Caching
• Reduce round trips

I/O Operations:

• Buffering
• Async/non-blocking I/O
• Batch requests
• Compression
• Caching

Step 3: Propose Optimization with Examples

Provide before/after code with clear explanations.

Optimization Template:

## Optimization: [Brief Description]

### Before (Inefficient)
```[language]
[original code]

Issues:

• Issue 1: [Problem description]
• Issue 2: [Problem description]

Complexity: O([complexity]) Performance: [estimated time/memory]

After (Optimized)

[optimized code]

Improvements:

• Improvement 1: [What changed]
• Improvement 2: [What changed]

Complexity: O([new complexity]) Performance: [estimated time/memory] Gain: [X% faster / Y% less memory]

Why This Works

[Detailed explanation of the optimization]

Trade-offs

Pros:

• [Benefit 1]
• [Benefit 2]

Cons:

• [Drawback 1, if any]
• [Drawback 2, if any]

When to Use

• Use when: [scenario]
• Avoid when: [scenario]