Progressive L1-L6 refactoring hierarchy, 22 code smell taxonomy, atomic transformations, test code smells, and Fowler refactoring catalog
Based on the Refactoring Priority Premise (RPP) from the Alcor Academy curriculum.
Execute levels in mandatory sequence. Lower levels before higher.
Focus: eliminate clutter, improve naming, remove dead code. Smells: Dead Code | Comments (how-comments) | Speculative Generality | Lazy Class. Transformations: Rename | Extract (variables/constants) | Safe Delete. Impact: 80% of readability improvement value. Test smells: Obscure Test | Hard-Coded Test Data | Assertion Roulette.
Focus: method extraction, duplication elimination. Smells: Long Method | Duplicate Code | Complex Conditionals. Transformations: Extract (methods) | Move (common code). Impact: 20% additional readability improvement. Test smells: Eager Test | Test Code Duplication | Conditional Test Logic.
Focus: class responsibilities, coupling reduction. Smells: Large Class | Feature Envy | Inappropriate Intimacy | Data Class | Divergent Change | Shotgun Surgery. Transformations: Move | Extract (classes). Test smells: Test Class Bloat | Mystery Guest | General Fixture.
Focus: parameter objects, value objects, abstractions. Smells: Long Parameter List | Data Clumps | Primitive Obsession | Middle Man. Transformations: Extract (objects) | Inline | Move.
Focus: Strategy | State | Command patterns. Smells: Switch Statements | complex state-dependent behavior. Transformations: Extract (interfaces) | Move (to polymorphic structure).
Focus: SOLID principles, architectural patterns. Smells: Refused Bequest | Parallel Inheritance Hierarchies. Transformations: Extract (interfaces) | Move (responsibilities) | Safe Delete (violations).
MANDATORY: complete each level fully before moving to the next. Do not skip levels. 80% of refactoring value comes from readability improvements (L1-L2). Focus effort on L1-L2 for maximum impact. Move to higher levels only when needed.
When GREEN phase produced < 30 LOC of new production code:
L4-L6 architecture refactoring runs at orchestrator Phase 2.25 (once after all steps complete), not during each TDD inner loop.
| Smell | Detection | Treatment | Level |
|---|---|---|---|
| Long Method | >20 lines, multiple responsibilities | Extract Method, Compose Method | L2 |
| Large Class | >300 lines, too many fields | Extract Class, Extract Subclass | L3 |
| Primitive Obsession | Raw strings for domain concepts, magic numbers | Replace Data Value with Object | L4 |
| Long Parameter List | >=4 parameters | Introduce Parameter Object | L4 |
| Data Clumps | Same parameter groups repeated | Extract Class, Introduce Parameter Object | L4 |
| Smell | Detection | Treatment | Level |
|---|---|---|---|
| Switch Statements | Switch on type, complex if-else chains | Replace with Polymorphism, Strategy | L5 |
| Temporary Field | Fields empty most of the time | Extract Class, Null Object | L3 |
| Refused Bequest | Subclass doesn't support parent interface | Push Down, Replace Inheritance with Delegation | L6 |
| Alternative Classes, Different Interfaces | Same function, different names | Rename Method, Extract Superclass | L3 |
| Smell | Detection | Treatment | Level |
|---|---|---|---|
| Divergent Change | One class changed for different reasons | Extract Class | L3 |
| Shotgun Surgery | Change requires many small changes to many classes | Move Method, Move Field, Inline Class | L3 |
| Parallel Inheritance Hierarchies | Creating subclass requires another subclass | Move Method, Move Field | L6 |
| Smell | Detection | Treatment | Level |
|---|---|---|---|
| Comments (how-comments) | Comments explaining complex code | Extract Method, Rename Method | L1 |
| Duplicate Code | Same code structure in multiple places | Extract Method, Pull Up Method | L2 |
| Lazy Class | Class with few methods, little functionality | Inline Class, Collapse Hierarchy | L1 |
| Data Class | Only fields and getters/setters | Move Method, Encapsulate Field | L3 |
| Dead Code | Unused variables, methods, classes | Delete unused code | L1 |
| Speculative Generality | Abstractions for future features | Collapse Hierarchy, Inline Class | L1 |
| Smell | Detection | Treatment | Level |
|---|---|---|---|
| Feature Envy | Method uses another object's data more than its own | Move Method, Extract Method | L3 |
| Inappropriate Intimacy | Classes know too much about each other | Move Method, Extract Class, Hide Delegate | L3 |
| Message Chains | a.getB().getC().getD() | Hide Delegate, Extract Method | L3 |
| Middle Man | Class only delegates to another | Remove Middle Man, Inline Method | L4 |
Change name without changing behavior. Applies to: variables | methods | classes | fields | parameters. Safety: use IDE refactoring tools, verify all references updated, run tests, commit.
Take portion of code, create new element. Applies to: methods | classes | variables | constants | interfaces. Safety: identify code, create element with intention-revealing name, move code, replace original with call, test, commit.
Replace code element with its implementation. Applies to: methods | variables | classes. Safety: verify no side effects, replace all calls, remove original, test, commit.
Relocate code element to different scope or class. Applies to: methods | fields | classes. Safety: check dependencies, create in target, update references, remove from source, test, commit.
Remove unused code elements. Applies to: methods | fields | classes | parameters | variables. Safety: verify truly unused, check for dynamic references, remove, compile and test, commit.
For test code smells (9 smells with detection patterns and before/after examples), load the test-refactoring-catalog skill.
Don't design patterns upfront - refactor toward them as needs emerge:
For complex architectural refactoring, load the mikado-method skill.