Suggest Performance Fix

Identify performance issues and bottlenecks in code, suggesting specific optimizations.

Performance Issue Categories

1. Algorithmic Complexity

Nested Loops: O(n²) or worse time complexity
Inefficient Search: Linear search when hash lookup possible
Redundant Calculations: Computing same value multiple times
Inefficient Sorting: Using bubble sort instead of quicksort/mergesort
String Concatenation: Building strings in loops

2. Database Performance

N+1 Query Problem: Loading related data in a loop
Missing Indexes: Queries on unindexed columns
**SELECT ***: Fetching unnecessary columns
No Query Pagination: Loading all records at once
Missing Connection Pooling: Creating new connection per query
Lack of Prepared Statements: Re-parsing queries

3. Memory Issues

Memory Leaks: Objects not released/garbage collected
Excessive Allocations: Creating unnecessary objects
Large In-Memory Data: Loading entire datasets into RAM
Caching Issues: Not caching expensive operations
Deep Cloning: Expensive deep copies when shallow would work

4. I/O Performance

Synchronous I/O: Blocking operations in async context
No Batching: Multiple small I/O operations instead of batch
Missing Compression: Large payloads without compression
No Streaming: Loading entire files into memory
Excessive File I/O: Reading/writing files repeatedly

5. Frontend/API Performance

No Lazy Loading: Loading all data upfront
Missing CDN: Serving static assets from origin
Large Bundle Size: Shipping unnecessary code
Render Blocking: Blocking page render with scripts
Missing Caching Headers: Not utilizing browser cache
Excessive API Calls: Multiple calls when one would suffice

6. Concurrency Issues

Missing Parallelization: Sequential when parallel possible
Race Conditions: Unprotected shared state
Lock Contention: Too much synchronization
Thread Pool Exhaustion: Not limiting concurrent operations

Analysis Process

Identify hotspots - Find expensive operations
Measure complexity - Calculate time/space complexity
Check patterns - Match against known anti-patterns
Estimate impact - Predict performance gain from fix
Prioritize - Focus on high-impact optimizations
Generate fix - Suggest specific code improvements

Performance Analysis Techniques

Complexity analysis (Big O notation)
Pattern matching for known anti-patterns
Static analysis of queries and loops
Resource usage estimation
Comparison with best practices

Return Value

Return object:

{
  "file": "api/users.js",
  "issues": [
    {
      "type": "N+1 Query",
      "severity": "critical",
      "location": {
        "line": 45,
        "function": "getUsersWithPosts"
      },
      "description": "Loading posts for each user in a loop (N+1 query pattern)",
      "currentPerformance": {
        "timeComplexity": "O(n)",
        "queriesExecuted": "1 + n",
        "estimatedLatency": "50ms + (n × 20ms)"
      },
      "optimizedPerformance": {
        "timeComplexity": "O(1)",
        "queriesExecuted": "2",
        "estimatedLatency": "70ms (constant)"
      },
      "impact": "high",
      "effort": "small",
      "suggestedFix": {
        "approach": "Use JOIN or eager loading",
        "codeExample": "// Before...\n// After...",
        "estimatedSpeedup": "10-100x faster depending on n"
      }
    }
  ],
  "recommendations": [
    {
      "priority": 1,
      "title": "Fix N+1 query in getUsersWithPosts",
      "impact": "80% reduction in API response time",
      "effort": "30 minutes"
    }
  ]
}

Examples

Example 1: N+1 Query Detection

Context: User has API endpoint that loads users and their posts

Autonomous Invocation: Skill detects the pattern and reports:

Performance Issue Detected: N+1 Query Problem

Location: api/users.js, line 45

Current Code:
async function getUsersWithPosts() {
  const users = await db.query('SELECT * FROM users');
  
  for (const user of users) {
    user.posts = await db.query('SELECT * FROM posts WHERE user_id = ?', [user.id]);
  }
  
  return users;
}

Problem:
- Executes 1 query to get users
- Then executes n additional queries (one per user) to get posts
- With 100 users, this is 101 database queries!

Performance Impact:
- Current: ~50ms + (100 × 20ms) = 2,050ms (2 seconds!)
- Each additional user adds 20ms

Optimized Solution:
async function getUsersWithPosts() {
  const users = await db.query('SELECT * FROM users');
  const userIds = users.map(u => u.id);
  
  // Single query to get all posts
  const posts = await db.query(
    'SELECT * FROM posts WHERE user_id IN (?)',
    [userIds]
  );
  
  // Group posts by user_id in application code
  const postsByUser = posts.reduce((acc, post) => {
    if (!acc[post.user_id]) acc[post.user_id] = [];
    acc[post.user_id].push(post);
    return acc;
  }, {});
  
  users.forEach(user => {
    user.posts = postsByUser[user.id] || [];
  });
  
  return users;
}

