dry-refactor

This skill should be used when the user asks to "refactor duplicate code", "apply DRY principles", "eliminate code repetition", "extract common functionality", or mentions code duplication, similar patterns, repeated logic, or reusable abstractions.

⭐5stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026

When & Why to Use This Skill

This Claude skill specializes in optimizing software maintainability by identifying and eliminating code duplication through 'Don't Repeat Yourself' (DRY) principles. It provides a systematic approach to refactoring, helping developers reduce technical debt, improve code readability, and implement robust design patterns like polymorphism and strategy patterns.

Use Cases

  • Refactoring repetitive logic: Automatically identify near-identical code blocks across a project and extract them into reusable functions or shared utilities.
  • Simplifying complex conditionals: Replace redundant switch or if-else statements with polymorphic structures or strategy patterns to enhance extensibility.
  • Cleaning up class hierarchies: Detect identical methods in subclasses and 'pull them up' to a base class to ensure consistent behavior and easier maintenance.
  • Optimizing expressions: Extract repeated complex expressions into descriptive variables to improve code clarity and reduce the risk of logic errors.
  • Architectural improvement: Consolidate scattered related functions into cohesive classes, applying the 'Rule of Three' to ensure abstractions are meaningful and not premature.
namedry-refactor
descriptionThis skill should be used when the user asks to "refactor duplicate code", "apply DRY principles", "eliminate code repetition", "extract common functionality", or mentions code duplication, similar patterns, repeated logic, or reusable abstractions.

DRY Refactoring

Process

  1. Identify - Exact copies, similar patterns, parallel hierarchies, naming patterns (data1/data2, handleXClick)
  2. Analyze - Coupling, cohesion, frequency (Rule of Three: wait for 3+ occurrences), volatility
  3. Refactor - Choose technique below, extract incrementally, test after each step

Techniques

Extract Function - Same logic in multiple places

getFullName(user: User) => `${user.firstName} ${user.lastName}`

Extract Variable - Repeated expression

const isWorkingAge = user.age >= 18 && user.age < 65;

Parameterize - Code differs only in values

validateField(value: string, pattern: RegExp)
// Use: validateField(email, EMAIL_REGEX)

Extract Class - Related functions scattered

class UserRewards {
  calculateDiscount(user, amount) { }
  getLoyaltyPoints(user) { }
}

Polymorphism - Repeated switch/if-else

interface PaymentProcessor { process(amount: number): void }
class CreditProcessor implements PaymentProcessor { }

Strategy Pattern - Duplicated algorithm selection

const strategies = { date: byDate, name: byName };
items.sort(strategies[sortType] ?? byPriority);

Pull Up Method - Identical methods in subclasses

class BaseUser { getDisplayName() { } }
class AdminUser extends BaseUser { }

Detection

Code Smells: Look for numbered variables (data1, data2), parallel function names (handleXClick), near-identical code differing only in constants, repeated validation/error handling, parallel class structures, large switches in multiple places, repeated null checks, magic numbers

Rule of Three: Wait for 3+ occurrences before abstracting

When NOT to DRY

  • Coincidental similarity - Avoid abstracting different domains/business rules that happen to look alike (will diverge)
  • Premature abstraction - Wait until pattern is clear; early abstraction often guesses wrong
  • Single use - Skip abstraction when code appears 1-2 times and is unlikely to grow
  • Test clarity - Prefer readable test setup over DRY
  • Over-engineering - Avoid abstracting every 2-3 line similarity

Patterns

  • Configuration over code - Use data structures to eliminate conditionals
  • Template Method - Define skeleton in base, vary steps in subclasses
  • Dependency Injection - Parameterize dependencies to reduce coupling
  • Builder - Construct complex objects incrementally

Best Practices

  • Refactor only after tests pass (green)
  • Apply one refactoring at a time
  • Commit changes frequently
  • Name abstractions for intent, not implementation
  • Consider performance impact of abstractions
  • Review abstractions with team before finalizing