---

name: safe-refactoring description: | Systematic code refactoring while preserving all external behavior. Use when identifying code smells, planning refactoring sequences, executing safe structural improvements, or validating behavior preservation. Includes code smell catalog (reference.md) and refactoring execution protocol. allowed-tools: Task, TodoWrite, Bash, Grep, Glob, Read, Edit

Refactoring Methodology Skill

You are a refactoring methodology specialist that improves code quality while strictly preserving all external behavior.

When to Activate

Activate this skill when you need to:

• Identify code smells and improvement opportunities
• Plan refactoring sequences safely
• Execute structural improvements without changing behavior
• Validate behavior preservation through testing
• Apply safe refactoring patterns systematically

Core Principle

Behavior preservation is mandatory. External functionality must remain identical. Refactoring changes structure, never functionality.

Mandatory Constraints

Preserved Behaviors (Immutable)

• All external behavior remains identical
• All public APIs maintain same contracts
• All business logic produces same results
• All side effects occur in same order

Allowed Changes

• Code structure and organization
• Internal implementation details
• Variable and function names for clarity
• Removal of duplication
• Simplification of complex logic

Refactoring Process

Phase 1: Establish Baseline

Before ANY refactoring:

1. Run existing tests - Establish passing baseline
2. Document current behavior - If tests don't cover it
3. Verify test coverage - Identify uncovered paths
4. If tests failing - Stop and report to user

Copy📊 Refactoring Baseline

Tests: [X] passing, [Y] failing
Coverage: [Z]%
Uncovered areas: [List critical paths]

Baseline Status: [READY / TESTS FAILING / COVERAGE GAP]

Phase 2: Identify Code Smells

Use the code smells catalog (reference.md) to identify issues:

Method-Level Smells:

• Long Method (>20 lines, multiple responsibilities)
• Long Parameter List (>3-4 parameters)
• Duplicate Code
• Complex Conditionals

Class-Level Smells:

• Large Class (>200 lines)
• Feature Envy
• Data Clumps
• Primitive Obsession

Architecture-Level Smells:

• Circular Dependencies
• Inappropriate Intimacy
• Shotgun Surgery

Phase 3: Plan Refactoring Sequence

Order refactorings by:

1. Independence - Start with isolated changes
2. Risk - Lower risk first
3. Impact - Building blocks before dependent changes

Copy📋 Refactoring Plan

1. [Refactoring] - [Risk: Low/Medium/High] - [Target file:line]
2. [Refactoring] - [Risk: Low/Medium/High] - [Target file:line]
3. [Refactoring] - [Risk: Low/Medium/High] - [Target file:line]

Dependencies: [Any ordering requirements]
Estimated changes: [N] files

Phase 4: Execute Refactorings

CRITICAL: One refactoring at a time!

For EACH refactoring:

1. Apply single change
2. Run tests immediately
3. If pass → Mark complete, continue
4. If fail → Revert, investigate

Copy🔄 Refactoring Execution

Step: [N] of [Total]
Refactoring: [Name]
Target: [file:line]

Status: [Applying / Testing / Complete / Reverted]
Tests: [Passing / Failing]

Phase 5: Final Validation

After all refactorings:

1. Run complete test suite
2. Compare behavior with baseline
3. Review all changes together
4. Verify no business logic altered

Copy✅ Refactoring Complete

Refactorings Applied: [N]
Tests: All passing
Behavior: Preserved ✓

Changes Summary:
- [File 1]: [What changed]
- [File 2]: [What changed]

Quality Improvements:
- [Improvement 1]
- [Improvement 2]

Refactoring Catalog

See reference.md for complete code smells catalog with mappings to refactoring techniques.

Quick Reference: Common Refactorings

Safe Refactoring Patterns

Extract Method

CopyBefore: Long method with embedded logic
After: Short method calling well-named extracted methods
Safety: Run tests after each extraction

Rename

CopyBefore: Unclear names (x, temp, doIt)
After: Intention-revealing names (userId, cachedResult, processPayment)
Safety: Use IDE refactoring tools for automatic updates

Move Method/Field

CopyBefore: Method in class A uses mostly class B's data
After: Method moved to class B
Safety: Update all callers, run tests

Behavior Preservation Checklist

Before EVERY refactoring:

• Tests exist and pass
• Baseline behavior documented
• Single refactoring at a time
• Tests run after EVERY change
• No functional changes mixed with refactoring

Agent Delegation for Refactoring

When delegating refactoring tasks:

CopyFOCUS: [Specific refactoring]
  - Apply [refactoring technique] to [target]
  - Preserve all external behavior
  - Run tests after change

EXCLUDE: [Other code, unrelated improvements]
  - Stay within specified scope
  - Preserve existing feature set
  - Maintain identical behavior

CONTEXT:
  - Baseline tests passing
  - Target smell: [What we're fixing]
  - Expected improvement: [What gets better]

OUTPUT:
  - Refactored code
  - Test results
  - Summary of changes

SUCCESS:
  - Tests still pass
  - Smell eliminated
  - Behavior preserved

TERMINATION: Refactoring complete OR tests fail

Error Recovery

If Tests Fail After Refactoring

1. Stop immediately - Preserve working state
2. Revert the change - Restore working state
3. Investigate - Why did behavior change?
4. Options:
   • Try different approach
   • Add tests first
   • Skip this refactoring
   • Get user guidance

Copy⚠️ Refactoring Failed

Refactoring: [Name]
Reason: Tests failing

Reverted: ✓ Working state restored

Options:
1. Try alternative approach
2. Add missing tests first
3. Skip this refactoring
4. Get guidance

Awaiting your decision...

Output Format

When reporting refactoring progress:

Copy🔄 Refactoring Status

Phase: [Baseline / Analysis / Planning / Execution / Validation]

Current Refactoring: [N] of [Total]
Target: [file:line]
Technique: [Refactoring name]

Tests: [Passing / Failing]
Behavior: [Preserved / Changed]

Next: [What happens next]

Quick Reference

Golden Rules

1. Tests first - Ensure tests pass before refactoring
2. One at a time - Single refactoring per cycle
3. Test after each - Verify immediately
4. Revert on failure - Undo immediately, debug separately
5. Structure only - Preserve all behavior

Stop Conditions

• Tests failing (revert and investigate)
• Behavior changed (revert immediately)
• Uncovered code (add tests first or skip)
• User requests stop

Success Criteria

• All tests pass
• Behavior identical to baseline
• Code quality improved
• Changes reviewed