Systematic Refactoring Patterns

🔄 Quick Recall: In the previous lesson, you learned to detect code smells with AI. Now you’ll learn the specific refactoring patterns that fix those smells — systematic transformations that improve code structure without changing external behavior.

Refactoring is not rewriting. It’s a series of small, behavior-preserving transformations — each one makes the code slightly better, and none of them changes what the code does. AI makes refactoring practical by generating the transformed code side by side with the original, so you can verify that the behavior is preserved.

Extract Method

AI prompt for extract method refactoring:

Refactor this function using the Extract Method pattern. Function: [PASTE CODE]. Identify logical sections that can be extracted into separate functions: (1) find blocks of code with a single clear purpose (validation, transformation, I/O, calculation), (2) identify the inputs each block needs (parameters for the new function), (3) identify the outputs (return value of the new function), (4) name the new function to describe what it does (not how). Show the before and after side by side. Verify: does calling the extracted functions in sequence produce the same result as the original function?

Extract method decision guide:

Replace Conditional with Polymorphism

AI prompt for conditional refactoring:

Refactor this conditional logic using polymorphism. Code: [PASTE CODE WITH IF/ELSE OR SWITCH]. The conditional dispatches on: [TYPE/STATUS/MODE]. Generate: (1) an interface/abstract class with the common method signature, (2) one implementation per branch of the conditional, (3) a registry or factory that maps the dispatch value to the correct implementation, (4) the refactored caller that uses the registry instead of the conditional. Verify: for each branch of the original conditional, the corresponding implementation produces the same result.

✅ Quick Check: You have if (format === 'pdf') { ... } else if (format === 'csv') { ... } else if (format === 'xlsx') { ... } with 20-30 lines per branch. After refactoring to Strategy pattern, what happens when someone requests a new format (‘json’)? (Answer: You create a new JsonExporter class implementing the Exporter interface, register it in the factory, and it works — no modification to existing code. Before refactoring, adding ‘json’ means adding another branch to the already-long conditional and risking bugs in the existing branches. This is the Open/Closed Principle in action: open for extension, closed for modification.)

Introduce Parameter Object

AI prompt for parameter object refactoring:

Refactor these functions to use a parameter object. Functions: [PASTE FUNCTIONS WITH REPEATED PARAMETER GROUPS]. Generate: (1) the parameter object class/type with all shared parameters as fields, (2) constructor or factory method with validation, (3) refactored function signatures using the parameter object, (4) any methods that should move onto the parameter object itself (logic that primarily operates on those fields). Show the before and after for each function.

Simplify Conditionals

AI prompt for conditional simplification:

Simplify the conditional logic in this code. Code: [PASTE CODE WITH COMPLEX CONDITIONS]. Apply these techniques: (1) Guard clauses — replace nested if/else with early returns for exceptional cases, (2) De Morgan’s laws — simplify negated compound conditions, (3) Boolean extraction — extract complex boolean expressions into named variables, (4) Consolidate conditionals — merge branches with identical outcomes, (5) Remove double negation — simplify if (!isNotValid) to if (isValid). Show each simplification step and verify the logic is preserved.

Before/after example — guard clauses:

Before (deeply nested):

function processOrder(order) {
  if (order) {
    if (order.items.length > 0) {
      if (order.status === 'pending') {
        // 30 lines of actual logic
      }
    }
  }
}

After (guard clauses):

function processOrder(order) {
  if (!order) return
  if (order.items.length === 0) return
  if (order.status !== 'pending') return
  // 30 lines of actual logic (no nesting)
}

Safe Refactoring Workflow

AI prompt for refactoring plan:

Create a safe refactoring plan for this code. Code: [PASTE CODE]. Current test coverage: [DESCRIBE — full/partial/none]. Generate: (1) characterization tests if no tests exist (tests that capture current behavior), (2) the refactoring sequence — which transformation first, second, third (order matters for safety), (3) verification after each step — which tests to run, what to check, (4) rollback plan — how to undo each step if something goes wrong. Each step should be small enough to commit independently: if step 3 introduces a bug, you can revert step 3 without losing steps 1 and 2.

Key Takeaways

• Always write tests before refactoring — characterization tests capture the current behavior (including bugs) so you know immediately if your refactoring changed something. AI generates these tests from the existing function
• Extract Method is the most-used refactoring pattern: comments, blank lines, and try/catch blocks are natural extraction boundaries — if you need a comment to explain what the next block does, that block should be its own function named after the comment
• Replace Conditional with Polymorphism transforms if/else chains into extensible designs: adding a new case means adding a new class, not modifying existing code. AI generates the full pattern (interface + implementations + factory)
• Guard clauses eliminate deep nesting by handling exceptional cases first with early returns — the main logic stays at the top level of indentation, dramatically improving readability
• Refactoring should be done in small, independently committable steps: each step is one transformation, verified by tests, and revertible if anything goes wrong

Up Next

In the next lesson, you’ll integrate AI review into your development workflow — PR automation, CI/CD hooks, and the review pipeline that catches issues before human reviewers see the code.