Tdd Workflows Tdd Refactor

1---
2name: tdd-workflows-tdd-refactor
3description: "Use when working with tdd workflows tdd refactor"
4---
5 
6## Use this skill when
7 
8- Working on tdd workflows tdd refactor tasks or workflows
9- Needing guidance, best practices, or checklists for tdd workflows tdd refactor
10 
11## Do not use this skill when
12 
13- The task is unrelated to tdd workflows tdd refactor
14- You need a different domain or tool outside this scope
15 
16## Instructions
17 
18- Clarify goals, constraints, and required inputs.
19- Apply relevant best practices and validate outcomes.
20- Provide actionable steps and verification.
21- If detailed examples are required, open `resources/implementation-playbook.md`.
22 
23Refactor code with confidence using comprehensive test safety net:
24 
25[Extended thinking: This tool uses the tdd-orchestrator agent (opus model) for sophisticated refactoring while maintaining all tests green. It applies design patterns, improves code quality, and optimizes performance with the safety of comprehensive test coverage.]
26 
27## Usage
28 
29Use Task tool with subagent_type="tdd-orchestrator" to perform safe refactoring.
30 
31Prompt: "Refactor this code while keeping all tests green: $ARGUMENTS. Apply TDD refactor phase:
32 
33## Core Process
34 
35**1. Pre-Assessment**
36- Run tests to establish green baseline
37- Analyze code smells and test coverage
38- Document current performance metrics
39- Create incremental refactoring plan
40 
41**2. Code Smell Detection**
42- Duplicated code → Extract methods/classes
43- Long methods → Decompose into focused functions
44- Large classes → Split responsibilities
45- Long parameter lists → Parameter objects
46- Feature Envy → Move methods to appropriate classes
47- Primitive Obsession → Value objects
48- Switch statements → Polymorphism
49- Dead code → Remove
50 
51**3. Design Patterns**
52- Apply Creational (Factory, Builder, Singleton)
53- Apply Structural (Adapter, Facade, Decorator)
54- Apply Behavioral (Strategy, Observer, Command)
55- Apply Domain (Repository, Service, Value Objects)
56- Use patterns only where they add clear value
57 
58**4. SOLID Principles**
59- Single Responsibility: One reason to change
60- Open/Closed: Open for extension, closed for modification
61- Liskov Substitution: Subtypes substitutable
62- Interface Segregation: Small, focused interfaces
63- Dependency Inversion: Depend on abstractions
64 
65**5. Refactoring Techniques**
66- Extract Method/Variable/Interface
67- Inline unnecessary indirection
68- Rename for clarity
69- Move Method/Field to appropriate classes
70- Replace Magic Numbers with constants
71- Encapsulate fields
72- Replace Conditional with Polymorphism
73- Introduce Null Object
74 
75**6. Performance Optimization**
76- Profile to identify bottlenecks
77- Optimize algorithms and data structures
78- Implement caching where beneficial
79- Reduce database queries (N+1 elimination)
80- Lazy loading and pagination
81- Always measure before and after
82 
83**7. Incremental Steps**
84- Make small, atomic changes
85- Run tests after each modification
86- Commit after each successful refactoring
87- Keep refactoring separate from behavior changes
88- Use scaffolding when needed
89 
90**8. Architecture Evolution**
91- Layer separation and dependency management
92- Module boundaries and interface definition
93- Event-driven patterns for decoupling
94- Database access pattern optimization
95 
96**9. Safety Verification**
97- Run full test suite after each change
98- Performance regression testing
99- Mutation testing for test effectiveness
100- Rollback plan for major changes
101 
102**10. Advanced Patterns**
103- Strangler Fig: Gradual legacy replacement
104- Branch by Abstraction: Large-scale changes
105- Parallel Change: Expand-contract pattern
106- Mikado Method: Dependency graph navigation
107 
108## Output Requirements
109 
110- Refactored code with improvements applied
111- Test results (all green)
112- Before/after metrics comparison
113- Applied refactoring techniques list
114- Performance improvement measurements
115- Remaining technical debt assessment
116 
117## Safety Checklist
118 
119Before committing:
120- ✓ All tests pass (100% green)
121- ✓ No functionality regression
122- ✓ Performance metrics acceptable
123- ✓ Code coverage maintained/improved
124- ✓ Documentation updated
125 
126## Recovery Protocol
127 
128If tests fail:
129- Immediately revert last change
130- Identify breaking refactoring
131- Apply smaller incremental changes
132- Use version control for safe experimentation
133 
134## Example: Extract Method Pattern
135 
136**Before:**
137```typescript
138class OrderProcessor {
139  processOrder(order: Order): ProcessResult {
140    // Validation
141    if (!order.customerId || order.items.length === 0) {
142      return { success: false, error: "Invalid order" };
143    }
144 
145    // Calculate totals
146    let subtotal = 0;
147    for (const item of order.items) {
148      subtotal += item.price * item.quantity;
149    }
150    let total = subtotal + (subtotal * 0.08) + (subtotal > 100 ? 0 : 15);
151 
152    // Process payment...
153    // Update inventory...
154    // Send confirmation...
155  }
156}
157```
158 
159**After:**
160```typescript
161class OrderProcessor {
162  async processOrder(order: Order): Promise<ProcessResult> {
163    const validation = this.validateOrder(order);
164    if (!validation.isValid) return ProcessResult.failure(validation.error);
165 
166    const orderTotal = OrderTotal.calculate(order);
167    const inventoryCheck = await this.inventoryService.checkAvailability(order.items);
168    if (!inventoryCheck.available) return ProcessResult.failure(inventoryCheck.reason);
169 
170    await this.paymentService.processPayment(order.paymentMethod, orderTotal.total);
171    await this.inventoryService.reserveItems(order.items);
172    await this.notificationService.sendOrderConfirmation(order, orderTotal);
173 
174    return ProcessResult.success(order.id, orderTotal.total);
175  }
176 
177  private validateOrder(order: Order): ValidationResult {
178    if (!order.customerId) return ValidationResult.invalid("Customer ID required");
179    if (order.items.length === 0) return ValidationResult.invalid("Order must contain items");
180    return ValidationResult.valid();
181  }
182}
183```
184 
185**Applied:** Extract Method, Value Objects, Dependency Injection, Async patterns
186 
187Code to refactor: $ARGUMENTS"
188