refactoring

name	refactoring
description	Comprehensive skill for 89 refactoring techniques and 22 code smells with practical examples. Use when the user asks to refactor code, detect code smells, improve code quality, reduce complexity, or clean up technical debt. Covers composing methods, moving features between objects, organizing data, simplifying conditionals and method calls, dealing with generalization, and detecting smells across bloaters, OO abusers, change preventers, dispensables, and couplers with before/after comparisons and step-by-step mechanics.
allowed-tools	Read Grep Glob Bash
user-invocable	false

Refactoring

A thorough reference covering 89 refactoring techniques and code smells — featuring PHP 8.3+ examples, rationale, step-by-step mechanics, and before/after comparisons.

Refactoring Techniques (67)

Composing Methods

• Extract Method — Pull code fragments into named methods → reference
• Inline Method — Substitute a method call with its body → reference
• Extract Variable — Give complex expressions meaningful names through explanatory variables → reference
• Inline Temp — Substitute a temporary variable with its expression → reference
• Replace Temp with Query — Swap temp variables for method calls → reference
• Split Temporary Variable — Assign separate variables for separate purposes → reference
• Remove Assignments to Parameters — Introduce local variables rather than reassigning parameters → reference
• Replace Method with Method Object — Convert a complex method into its own class → reference
• Substitute Algorithm — Swap an algorithm for a clearer alternative → reference

Moving Features Between Objects

• Move Method — Relocate a method to the class that depends on it most → reference
• Move Field — Relocate a field to the class that depends on it most → reference
• Extract Class — Divide a class that handles too much → reference
• Inline Class — Consolidate a class that does too little → reference
• Hide Delegate — Introduce methods that conceal delegation chains → reference
• Remove Middle Man — Allow clients to call the delegate directly → reference
• Introduce Foreign Method — Attach a missing method to a class you cannot modify → reference
• Introduce Local Extension — Build a wrapper or subclass for a library class → reference

Organizing Data

• Self Encapsulate Field — Route field access through getters even within the class → reference
• Replace Data Value with Object — Promote primitive data to a rich object → reference
• Change Value to Reference — Convert value objects into reference objects → reference
• Change Reference to Value — Convert reference objects into value objects → reference
• Replace Array with Object — Swap arrays used as data structures for proper objects → reference
• Duplicate Observed Data — Keep domain data in sync with the UI via Observer → reference
• Change Unidirectional to Bidirectional — Introduce back-references when needed → reference
• Change Bidirectional to Unidirectional — Eliminate unnecessary back-references → reference
• Replace Magic Number with Symbolic Constant — Assign meaningful names to magic numbers → reference
• Encapsulate Field — Restrict field visibility, expose accessors → reference
• Encapsulate Collection — Expose read-only views of collections → reference
• Replace Type Code with Class — Swap type codes for enums or classes → reference
• Replace Type Code with Subclasses — Swap type codes for a class hierarchy → reference
• Replace Type Code with State/Strategy — Swap behavior-affecting type codes for State/Strategy → reference
• Replace Subclass with Fields — Eliminate subclasses that differ only in constants → reference

Simplifying Conditional Expressions

• Decompose Conditional — Break complex conditionals into named methods → reference
• Consolidate Conditional Expression — Merge conditions that produce the same result → reference
• Consolidate Duplicate Conditional Fragments — Hoist identical code outside of conditionals → reference
• Remove Control Flag — Swap control flags for break/return/continue → reference
• Replace Nested Conditional with Guard Clauses — Flatten nested conditionals using early returns → reference
• Replace Conditional with Polymorphism — Swap conditionals for polymorphic method calls → reference
• Introduce Null Object — Swap null checks for a null object → reference
• Introduce Assertion — Insert assertions to document assumptions → reference

Simplifying Method Calls

• Rename Method — Choose method names that reveal their purpose → reference
• Add Parameter — Introduce new parameters to support additional data → reference
• Remove Parameter — Drop unused method parameters → reference
• Separate Query from Modifier — Divide methods that both return values and change state → reference
• Parameterize Method — Unify similar methods by adding a parameter → reference
• Replace Parameter with Explicit Methods — Produce separate methods for each parameter value → reference
• Preserve Whole Object — Pass the entire object rather than individual values → reference
• Replace Parameter with Method Call — Derive values internally instead of passing them in → reference
• Introduce Parameter Object — Bundle related parameters into an object → reference
• Remove Setting Method — Eliminate setters for fields assigned only at creation → reference
• Hide Method — Narrow the visibility of unused public methods → reference
• Replace Constructor with Factory Method — Use factory methods for complex object creation → reference
• Replace Error Code with Exception — Throw exceptions rather than returning error codes → reference
• Replace Exception with Test — Validate conditions upfront instead of catching exceptions → reference

Dealing with Generalization

• Pull Up Field — Promote identical fields to the superclass → reference
• Pull Up Method — Promote identical methods to the superclass → reference
• Pull Up Constructor Body — Promote shared constructor logic to the superclass → reference
• Push Down Method — Relocate a method to the subclass that uses it → reference
• Push Down Field — Relocate a field to the subclass that uses it → reference
• Extract Subclass — Carve out a subclass for a subset of features → reference
• Extract Superclass — Hoist shared behavior into a parent class → reference
• Extract Interface — Define a shared interface for common operations → reference
• Collapse Hierarchy — Merge superclass and subclass when they are too similar → reference
• Form Template Method — Generalize similar methods into a template → reference
• Replace Inheritance with Delegation — Swap inheritance for composition → reference
• Replace Delegation with Inheritance — Swap excessive delegation for inheritance → reference

Code Smells (22)

Bloaters

• Long Method — Methods that have grown excessively long → reference
• Large Class — Classes that try to handle too much → reference
• Primitive Obsession — Excessive use of primitives instead of small objects → reference
• Long Parameter List — Methods accepting too many parameters → reference
• Data Clumps — Groups of data that repeatedly appear together → reference

Object-Orientation Abusers

• Alternative Classes with Different Interfaces — Similar classes with mismatched method signatures → reference
• Refused Bequest — Subclasses that disregard inherited behavior → reference
• Switch Statements — Complex switch/match constructs that should be polymorphism → reference
• Temporary Field — Fields populated only under certain conditions → reference

Change Preventers

• Divergent Change — A single class modified for many unrelated reasons → reference
• Parallel Inheritance Hierarchies — Creating one subclass forces creating another → reference
• Shotgun Surgery — A single change demands edits across many classes → reference

Dispensables

• Comments — Excessive comments that mask unclear code → reference
• Duplicate Code — Identical or nearly identical code in multiple locations → reference
• Data Class — Classes consisting of nothing but fields and getters/setters → reference
• Dead Code — Unreachable or unused code → reference
• Lazy Class — Classes that contribute too little to justify their existence → reference
• Speculative Generality — Unused abstractions built "just in case" → reference

Couplers

• Feature Envy — Methods that rely more on another class's data than their own → reference
• Inappropriate Intimacy — Classes that reach into each other's internals → reference
• Incomplete Library Class — Library classes that fall short of providing needed features → reference
• Message Chains — Long chains of method calls (a.b().c().d()) → reference
• Middle Man — Classes that do nothing but delegate to another class → reference

Best Practices

• Refactor in small, verified steps — execute tests after every change
• Follow the Boy Scout Rule: leave code in better shape than you found it
• Reach for IDE refactoring tools when available for safe, automated transformations
• Never refactor and alter behavior simultaneously — keep them separate
• Prioritize refactoring that lowers coupling and raises cohesion
• Tackle code smells nearest to your current work first