LLMSkillHub
mirroredCopied from irahardianto/awesome-agv under MIT. irahardianto has not claimed this page, and is not affiliated with LLM SkillHub.

irahardianto / refactoring-patterns

Safe refactoring pattern catalog: code smell taxonomy, transformation techniques, behavior preservation strategies, and metrics tracking.

0
SKILL.md
3.1 KB

Refactoring Patterns

Catalog of safe, incremental code transformation patterns.

When to Invoke

  • Executing /refactor command
  • Technical debt remediation
  • Pattern migration (e.g., callbacks → async/await)
  • Code smell resolution from static analysis findings

Code Smell Taxonomy

Structural Smells

SmellDetectionRefactoring
Long method>30 linesExtract method
Large class>300 lines or >5 responsibilitiesExtract class
Long parameter list>4 parametersIntroduce parameter object
Feature envyMethod uses another class's data more than its ownMove method
Data clumpsSame fields appear together repeatedlyExtract class
Primitive obsessionPrimitives where domain types belongIntroduce value object

Coupling Smells

SmellDetectionRefactoring
God classOne class knows/does too muchExtract classes by responsibility
Circular dependencyA → B → AIntroduce interface, dependency inversion
Inappropriate intimacyClasses access each other's internalsMove method, extract interface
Shotgun surgeryOne change requires touching many filesMove related code together

Safe Transformation Techniques

1. Characterization Tests

Before refactoring, write tests that capture current behavior:

Run existing code → record outputs → assert in tests → now refactor safely

2. Strangler Fig Pattern

Gradually replace old implementation with new:

Old Code ← requests
         ↓ gradually route to
New Code ← requests (eventually all traffic)
Old Code ← delete

3. Branch by Abstraction

  1. Create abstraction (interface) over existing implementation
  2. Modify all clients to use abstraction
  3. Create new implementation behind abstraction
  4. Switch to new implementation
  5. Remove old implementation

4. Parallel Run

Run old and new implementations simultaneously, compare outputs:

Request → Old Implementation → Response (returned to user)
       → New Implementation → Response (logged, compared)

Behavior Preservation Checklist

  • [ ] Tests pass before starting
  • [ ] Each step is a single, atomic change
  • [ ] Tests pass after each step
  • [ ] Same inputs produce same outputs
  • [ ] Coverage ≥ pre-refactoring level
  • [ ] No new public API surface (unless intentional)
  • [ ] Complexity metrics improved or unchanged

Metrics

MetricToolTarget
Cyclomatic complexitySonarQube, radon, gocyclo≤ 10 per function
Cognitive complexitySonarQube≤ 15 per function
Coupling (afferent/efferent)JDepend, NDependDecreasing trend
DuplicationSonarQube, jscpd< 3%
Test coveragelcov, coverage.py≥ pre-refactoring

Related

  • Code Review @.agents/skills/code-review/SKILL.md
  • Guardrails @.agents/skills/guardrails/SKILL.md
  • Testing Strategy .agents/rules/testing-strategy.md