Performance

Performance Skill — Optimization & Profiling

This skill provides systematic performance analysis and optimization guidance.

Performance Budget Template

Profiling Methodology

1. Measure First

Copy code
NEVER optimize without measuring first.
ALWAYS establish a baseline before changes.
ALWAYS compare after optimization with real numbers.

2. Identify Bottleneck

3. Optimize by Category

Algorithmic

• Replace O(n²) with O(n log n) or O(n)
• Use appropriate data structures (Set for lookups, Map for key-value)
• Cache repeated computations (memoization)
• Lazy evaluation for expensive operations

I/O

• Batch database queries
• Use connection pooling
• Implement pagination
• Compress responses (gzip/brotli)
• Use CDN for static assets

Memory

• Stream large data instead of buffering
• Release references when done
• Use object pooling for frequent allocations
• Avoid closure capture of large objects

Concurrency

• Use async/await for I/O-bound work
• Worker threads for CPU-bound work
• Connection pooling for database/HTTP
• Backpressure handling for streams

Optimization Patterns

Caching Strategy

Copy code
Layer 1: In-memory (LRU, TTL: seconds)
Layer 2: Redis/Memcached (TTL: minutes)
Layer 3: Database (materialized views)
Layer 4: CDN (static assets, TTL: hours)

Database Optimization

1. Index Strategy: Index all WHERE/JOIN columns
2. Query Optimization: Avoid SELECT *, use projections
3. Connection Pooling: Reuse connections
4. Pagination: Cursor-based for large datasets
5. Denormalization: For read-heavy workloads

Performance Testing

typescriptCopy code
describe('Performance', () => {
  it('should process 10k records in under 100ms', async () => {
    const data = generateTestData(10_000);
    const start = performance.now();
    const result = processRecords(data);
    const elapsed = performance.now() - start;
    expect(elapsed).toBeLessThan(100);
    expect(result).toHaveLength(10_000);
  });
});

Anti-Patterns to Avoid

• Premature optimization without profiling data
• Caching everything (cache invalidation is hard)
• Denormalizing too early
• Micro-optimizing cold paths
• Ignoring GC pressure from excessive allocations

When NOT to Use

Do NOT use this skill when:

• Writing application business logic (use domain-driven skill)
• Designing database schemas (use database-design skill)
• Writing API endpoint implementations (use api-design skill)
• Writing SQL queries (use sql-best-practices skill)
• Designing multi-page website layouts (use design-system skill)
• Reviewing git workflows (use git-workflow skill)
• Analyzing deployment configurations (use deployment skill)