Performance Analysis

---
model_tier: high
name: performance-analysis
description: "Performance audit — bottleneck profiling, N+1 query detection, hot-path analysis; explicit request only, not part of regular feature work."
personas:
  - performance-engineer
domain: discovery
workspaces:
  - engineering
packs:
  - engineering-base
---

# performance-analysis

## Mission

Find performance bottlenecks before they affect users. This skill is **proactive** — it
analyzes code for performance issues, not just responds to "it's slow" reports.

For writing performant code patterns (caching, eager loading, Redis), use the `performance` skill.
For test suite performance, use `test-performance`.

## When to use

Use this skill when:

- Auditing a codebase or flow for performance bottlenecks
- `analysis-autonomous-mode` routes here after detecting slow patterns
- Reviewing code that handles large datasets, loops, or external calls
- Investigating why a specific endpoint or job is slow

Do NOT use when:

- Writing new caching/optimization code → use `performance`
- Optimizing test suite speed → use `test-performance`
- Hunting for functional bugs → use `bug-analyzer` (proactive mode)

## Procedure: Performance analysis

### 1. Identify hotspots

Focus on code paths with high execution frequency or large data volumes:

- API endpoints called frequently (list endpoints, dashboards)
- Queue jobs processing batches
- Scheduled commands running on large datasets
- Import/export operations
- Report generation

### 2. Database query analysis

| Pattern | What to look for |
|---|---|
| **N+1 queries** | `->load()` or relationship access in loops, missing `->with()` |
| **Missing indexes** | `WHERE` clauses on unindexed columns, slow `ORDER BY` |
| **Full table scans** | `SELECT *` without `WHERE`, `LIKE '%term%'` |
| **Unnecessary queries** | Same query executed multiple times in one request |
| **Large result sets** | Loading thousands of models when only counts or IDs are needed |
| **Missing pagination** | `->get()` on unbounded queries |
| **Suboptimal joins** | Multiple queries that should be a single JOIN |
| **Transaction scope** | Transactions holding locks longer than necessary |

### 3. Application-level bottlenecks

| Pattern | What to look for |
|---|---|
| **Synchronous I/O** | HTTP calls, file operations, or API calls in the request cycle |
| **Memory bloat** | Loading entire collections when chunking would work |
| **Redundant computation** | Same calculation repeated without caching |
| **Missing cache** | Data that rarely changes but is queried on every request |
| **Stale cache** | Cache that is never invalidated or has wrong TTL |
| **Serialization overhead** | Large models serialized to JSON unnecessarily |
| **Loop inefficiency** | O(n²) patterns with nested loops or repeated array searches |

### 4. Queue and job analysis

- Jobs that should be batched but run individually
- Missing `chunk()` for large dataset processing
- Retry storms from failing jobs without backoff
- Jobs that hold database connections too long
- Missing `WithoutOverlapping` for idempotency-critical jobs

### 5. Infrastructure-level checks

- Missing Redis for session/cache (using file/database driver)
- Missing CDN for static assets
- Missing response caching for read-heavy endpoints
- Database connection pooling and limits
- Queue worker concurrency vs database connection limits

## Output format

1. Emit one entry per bottleneck using the field list below; never collapse multiple bottlenecks into a single entry.
2. Severity, Effort, and Confidence are required for every entry and must use the bounded vocabulary (Low / Medium / High / Critical for severity).
3. Close with a *Recommended Fix Order* ranked by `Impact ÷ Effort` and capped at 5 items.

For each bottleneck:

- **Issue:** concise title
- **Location:** file, line, or endpoint
- **Severity:** Low / Medium / High / Critical
- **Impact:** estimated effect (e.g., "adds ~500ms per request", "causes N+1 on 100+ records")
- **Evidence:** code reference, query pattern, or measurement
- **Fix:** concrete optimization
- **Effort:** Low / Medium / High
- **Confidence:** Low / Medium / High

## Integration with other skills

- **analysis-autonomous-mode** — routes here when performance concerns are detected
- **performance** — complementary: performance is about writing fast code, this is about finding slow code
- **test-performance** — for test suite speed specifically
- **bug-analyzer** — some performance issues are actually bugs (N+1, infinite loops)
- **database** — for deep DB optimization guidance

## Gotcha

- Don't present raw numbers without context — "200ms" means nothing without knowing the baseline.
- The model tends to focus on code-level optimization when the bottleneck is a database query.
- Profiling in development differs from production — different data volumes, different query plans.

## Do NOT

- Do NOT micro-optimize code that runs infrequently or on small datasets
- Do NOT recommend caching without considering invalidation
- Do NOT assume bottlenecks — measure or trace the actual code path
- Do NOT confuse code style preferences with performance issues
- Do NOT recommend infrastructure changes when code fixes would suffice