yigityildiz0 Code Review - Performance Review
Identify performance bottlenecks, caching issues, and optimization opportunities. This skill is Phase 4 of the 6-phase code review methodology.
When to Use This Skill
Use this skill when you need to:
- Identify performance bottlenecks
- Optimize critical code paths
- Reduce resource consumption
- Improve response times
- Address scalability concerns
- Profile memory and CPU usage
- Evaluate caching strategies
Trigger phrases: "performance review", "bottleneck", "slow code", "optimize", "profiling", "latency", "throughput", "memory usage", "caching"
What This Skill Does
Performance Dimensions
| Dimension | Metrics |
|---|---|
| Time | Response time, latency, throughput |
| Memory | Heap usage, allocations, leaks |
| CPU | Utilization, hot paths |
| I/O | Database queries, network calls |
| Concurrency | Threading, async efficiency |
| Caching | Hit rate, TTL, invalidation |
Severity Classification
| Level | Alias | Description |
|---|---|---|
| P0 | CRITICAL | Production outages, severe degradation |
| P1 | HIGH | Significant performance impact |
| P2 | MEDIUM | Notable inefficiency |
| P3 | LOW | Minor optimization opportunity |
Instructions
Step 1: Profile Application
# Python
python -m cProfile -s cumtime script.py
py-spy record -o profile.svg -- python script.py
# JavaScript/Node.js
node --prof app.js
clinic doctor -- node app.js
# Java
java -XX:+FlightRecorder -XX:StartFlightRecording=duration=60s,filename=app.jfr App
Step 2: Identify Hot Paths
CPU Profiling
- Functions with highest cumulative time
- Frequent function calls
- Complex algorithms
Memory Analysis
- Large object allocations
- Memory leaks
- Garbage collection pressure
- Event listener leaks (registered but never removed)
I/O Analysis
- N+1 query patterns
- Unoptimized database queries
- Unnecessary network calls
Step 3: Common Anti-Patterns
Reference: references/code-quality-checklist.md (Performance & Caching section)
| Anti-Pattern | Issue | Solution |
|---|---|---|
| N+1 Queries | Loop database calls | Batch queries, joins |
| Large Payloads | Excessive data transfer | Pagination, field selection |
| No Caching | Repeated computations | Add caching layer |
| Sync I/O | Blocking operations | Async/await |
| String Concatenation | Memory allocation in loops | StringBuilder/join |
| Missing Memoization | Same pure function called repeatedly | Add memoization |
| Over-fetching | SELECT * when only 2 columns needed |
Select specific columns |
| No Pagination | Loading entire tables | LIMIT/OFFSET or cursor pagination |
Step 4: Caching Strategy Analysis
| Issue | Risk | Diagnostic |
|---|---|---|
| Missing cache | Repeated expensive computations | "Is this expensive operation called more than once with the same inputs?" |
| Cache without TTL | Stale data served indefinitely | "How long is cached data valid?" |
| No invalidation strategy | Cache and database drift | "When the source data changes, how is the cache updated?" |
| Key collisions | Different data overwriting each other | "Could two different inputs produce the same cache key?" |
| User data cached globally | Data leaks between users | "Does the cache key include user/tenant identity?" |
| Cache stampede | All caches expire simultaneously | "What happens when the cache expires under load?" |
Step 5: Boundary Conditions Affecting Performance
Reference: references/code-quality-checklist.md (Boundary Conditions section)
| Condition | Performance Impact |
|---|---|
| Unbounded collections | Lists/maps growing without limit, OOM risk |
| Large file loading | Reading entire files into memory instead of streaming |
| String concatenation in loops | O(n^2) memory allocation |
| Empty collection edge cases | .reduce() without initial value, .sort() on empty arrays |
Step 6: Diagnostic Questions
Apply these questions to each module under review:
- "What is the most expensive operation in the critical path? Can it be cached, batched, or deferred?"
- "Are there any N+1 query patterns? (Loop that issues a query per iteration)"
- "Is there any unbounded data structure that grows with input size?"
- "For cached data, what is the TTL and invalidation strategy?"
Step 7: Document Findings
## Performance Finding
**File**: [path/to/file.py:42]
**Severity**: P1 (HIGH)
**Impact**: 500ms added latency per request
**Category**: Database Query
### Issue
N+1 query pattern in user loading
### Current Code
```python
users = User.query.all()
for user in users:
orders = Order.query.filter_by(user_id=user.id).all()
Optimized Code
users = User.query.options(
joinedload(User.orders)
).all()
Expected Improvement
- Latency: 500ms -> 50ms
- Database queries: N+1 -> 1
## Language-Specific Tools
### Python
- cProfile, py-spy, memory_profiler
- line_profiler, tracemalloc
### JavaScript
- Chrome DevTools, Node.js profiler
- clinic.js, 0x
### Java
- JFR, VisualVM, async-profiler
- JMH for benchmarks
### Go
- pprof, trace
- benchmarks
### C# / .NET
- dotTrace, dotMemory
- BenchmarkDotNet
## Quality Checklist
- [ ] Application profiled
- [ ] Hot paths identified
- [ ] Database queries analyzed (N+1, missing indexes, over-fetching)
- [ ] Memory usage reviewed (leaks, unbounded collections)
- [ ] Caching strategy evaluated (TTL, invalidation, stampede)
- [ ] Boundary conditions checked
- [ ] Diagnostic questions applied to each module
- [ ] Findings documented with metrics and severity (P0-P3)
## Related Skills
- `context-analysis` - Context understanding (Phase 1)
- `code-quality` - Code quality + SOLID review (Phase 2)
- `security-review` - Security analysis (Phase 3)
- `performance-testing` - Load testing
- `testing-review` - Test assessment (Phase 5)
- `final-report` - Consolidated report (Phase 6)
---
**Version**: 2.0.0
**Last Updated**: February 2026
**Based on**: DevAI-Hub code review methodology + code-review-expert
### Iterative Refinement Strategy
This skill is optimized for an iterative approach:
1. **Execute**: Perform the core steps defined above.
2. **Review**: Critically analyze the output (coverage, quality, completeness).
3. **Refine**: If targets aren't met, repeat the specific implementation steps with improved context.
4. **Loop**: Continue until the definition of done is satisfied.