Performance Profiler Skill

Performance Profiler

Identifies and suggests fixes for common performance bottlenecks in code.

When to Use

User reports performance issues or slow code
Optimization requests
Code review for performance
User mentions "slow", "bottleneck", "optimization", "memory leak"

Instructions

1. Identify Performance Anti-Patterns

N+1 Query Problems:

// Bad: N+1 queries
users.forEach(user => {
  const posts = db.query('SELECT * FROM posts WHERE user_id = ?', user.id);
});

// Good: Single query with JOIN
const usersWithPosts = db.query('SELECT * FROM users LEFT JOIN posts ON users.id = posts.user_id');

Inefficient Loops:

# Bad: O(n²) nested loops
for item in list1:
    for other in list2:
        if item.id == other.id:
            process(item, other)

# Good: O(n) with hash map
lookup = {other.id: other for other in list2}
for item in list1:
    if item.id in lookup:
        process(item, lookup[item.id])

Unnecessary Re-renders (React):

// Bad: Creates new object on every render
<Component style={{ margin: 10 }} />

// Good: Define outside or useMemo
const style = { margin: 10 };
<Component style={style} />

Memory Leaks:

Event listeners not cleaned up
Timers not cleared
Circular references
Large caches without limits

Blocking Operations:

Synchronous file I/O
Long-running calculations in UI thread
Missing pagination

2. Database Performance

Check for:

Missing indexes on foreign keys
SELECT * instead of specific columns
Queries in loops (N+1)
Missing query limits
Inefficient JOINs

Suggest:

Add indexes: CREATE INDEX idx_user_id ON posts(user_id);
Use eager loading/prefetching
Implement pagination
Use database query analyzers (EXPLAIN)

3. Algorithm Complexity

Identify:

O(n²) or worse algorithms
Redundant calculations
Unnecessary sorting
Inefficient data structures

Common fixes:

Hash maps for O(1) lookup vs O(n) array search
Binary search O(log n) vs linear search O(n)
Memoization for repeated calculations
Lazy evaluation for expensive operations

4. Frontend Performance

Check for:

Large bundle sizes
Unoptimized images
Missing code splitting
Inefficient React components
Missing memoization

Suggest:

Lazy loading: const Component = lazy(() => import('./Component'));
Image optimization
Debounce/throttle expensive operations
Virtual scrolling for long lists
Web Workers for heavy computations

5. Network Performance

Issues:

Too many HTTP requests
Large payloads
Missing caching
Synchronous requests

Solutions:

Bundle/concatenate resources
Implement compression (gzip, brotli)
Use HTTP/2 multiplexing
Add caching headers
Parallel vs sequential requests

6. Generate Performance Report

Performance Analysis
===================

Critical Issues (Fix Immediately):
1. N+1 query in UserController.index (file.js:45)
   - Impact: 100+ DB queries per request
   - Fix: Use eager loading or JOIN

2. Memory leak in EventEmitter (file.js:120)
   - Impact: Memory grows unbounded
   - Fix: Remove listeners in cleanup

High Priority:
3. O(n²) loop in processData (file.js:200)
   - Impact: Slow for large datasets
   - Fix: Use hash map for O(n)

Medium Priority:
4. Missing image optimization
   - Impact: Slow page load
   - Fix: Use next/image or optimize manually

7. Profiling Tools

JavaScript:

Chrome DevTools Performance tab
Node.js --inspect flag
console.time() / console.timeEnd()

Python:

cProfile module
line_profiler
memory_profiler

Database:

EXPLAIN / EXPLAIN ANALYZE
Slow query log
pg_stat_statements (PostgreSQL)

Best Practices

Profile before optimizing
Focus on hot paths (80/20 rule)
Measure impact of changes
Consider readability vs performance trade-offs
Document performance-critical sections

Agent Skills: Performance Profiler

Install this agent skill to your local

Skill Files