Agent Skills: Optimize Mode

Optimize Mode

Goal: Improve quality WITHOUT changing behavior.

Process

1. Risk assessment (classify change type)
2. Measure current state (baseline)
3. Identify main bottleneck
4. Choose safe optimization strategy
5. Propose improvements + predict results
6. Refactor by priority order
7. Compare before/after
8. Ensure tests still pass
9. Document rollback plan

Performance Metrics by Language

| Language | Build/Size | Runtime | Profiling Tool | |----------|------------|---------|----------------| | JS/TS | Bundle < 500KB | Render < 16ms | Webpack Analyzer, Lighthouse | | Python | N/A | Response < 100ms | cProfile, py-spy | | Java | JAR size | GC pause < 50ms | JProfiler, VisualVM | | Go | Binary size | p99 latency | pprof, go test -bench |

Common Optimization Patterns

All Languages

| Issue | Solution | Impact | |-------|----------|--------| | Slow DB queries | Add indexes, limit results, eager loading | High | | N+1 queries | Batch loading, JOINs | High | | Large payloads | Pagination, compression, lazy loading | High | | Repeated calculations | Caching, memoization | Medium | | Memory leaks | Proper cleanup, weak references | Medium |

Language-Specific

| Language | Common Issue | Solution | |----------|--------------|----------| | JS/TS | Unnecessary re-renders | React.memo, useMemo, useCallback | | JS/TS | Large bundle | Code splitting, tree shaking, dynamic imports | | Python | Slow loops | NumPy vectorization, list comprehensions | | Go | Excessive allocations | Sync.Pool, pre-allocate slices |

Output Format

## OPTIMIZE

**Issue:** [slow / duplicate code / hard to maintain]
**Language:** [JS/Python/Java/Go/PHP/Ruby]

**Baseline:**
- Response time: X ms
- Memory: X MB
- LOC: X

---

### Bottleneck:
| Issue | Location | Severity |
|-------|----------|----------|
| [Description] | `file:line` | High |

### Proposal:
| Item | Before | After | Change |
|------|--------|-------|--------|
| Response time | 500ms | 50ms | -90% |
| Memory | 200MB | 50MB | -75% |

### Regression Check:
- [ ] Tests still pass
- [ ] Behavior unchanged
- [ ] Performance verified

## Risk Assessment

### Risk Classification
| Change Type      | Risk Level | Rollback Ease | Strategy                        |
| ---------------- | ---------- | ------------- | ------------------------------- |
| Algorithm change | High       | Easy          | A/B test, gradual rollout       |
| Database schema  | High       | Hard          | Migration plan, rollback script |
| Caching layer    | Medium     | Medium        | Feature flag, monitor           |
| Code refactor    | Low        | Easy          | Tests, revert if fail           |

### Risk Questions
- [ ] What if optimization introduces bugs?
- [ ] Can we rollback easily?
- [ ] What's the blast radius?
- [ ] Who gets affected if fails?

### Safe Optimization Strategies

#### Strategy 1: Feature Flag (Recommended for critical paths)
```typescript
// Use feature flag for new optimized code
const useNewOptimization = featureFlags.get('use-v2-algorithm', false);

if (useNewOptimization) {
  return optimizedMethod(data);
} else {
  return legacyMethod(data);
}

Strategy 2: Gradual Rollout

**Week 1:** 5% of traffic
**Week 2:** 25% of traffic
**Week 3:** 50% of traffic
**Week 4:** 100% of traffic

**Monitor after each phase:**
- Error rate
- Performance metrics
- User complaints

Strategy 3: A/B Testing

**Control:** Current implementation
**Variant:** Optimized implementation

**Metrics to compare:**
- Response time (p50, p95, p99)
- Error rate
- Resource usage
- User satisfaction

**Statistical significance:** 95% confidence

Rollback Plan

Document Before Optimizing

**Rollback Trigger:**
- Error rate increases > 5%
- p95 latency degrades > 20%
- User complaints > X/hour

**Rollback Steps:**
1. [Revert commit / disable feature flag]
2. [Verify old behavior restored]
3. [Monitor for Y minutes]
4. [Document lessons learned]

Optimization Safety Checklist

• [ ] Baseline metrics documented
• [ ] Rollback plan written
• [ ] Feature flag available (if critical)
• [ ] Monitoring/alerts configured
• [ ] Tests covering the change
• [ ] Code reviewed
• [ ] Staged rollout planned

## Quick Optimization Examples

### React Re-render
```diff
- function UserList({ users }) {
-   return users.map(u => <UserCard user={u} />);
- }
+ const UserList = React.memo(function UserList({ users }) {
+   return users.map(u => <UserCard key={u.id} user={u} />);
+ });

Python N+1 Query

- for order in orders:
-     print(order.customer.name)
+ orders = Order.objects.select_related('customer').all()
+ for order in orders:
+     print(order.customer.name)

Go Slice Pre-allocation

- var results []Result
- for _, item := range items {
-     results = append(results, process(item))
- }
+ results := make([]Result, 0, len(items))
+ for _, item := range items {
+     results = append(results, process(item))
+ }

Principles

| DON'T | DO | |-------|-----| | Optimize prematurely | Measure first, optimize later | | Change behavior | Keep behavior unchanged | | Prioritize cleverness | Readability > Performance | | Skip tests | Re-run tests after changes | | Optimize everything | Focus on bottlenecks (80/20 rule) |