Alternative (SQL JOIN):
const results = await db.query(`
  SELECT 
    u.*,
    p.id as post_id,
    p.title as post_title,
    p.content as post_content
  FROM users u
  LEFT JOIN posts p ON p.user_id = u.id
`);

// Then reshape results in application code

Performance Improvement:
- Optimized: ~70ms (constant, regardless of user count)
- 30x faster with 100 users
- 100x faster with 1000 users

Estimated effort: 30 minutes
Impact: Critical for scalability

Example 2: Inefficient Algorithm

Context: User has sorting implementation in code

Autonomous Invocation: Skill identifies algorithmic issue:

Performance Issue Detected: Inefficient Algorithm

Location: utils/sort.js, line 23

Current Code:
function sortUsers(users) {
  // Bubble sort implementation
  for (let i = 0; i < users.length; i++) {
    for (let j = 0; j < users.length - 1; j++) {
      if (users[j].name > users[j + 1].name) {
        [users[j], users[j + 1]] = [users[j + 1], users[j]];
      }
    }
  }
  return users;
}

Problem:
- Time Complexity: O(n²) - quadratic growth
- With 1,000 users: ~1,000,000 comparisons
- With 10,000 users: ~100,000,000 comparisons

Performance Impact:
- 100 users: ~5ms
- 1,000 users: ~450ms
- 10,000 users: ~45 seconds (!!!)

Optimized Solution:
function sortUsers(users) {
  return users.sort((a, b) => a.name.localeCompare(b.name));
}

Built-in Array.sort() uses optimized algorithm (typically Timsort):
- Time Complexity: O(n log n)
- With 10,000 users: ~130,000 comparisons (vs 100M)

Performance Improvement:
- 100 users: 5ms → <1ms
- 1,000 users: 450ms → 3ms (150x faster)
- 10,000 users: 45s → 40ms (1,125x faster!)

Additional Optimization (for very large datasets):
// If sorting is a frequent operation, consider:
1. Maintain sorted order during insertion
2. Use indexed database column and sort in DB
3. Cache sorted results

Estimated effort: 5 minutes
Impact: Critical at scale

Example 3: Missing Database Index

Context: User reports slow query performance

Autonomous Invocation: Skill analyzes query:

Performance Issue Detected: Missing Database Index

Location: repositories/user-repo.js, line 67

Current Code:
async function findUsersByStatus(status) {
  return await db.query(
    'SELECT * FROM users WHERE status = ?',
    [status]
  );
}

Problem:
- Query filters on 'status' column
- No index on 'status' column
- Database must scan entire table (table scan)

Performance Impact (with 100,000 users):
- Current: ~500ms (full table scan)
- After index: ~5ms (index lookup)
- 100x improvement!

Query Execution Plan (Current):
- Type: ALL (full table scan)
- Rows examined: 100,000
- Rows returned: ~5,000

Recommended Fix:
1. Add database index:
   CREATE INDEX idx_users_status ON users(status);

2. Verify index is being used:
   EXPLAIN SELECT * FROM users WHERE status = 'active';

Query Execution Plan (After Index):
- Type: ref (index lookup)
- Rows examined: ~5,000 (only matching rows)
- Rows returned: ~5,000

Additional Considerations:
- Index adds ~5MB storage (minimal cost)
- Slightly slower writes (updates must update index)
- Worth it for read-heavy columns

If multiple filters are common:
   CREATE INDEX idx_users_status_created 
   ON users(status, created_at);

This supports queries like:
   WHERE status = 'active' AND created_at > '2024-01-01'

Estimated effort: 5 minutes
Impact: Critical for query performance

Error Handling

If file type not recognized: Skip analysis or use generic patterns
If measurements missing: Provide theoretical analysis only
If context insufficient: Ask for more information about use case
If no issues found: Provide confirmation that code looks performant

Priority Matrix

Issues are prioritized by:

Critical: 10x+ improvement possible, high traffic code path
High: 5-10x improvement, medium traffic
Medium: 2-5x improvement or low traffic
Low: < 2x improvement, optimization edge cases

Integration with Workflow

Proactive: Catches issues before they reach production
Educational: Explains complexity and tradeoffs
Measurable: Provides concrete performance estimates
Actionable: Specific code examples for fixes
Prioritized: Focuses on high-impact optimizations

Related Skills

detect-code-smells: General code quality issues
security-pattern-check: Security-focused analysis

Notes

Following the senior developer principle: "Premature optimization is the root of all evil, but that doesn't mean ignore obvious issues." This skill focuses on clear performance anti-patterns, not micro-optimizations.

Performance optimization should be:

Measured (know the current performance)
Targeted (fix the actual bottleneck)
Verified (confirm the improvement)
Balanced (against code complexity)

suggest-performance-fix