feat: add verification methodology and writing plans skills

2026-06-12 21:24:56 +03:00 · 2025-11-29 23:23:04 +07:00
parent 96d9217c31
commit 3c224790f9
80 changed files with 30860 additions and 0 deletions
@@ -0,0 +1,295 @@
+---
+title: /optimize
+description: Analyze and optimize code performance
+---
+
+# /optimize
+
+## Purpose
+
+Analyze and optimize code performance. Identifies bottlenecks, suggests improvements, and implements optimizations while ensuring correctness.
+
+## Usage
+
+```bash
+/optimize [file-or-function]
+```
+
+## Arguments
+
+- **file-or-function**: Path to file or function to optimize
+  - File path: `src/services/data-processor.ts`
+  - Function name: `processUserData`
+  - Module: `src/utils/`
+
+## Workflow
+
+### Step 1: Analyze Current Performance
+
+1. **Identify bottlenecks**
+   - Analyze time complexity
+   - Check space complexity
+   - Look for redundant operations
+
+2. **Profile if possible**
+   - Check for N+1 queries
+   - Identify unnecessary loops
+   - Find repeated calculations
+
+### Step 2: Identify Opportunities
+
+1. **Algorithm improvements**
+   - Better data structures
+   - More efficient algorithms
+   - Reduce complexity
+
+2. **Caching opportunities**
+   - Memoization
+   - Result caching
+   - Computed properties
+
+3. **Async optimizations**
+   - Parallel execution
+   - Batch operations
+   - Lazy loading
+
+### Step 3: Implement Optimizations
+
+1. **Make targeted changes**
+   - Implement improvements
+   - Preserve functionality
+   - Add comments
+
+2. **Verify improvements**
+   - Test correctness
+   - Measure performance
+   - Compare before/after
+
+## Output
+
+```markdown
+## Optimization Report: [Component]
+
+### Current Performance
+- Time complexity: O(n²)
+- Space complexity: O(n)
+- Estimated execution time: 500ms for 1000 items
+- Issues found: 3
+
+### Bottlenecks Identified
+
+1. **Nested loop in data processing**
+   - Location: `processData()` lines 45-60
+   - Impact: High
+   - Current: O(n²)
+
+2. **Redundant database queries**
+   - Location: `getUserData()` lines 120-135
+   - Impact: Medium
+   - Issue: N+1 query pattern
+
+3. **Inefficient array operations**
+   - Location: `filterResults()` lines 88-92
+   - Impact: Low
+   - Issue: Multiple array iterations
+
+### Optimizations Applied
+
+#### 1. Algorithm Improvement
+**Before:**
+```typescript
+// O(n²) nested loop
+for (const item of items) {
+  for (const tag of tags) {
+    if (item.tags.includes(tag)) {
+      results.push(item);
+    }
+  }
+}
+```
+
+**After:**
+```typescript
+// O(n) with Set lookup
+const tagSet = new Set(tags);
+const results = items.filter(item =>
+  item.tags.some(tag => tagSet.has(tag))
+);
+```
+
+**Impact:** Time complexity reduced from O(n²) to O(n)
+
+#### 2. Caching Implementation
+**Before:**
+```typescript
+function calculateScore(user) {
+  // Recalculates every time
+  return expensiveCalculation(user);
+}
+```
+
+**After:**
+```typescript
+const scoreCache = new Map();
+function calculateScore(user) {
+  if (scoreCache.has(user.id)) {
+    return scoreCache.get(user.id);
+  }
+  const score = expensiveCalculation(user);
+  scoreCache.set(user.id, score);
+  return score;
+}
+```
+
+**Impact:** 95% cache hit rate in typical usage
+
+#### 3. Batch Processing
+**Before:**
+```typescript
+for (const userId of userIds) {
+  await db.getUser(userId); // N queries
+}
+```
+
+**After:**
+```typescript
+const users = await db.getUsers(userIds); // 1 query
+```
+
+**Impact:** Reduced database queries from N to 1
+
+### Performance Improvements
+
+| Metric | Before | After | Improvement |
+|--------|--------|-------|-------------|
+| Time Complexity | O(n²) | O(n log n) | 90% faster |
+| Execution Time | 500ms | 50ms | 10x faster |
+| Database Queries | 100 | 1 | 99% reduction |
+| Memory Usage | 150MB | 80MB | 47% reduction |
+
+### Testing
+
+All existing tests pass:
+- ✅ Unit tests: 45/45
+- ✅ Integration tests: 12/12
+- ✅ Performance benchmarks added
+
+### Recommendations
+
+1. **Monitor in production**: Track actual performance metrics
+2. **Consider further optimization**: Implement pagination for large datasets
+3. **Add benchmarks**: Create performance regression tests
+
+### Files Modified
+- `src/services/data-processor.ts`
+- `tests/data-processor.test.ts` (added benchmarks)
+```
+
+## Optimization Strategies
+
+### 1. Algorithm Optimization
+- Replace inefficient algorithms
+- Use appropriate data structures
+- Reduce time/space complexity
+
+### 2. Caching
+- Memoize expensive calculations
+- Cache API responses
+- Use computed properties
+
+### 3. Database Optimization
+- Batch queries
+- Add indexes
+- Optimize query patterns
+- Use eager loading
+
+### 4. Async Optimization
+- Parallel execution with `Promise.all()`
+- Lazy loading
+- Stream processing
+
+### 5. Code-Level Optimization
+- Avoid premature optimization
+- Profile before optimizing
+- Focus on hot paths
+
+## Examples
+
+```bash
+# Optimize specific file
+/optimize src/services/report-generator.ts
+
+# Optimize by function name
+/optimize calculateTotalSales
+
+# Optimize entire module
+/optimize src/utils/
+
+# Optimize with performance persona
+/optimize --persona=performance src/api/users.ts
+```
+
+## Flags
+
+| Flag | Description |
+|------|-------------|
+| `--profile` | Include profiling data |
+| `--benchmark` | Add performance benchmarks |
+| `--aggressive` | More aggressive optimizations |
+| `--safe` | Conservative optimizations only |
+| `--persona=performance` | Performance-focused analysis |
+
+## Best Practices
+
+1. **Profile First**: Don't optimize without measuring
+2. **Preserve Correctness**: Always verify behavior unchanged
+3. **Add Tests**: Include performance regression tests
+4. **Document Changes**: Explain why optimizations were made
+5. **Measure Impact**: Compare before/after metrics
+
+## Common Optimizations
+
+### N+1 Query Prevention
+```typescript
+// Before: N+1 queries
+const users = await db.getUsers();
+for (const user of users) {
+  user.posts = await db.getPostsByUser(user.id);
+}
+
+// After: 2 queries
+const users = await db.getUsers();
+const posts = await db.getPostsByUsers(users.map(u => u.id));
+// Map posts to users
+```
+
+### Memoization
+```typescript
+const memoize = (fn) => {
+  const cache = new Map();
+  return (...args) => {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) return cache.get(key);
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  };
+};
+```
+
+### Debouncing
+```typescript
+const debounce = (fn, delay) => {
+  let timeout;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => fn(...args), delay);
+  };
+};
+```
+
+## Related Commands
+
+- [/review](/claudekit/core-commands/review) - Code review with performance checks
+- [/test](/claudekit/core-commands/test) - Add performance tests
+- [/fix](/claudekit/core-commands/fix) - Fix performance issues