tdd-workflows-tdd-refactor

Use this skill when

Working on tdd workflows tdd refactor tasks or workflows

Needing guidance, best practices, or checklists for tdd workflows tdd refactor

Do not use this skill when

The task is unrelated to tdd workflows tdd refactor

You need a different domain or tool outside this scope

Instructions

Clarify goals, constraints, and required inputs.

Apply relevant best practices and validate outcomes.

Provide actionable steps and verification.

If detailed examples are required, open resources/implementation-playbook.md.

Refactor code with confidence using comprehensive test safety net:

[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.]

Usage

Use Task tool with subagent_type="tdd-orchestrator" to perform safe refactoring.

Prompt: "Refactor this code while keeping all tests green: $ARGUMENTS. Apply TDD refactor phase:

Core Process

1. Pre-Assessment

Run tests to establish green baseline

Analyze code smells and test coverage

Document current performance metrics

Create incremental refactoring plan

2. Code Smell Detection

Duplicated code → Extract methods/classes

Long methods → Decompose into focused functions

Large classes → Split responsibilities

Long parameter lists → Parameter objects

Feature Envy → Move methods to appropriate classes

Primitive Obsession → Value objects

Switch statements → Polymorphism

Dead code → Remove

3. Design Patterns

Apply Creational (Factory, Builder, Singleton)

Apply Structural (Adapter, Facade, Decorator)

Apply Behavioral (Strategy, Observer, Command)

Apply Domain (Repository, Service, Value Objects)

Use patterns only where they add clear value

4. SOLID Principles

Single Responsibility: One reason to change

Open/Closed: Open for extension, closed for modification

Liskov Substitution: Subtypes substitutable

Interface Segregation: Small, focused interfaces

Dependency Inversion: Depend on abstractions

5. Refactoring Techniques

Extract Method/Variable/Interface

Inline unnecessary indirection

Rename for clarity

Move Method/Field to appropriate classes

Replace Magic Numbers with constants

Encapsulate fields

Replace Conditional with Polymorphism

Introduce Null Object

6. Performance Optimization

Profile to identify bottlenecks

Optimize algorithms and data structures

Implement caching where beneficial

Reduce database queries (N+1 elimination)

Lazy loading and pagination

Always measure before and after

7. Incremental Steps

Make small, atomic changes

Run tests after each modification

Commit after each successful refactoring

Keep refactoring separate from behavior changes

Use scaffolding when needed

8. Architecture Evolution

Layer separation and dependency management

Module boundaries and interface definition

Event-driven patterns for decoupling

Database access pattern optimization

9. Safety Verification

Run full test suite after each change

Performance regression testing

Mutation testing for test effectiveness

Rollback plan for major changes

10. Advanced Patterns

Strangler Fig: Gradual legacy replacement

Branch by Abstraction: Large-scale changes

Parallel Change: Expand-contract pattern

Mikado Method: Dependency graph navigation

Output Requirements

Refactored code with improvements applied

Test results (all green)

Before/after metrics comparison

Applied refactoring techniques list

Performance improvement measurements

Remaining technical debt assessment

Safety Checklist

Before committing:

✓ All tests pass (100% green)

✓ No functionality regression

✓ Performance metrics acceptable

✓ Code coverage maintained/improved

✓ Documentation updated

Recovery Protocol

If tests fail:

Immediately revert last change

Identify breaking refactoring

Apply smaller incremental changes

Use version control for safe experimentation

Example: Extract Method Pattern

Before:

class OrderProcessor {
  processOrder(order: Order): ProcessResult {
    // Validation
    if (!order.customerId || order.items.length === 0) {
      return { success: false, error: "Invalid order" };
    }
    // Calculate totals
    let subtotal = 0;
    for (const item of order.items) {
      subtotal += item.price  item.quantity;
    }
    let total = subtotal + (subtotal  0.08) + (subtotal > 100 ? 0 : 15);    // Process payment...
    // Update inventory...
    // Send confirmation...
  }
}

After:

class OrderProcessor {
  async processOrder(order: Order): Promise<ProcessResult> {
    const validation = this.validateOrder(order);
    if (!validation.isValid) return ProcessResult.failure(validation.error);
    const orderTotal = OrderTotal.calculate(order);
    const inventoryCheck = await this.inventoryService.checkAvailability(order.items);
    if (!inventoryCheck.available) return ProcessResult.failure(inventoryCheck.reason);
    await this.paymentService.processPayment(order.paymentMethod, orderTotal.total);
    await this.inventoryService.reserveItems(order.items);
    await this.notificationService.sendOrderConfirmation(order, orderTotal);
    return ProcessResult.success(order.id, orderTotal.total);
  }  private validateOrder(order: Order): ValidationResult {
    if (!order.customerId) return ValidationResult.invalid("Customer ID required");
    if (order.items.length === 0) return ValidationResult.invalid("Order must contain items");
    return ValidationResult.valid();
  }
}

Applied: Extract Method, Value Objects, Dependency Injection, Async patterns

Code to refactor: $ARGUMENTS"