Course contentsShow
← Software Engineering
Lesson 329 of 1,93310. RefactoringFree lesson

When to Refactor

Identifying the right times to refactor: the rule of three, before adding features, during bug fixes, and in code review.

When to Refactor

You'll learn the best moments to pause and improve your code's internal structure.

The Timing Problem

Knowing what refactoring is and why it matters doesn't tell you when to do it. Refactor too early, and you waste time polishing code that might change drastically. Refactor too late, and you're drowning in technical debt. The secret is recognizing strategic moments when refactoring delivers maximum value with minimal disruption.

Four Key Refactoring Triggers

The Rule of Three

The first time you write something, just do it. The second time you do something similar, wince at the duplication but move on. The third time you encounter the same pattern? Stop and refactor. This rule prevents premature abstraction while catching repetition before it spreads too far.

Before Adding Features

Imagine trying to add a room to a house with a cracked foundation. Fix the foundation first. When you're about to add new functionality, look at the existing code. If it's messy or brittle, refactor it first to make the new feature easier to add. You'll work faster and introduce fewer bugs.

During Bug Fixes

Found a bug? That's a red flag that the code is confusing—either to you or to whoever wrote it. After fixing the bug, spend a few minutes refactoring the surrounding code to make it clearer. This prevents similar bugs from creeping back in.

In Code Review

When reviewing a colleague's pull request (or having yours reviewed), unclear or overly complex code stands out. Code review is the perfect time to suggest refactoring improvements before the code enters the main codebase.

When NOT to Refactor

Don't refactor code you're about to delete or rewrite completely. Don't refactor right before a critical deadline unless it directly blocks deployment.

Key Takeaway: Refactor when you see duplication for the third time, before adding features, after fixing bugs, and during code reviews—not randomly or under extreme time pressure.