optimizing-performance

name	Optimizing Performance
description	Optimize performance with profiling, caching strategies, database query optimization, and bottleneck analysis. Use when improving response times, implementing caching layers, or scaling for high load.

Optimizing Performance

I help you identify and fix performance bottlenecks using language-specific profiling tools, optimization patterns, and best practices.

When to Use Me

Performance analysis:

• "Profile this code for bottlenecks"
• "Analyze performance issues"
• "Why is this slow?"

Optimization:

• "Optimize database queries"
• "Improve response time"
• "Reduce memory usage"

Scaling:

• "Implement caching strategy"
• "Optimize for high load"
• "Scale this service"

How I Work - Progressive Loading

I load only the performance guidance relevant to your language:

Language Detection:
  "Python project" → Load @languages/PYTHON.md
  "Rust project" → Load @languages/RUST.md
  "JavaScript/Node.js" → Load @languages/JAVASCRIPT.md
  "Go project" → Load @languages/GO.md
  "Any language" → Load @languages/GENERIC.md

Don't load all files! Start with language detection, then load specific guidance.

Core Principles

1. Measure First

Never optimize without data. Profile to find actual bottlenecks, don't guess.

• Establish baseline metrics
• Profile to identify hot paths
• Focus on the 20% of code that takes 80% of time
• Measure improvements after optimization

2. Performance Budgets

Set clear targets before optimizing:

targets:
  api_response: "<200ms (p95)"
  page_load: "<2 seconds"
  database_query: "<50ms (p95)"
  cache_lookup: "<10ms"

3. Trade-offs

Balance performance vs:

• Code readability
• Maintainability
• Development time
• Memory usage

Premature optimization is the root of all evil. Optimize when:

• Profiling shows clear bottleneck
• Performance requirement not met
• User experience degraded

Quick Wins (Language-Agnostic)

Database

• Add indexes for frequently queried columns
• Implement connection pooling
• Use batch operations instead of loops
• Cache expensive query results

Caching

• Implement multi-level caching (L1: in-memory, L2: Redis, L3: database, L4: CDN)
• Define cache invalidation strategy
• Monitor cache hit rates

Network

• Enable compression for responses
• Use HTTP/2 or HTTP/3
• Implement CDN for static assets
• Configure appropriate timeouts

Language-Specific Guidance

Python

Load: @languages/PYTHON.md

Quick reference:

• Profiling: cProfile, py-spy, memory_profiler
• Patterns: Generators, async/await, list comprehensions
• Anti-patterns: String concatenation in loops, GIL contention
• Tools: pytest-benchmark, locust

Rust

Load: @languages/RUST.md

Quick reference:

• Profiling: cargo bench, flamegraph, perf
• Patterns: Zero-cost abstractions, iterator chains, preallocated collections
• Anti-patterns: Unnecessary allocations, large enum variants
• Tools: criterion, rayon, parking_lot

JavaScript/Node.js

Load: @languages/JAVASCRIPT.md

Quick reference:

• Profiling: clinic.js, 0x, Chrome DevTools
• Patterns: Event loop optimization, worker threads, streaming
• Anti-patterns: Blocking event loop, memory leaks, unnecessary re-renders
• Tools: autocannon, react-window, p-limit

Go

Load: @languages/GO.md

Quick reference:

• Profiling: pprof, go test -bench, go tool trace
• Patterns: Goroutine pools, buffered channels, sync.Pool
• Anti-patterns: Unlimited goroutines, defer in loops, lock contention
• Tools: benchstat, sync.Map, strings.Builder

Generic Patterns

Load: @languages/GENERIC.md

When to use: Database optimization, caching strategies, load balancing, monitoring - applicable to any language.

Optimization Workflow

Phase 1: Baseline

1. Define performance requirements
2. Measure current performance
3. Identify user-facing metrics (response time, throughput)

Phase 2: Profile

1. Use language-specific profiling tools
2. Identify hot paths (where time is spent)
3. Find memory bottlenecks
4. Check for resource leaks

Phase 3: Optimize

1. Focus on biggest bottleneck first
2. Apply language-specific optimizations
3. Implement caching where appropriate
4. Optimize database queries

Phase 4: Verify

1. Re-profile to measure improvements
2. Run performance regression tests
3. Monitor in production
4. Set up alerts for degradation

Common Bottlenecks

Database

• Missing indexes
• N+1 query problem
• No connection pooling
• Expensive joins → Load @languages/GENERIC.md for DB optimization

Memory

• Memory leaks
• Excessive allocations
• Large object graphs
• No pooling → Load language-specific file for memory management

Network

• No compression
• Chatty API calls
• Synchronous external calls
• No CDN → Load @languages/GENERIC.md for network optimization

Concurrency

• Lock contention
• Excessive threading/goroutines
• Blocking operations
• Poor work distribution → Load language-specific file for concurrency patterns

Success Criteria

Optimization complete when:

• ✅ Performance targets met
• ✅ No regressions in functionality
• ✅ Code remains maintainable
• ✅ Improvements verified with profiling
• ✅ Production metrics show improvement
• ✅ Alerts configured for degradation

Next Steps

• Use profiling tools to identify bottlenecks
• Load language-specific guidance
• Apply targeted optimizations
• Set up monitoring and alerts

---

Load language-specific files for detailed profiling tools, optimization patterns, and best practices