Refactor
DevelopmentrefactorRefactor is an Agent Skill for development published in the FlorianBruniaux/claude-code-ultimate-guide repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.
Analyze code for SOLID violations and suggest targeted improvements
How to use this skill
Bring this guide into your coding agent with a prompt tailored to the tool you use.
- Open your project in Codex.
- Copy and paste the prompt below.
- Review files and risks before approving any action.
Inspect the Agent Skill at https://github.com/FlorianBruniaux/claude-code-ultimate-guide/blob/HEAD/examples/skills/refactor/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/refactor, but wait for my approval before writing files or running scripts.
Copying this prompt does not install or run the skill. Review third-party files before use.
SOLID Refactoring Assistant
Analyze code for SOLID violations and suggest targeted improvements.
Purpose
Identify refactoring opportunities based on:
- SOLID principle violations
- Code smells and anti-patterns
- Complexity metrics
- Duplication detection
Instructions
Step 1: Scope Analysis
Determine the refactoring scope from user input:
- Single file: Deep analysis
- Directory: Pattern detection across files
- Function/class: Focused extraction suggestions
# Get file/directory stats
if [ -f "$TARGET" ]; then
wc -l "$TARGET"
echo "Single file analysis"
elif [ -d "$TARGET" ]; then
find "$TARGET" -type f \( -name "*.ts" -o -name "*.js" -o -name "*.py" \) | wc -l
echo "Directory analysis"
fi
Step 2: SOLID Violations Detection
S - Single Responsibility
Look for:
- Files > 300 lines
- Functions > 50 lines
- Classes with > 10 methods
- Mixed concerns (data + UI + business logic)
# Find large files
find . -name "*.{ts,js,py}" -exec wc -l {} + 2>/dev/null | sort -rn | head -10
# Functions with high line count (approximate)
grep -rn "function\|def \|fn " --include="*.{ts,js,py,rs}" . | head -20
O - Open/Closed Principle
Look for:
- Switch/case statements on types
- Repeated if/else type checking
- Direct modifications vs extensions
L - Liskov Substitution
Look for:
- Overridden methods that throw "not implemented"
- Type checks before method calls
- Empty method overrides
I - Interface Segregation
Look for:
- Large interfaces (> 10 methods)
- Classes implementing unused interface methods
- Fat service classes
D - Dependency Inversion
Look for:
- Direct instantiation of dependencies (
new Service()) - Hardcoded class references
- Missing dependency injection
Step 3: Code Smells
# Duplication patterns
grep -rn --include="*.{ts,js,py}" . 2>/dev/null | \
awk -F: '{print $3}' | sort | uniq -c | sort -rn | head -10
# Long parameter lists (> 4 params)
grep -rn "function.*,.*,.*,.*," --include="*.{ts,js}" . 2>/dev/null | head -10
# Deep nesting (4+ levels)
grep -rn "^\s\{16,\}" --include="*.{ts,js,py}" . 2>/dev/null | head -10
Step 4: Complexity Assessment
For each issue found, assess:
- Impact: How much code is affected?
- Risk: What could break?
- Effort: Lines to change, tests needed?
Output Format
🔧 Refactoring Analysis
Target: [file/directory] Lines Analyzed: [count]
📊 SOLID Scorecard
| Principle | Status | Issues Found |
|---|---|---|
| Single Responsibility | 🟡 | 3 large classes |
| Open/Closed | 🟢 | OK |
| Liskov Substitution | 🟢 | OK |
| Interface Segregation | 🔴 | 2 fat interfaces |
| Dependency Inversion | 🟡 | 5 direct instantiations |
🎯 Priority Refactorings
1. [Highest Impact] - Extract class from UserService
Violation: Single Responsibility Current: 450 lines handling auth + profile + notifications Suggested:
UserService.ts (450 lines)
↓ Extract
AuthService.ts (~150 lines)
ProfileService.ts (~150 lines)
NotificationService.ts (~100 lines)
Risk: Medium (update imports) Tests Needed: Update dependency injection in tests
2. [Second Priority] - Replace switch with polymorphism
Location: src/handlers/payment.ts:45
Current:
switch (paymentType) {
case 'card': // 50 lines
case 'bank': // 50 lines
case 'crypto': // 50 lines
}
Suggested: Strategy pattern with PaymentProcessor interface
Risk: Low (isolated change)
📝 Code Smells
| Smell | Location | Severity |
|---|---|---|
| Long Method | api.ts:calculateTotal (120 lines) | 🟠 High |
| Duplicate Code | utils/*.ts (3 similar blocks) | 🟡 Medium |
| Deep Nesting | parser.ts:parse (6 levels) | 🟡 Medium |
🚀 Quick Wins (Low Risk, High Value)
- Extract
validateEmail()to shared utils (used in 4 places) - Replace magic numbers with named constants
- Add early returns to reduce nesting in
processOrder()
⚠️ Technical Debt Notes
- [Item to track for future sprints]
Refactoring Safety Checklist
Before applying suggestions:
- Tests exist for affected code
- Create feature branch
- Commit current state
- Apply one refactoring at a time
- Run tests after each change
- Review diff before committing
Usage
Analyze specific file:
/refactor src/services/user.ts
Analyze directory:
/refactor src/api/
Focus on specific principle:
/refactor --focus=srp src/services/
With complexity threshold:
/refactor --threshold=high
References
- Martin Fowler's Refactoring Catalog
- Clean Code by Robert C. Martin
- SOLID principles by Robert C. Martin
$ARGUMENTS