Jeffallan/claude-skills / skills/legacy-modernizer
legacy-modernizer
VerifiedDesigns incremental migration strategies, identifies service boundaries, produces dependency maps and migration roadmaps, and generates API facade designs for aging codebases. Use when modernizing legacy systems, implementing strangler fig pattern or branch by abstraction, decomposing monoliths, upgrading frameworks or languages, or reducing technical debt without disrupting business operations.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 6.1 KB |
| references/legacy-testing.md | markdown | 11.2 KB |
| references/migration-strategies.md | markdown | 11.5 KB |
| references/refactoring-patterns.md | markdown | 11.9 KB |
| references/strangler-fig-pattern.md | markdown | 8.2 KB |
| references/system-assessment.md | markdown | 14.8 KB |
references/system-assessment.md
View on GitHub# System Assessment
## Codebase Analysis Checklist
```python
# Automated assessment script
from pathlib import Path
import ast
import re
from collections import defaultdict
class LegacyCodeAnalyzer:
def __init__(self, codebase_path: Path):
self.path = codebase_path
self.metrics = defaultdict(int)
self.issues = []
def analyze(self):
"""Run comprehensive analysis"""
self.count_lines_of_code()
self.analyze_dependencies()
self.find_code_smells()
self.check_test_coverage()
self.identify_hotspots()
return self.generate_report()
def count_lines_of_code(self):
"""Basic size metrics"""
for py_file in self.path.rglob("*.py"):
with open(py_file) as f:
lines = f.readlines()
self.metrics['total_lines'] += len(lines)
self.metrics['files'] += 1
# Count code vs comments
code_lines = [l for l in lines if l.strip() and not l.strip().startswith('#')]
self.metrics['code_lines'] += len(code_lines)
def analyze_dependencies(self):
"""Find external and internal dependencies"""
dependencies = set()
for py_file in self.path.rglob("*.py"):
with open(py_file) as f:
tree = ast.parse(f.read())
for node in ast.walk(tree):
if isinstance(node, ast.Import):
for alias in node.names:
dependencies.add(alias.name.split('.')[0])
elif isinstance(node, ast.ImportFrom):
if node.module:
dependencies.add(node.module.split('.')[0])
self.metrics['dependencies'] = len(dependencies)
self.dependencies = dependencies
def find_code_smells(self):
"""Detect common legacy code issues"""
for py_file in self.path.rglob("*.py"):
with open(py_file) as f:
content = f.read()
tree = ast.parse(content)
# Long functions
for node in ast.walk(tree):
if isinstance(node, ast.FunctionDef):
func_length = node.end_lineno - node.lineno
if func_length > 50:
self.issues.append({
'type': 'long_function',
'file': str(py_file),
'function': node.name,
'lines': func_length,
})
# Global variables
if re.search(r'^[A-Z_]+ = ', content, re.MULTILINE):
self.metrics['global_vars'] += len(
re.findall(r'^[A-Z_]+ = ', content, re.MULTILINE)
)
# SQL in code (sign of tight coupling)
if re.search(r'(SELECT|INSERT|UPDATE|DELETE)\s+', content, re.IGNORECASE):
self.metrics['raw_sql'] += 1
self.issues.append({
'type': 'raw_sql',
'file': str(py_file),
})
def check_test_coverage(self):
"""Calculate test coverage"""
test_files = list(self.path.rglob("test_*.py"))
self.metrics['test_files'] = len(test_files)
self.metrics['test_coverage_estimate'] = (
len(test_files) / max(self.metrics['files'], 1) * 100
)
def identify_hotspots(self):
"""Find files changed most often (requires git)"""
import subprocess
try:
result = subprocess.run(
['git', 'log', '--format=format:', '--name-only'],
cwd=self.path,
capture_output=True,
text=True,
)
file_changes = defaultdict(int)
for line in result.stdout.split('\n'):
if line.strip():
file_changes[line.strip()] += 1
# Top 10 changed files
self.hotspots = sorted(
file_changes.items(),
key=lambda x: x[1],
reverse=True
)[:10]
except Exception:
self.hotspots = []
def generate_report(self):
"""Generate assessment report"""
return {
'summary': {
'total_files': self.metrics['files'],
'total_lines': self.metrics['total_lines'],
'code_lines': self.metrics['code_lines'],
'dependencies': self.metrics['dependencies'],
'test_coverage_estimate': f"{self.metrics['test_coverage_estimate']:.1f}%",
},
'issues': {
'long_functions': len([i for i in self.issues if i['type'] == 'long_function']),
'raw_sql_usage': self.metrics['raw_sql'],
'global_variables': self.metrics['global_vars'],
},
'hotspots': self.hotspots,
'detailed_issues': self.issues[:20], # Top 20 issues
}
# Usage
analyzer = LegacyCodeAnalyzer(Path('./legacy_app'))
report = analyzer.analyze()
print(json.dumps(report, indent=2))
```
## Dependency Analysis
```python
# Identify circular dependencies and tight coupling
import subprocess
import json
from pathlib import Path
from collections import defaultdict
def analyze_dependencies(project_path: Path):
"""Map internal module dependencies"""
dependencies = defaultdict(set)
for py_file in project_path.rglob("*.py"):
module_name = str(py_file.relative_to(project_path)).replace('/', '.').replace('.py', '')
with open(py_file) as f:
tree = ast.parse(f.read())
for node in ast.walk(tree):
if isinstance(node, ast.ImportFrom):
if node.module and not node.module.startswith('.'):
# Internal imports only
if node.module.split('.')[0] in ['app', 'lib', 'models']:
dependencies[module_name].add(node.module)
return dependencies
def find_circular_dependencies(dependencies: dict):
"""Detect circular dependencies"""
circular = []
def has_path(start, end, visited=None):
if visited is None:
visited = set()
if start == end:
return True
if start in visited:
return False
visited.add(start)
for dep in dependencies.get(start, []):
if has_path(dep, end, visited):
return True
return False
for module, deps in dependencies.items():
for dep in deps:
if has_path(dep, module):
circular.append((module, dep))
return circular
# Visualize dependency graph
def generate_dependency_graph(dependencies: dict, output_file: str):
"""Generate GraphViz diagram"""
dot_lines = ["digraph dependencies {"]
for module, deps in dependencies.items():
for dep in deps:
dot_lines.append(f' "{module}" -> "{dep}";')
dot_lines.append("}")
Path(output_file).write_text('\n'.join(dot_lines))
print(f"Generated {output_file} - render with: dot -Tpng {output_file} -o deps.png")
```
## Technical Debt Calculation
```python
from datetime import datetime, timedelta
class TechnicalDebtCalculator:
"""Calculate technical debt using SQALE method"""
SEVERITY_MULTIPLIERS = {
'critical': 1.0, # 1 day to fix
'major': 0.5, # 4 hours
'minor': 0.25, # 2 hours
'info': 0.1, # 30 min
}
def __init__(self):
self.debt_items = []
def add_issue(self, issue_type: str, severity: str, count: int = 1):
"""Add technical debt item"""
days_to_fix = self.SEVERITY_MULTIPLIERS[severity] * count
self.debt_items.append({
'type': issue_type,
'severity': severity,
'count': count,
'effort_days': days_to_fix,
})
def calculate_total_debt(self):
"""Calculate total remediation effort"""
total_days = sum(item['effort_days'] for item in self.debt_items)
return {
'total_days': round(total_days, 1),
'total_weeks': round(total_days / 5, 1),
'estimated_cost': round(total_days * 800, 2), # $800/day avg
'breakdown': self.debt_items,
}
# Usage based on code analysis
debt_calc = TechnicalDebtCalculator()
# From static analysis results
debt_calc.add_issue('long_functions', 'major', count=45)
debt_calc.add_issue('circular_dependencies', 'critical', count=8)
debt_calc.add_issue('missing_tests', 'major', count=120)
debt_calc.add_issue('security_vulnerabilities', 'critical', count=12)
debt_calc.add_issue('deprecated_dependencies', 'major', count=15)
debt_calc.add_issue('code_duplication', 'minor', count=89)
report = debt_calc.calculate_total_debt()
# Output: ~95 days of work, ~19 weeks, ~$76,000
```
## Risk Assessment Matrix
```python
from enum import Enum
class Risk(Enum):
LOW = 1
MEDIUM = 2
HIGH = 3
CRITICAL = 4
class RiskAssessment:
def __init__(self):
self.risks = []
def assess(self, area: str, impact: Risk, probability: Risk, mitigation: str):
"""Assess risk for modernization area"""
risk_score = impact.value * probability.value
self.risks.append({
'area': area,
'impact': impact.name,
'probability': probability.name,
'score': risk_score,
'severity': self._get_severity(risk_score),
'mitigation': mitigation,
})
def _get_severity(self, score: int) -> str:
if score >= 12:
return 'CRITICAL'
elif score >= 8:
return 'HIGH'
elif score >= 4:
return 'MEDIUM'
else:
return 'LOW'
def get_prioritized_risks(self):
"""Return risks sorted by severity"""
return sorted(self.risks, key=lambda r: r['score'], reverse=True)
# Example risk assessment
risks = RiskAssessment()
risks.assess(
area="Database migration",
impact=Risk.CRITICAL,
probability=Risk.MEDIUM,
mitigation="Implement dual-write pattern with comprehensive monitoring"
)
risks.assess(
area="Authentication system upgrade",
impact=Risk.CRITICAL,
probability=Risk.LOW,
mitigation="Shadow testing in production, feature flags for rollback"
)
risks.assess(
area="UI framework migration",
impact=Risk.MEDIUM,
probability=Risk.MEDIUM,
mitigation="Incremental component replacement, A/B testing"
)
risks.assess(
area="Legacy API deprecation",
impact=Risk.HIGH,
probability=Risk.HIGH,
mitigation="12-month sunset period, client migration support, versioning"
)
for risk in risks.get_prioritized_risks():
print(f"{risk['severity']}: {risk['area']}")
```
## Modernization Roadmap Template
```python
from dataclasses import dataclass
from datetime import date, timedelta
from typing import List
@dataclass
class MigrationPhase:
name: str
description: str
duration_weeks: int
dependencies: List[str]
success_metrics: dict
rollback_plan: str
class ModernizationRoadmap:
def __init__(self, start_date: date):
self.start_date = start_date
self.phases = []
def add_phase(self, phase: MigrationPhase):
self.phases.append(phase)
def generate_timeline(self):
"""Generate week-by-week timeline"""
timeline = []
current_date = self.start_date
for phase in self.phases:
end_date = current_date + timedelta(weeks=phase.duration_weeks)
timeline.append({
'phase': phase.name,
'start': current_date.isoformat(),
'end': end_date.isoformat(),
'duration_weeks': phase.duration_weeks,
'dependencies': phase.dependencies,
})
current_date = end_date
return timeline
# Example roadmap
roadmap = ModernizationRoadmap(start_date=date(2024, 1, 1))
roadmap.add_phase(MigrationPhase(
name="Assessment & Planning",
description="Code analysis, dependency mapping, risk assessment",
duration_weeks=2,
dependencies=[],
success_metrics={'assessment_complete': True, 'roadmap_approved': True},
rollback_plan="N/A - planning phase"
))
roadmap.add_phase(MigrationPhase(
name="Test Coverage",
description="Build characterization tests for critical paths",
duration_weeks=4,
dependencies=["Assessment & Planning"],
success_metrics={'coverage': '80%', 'characterization_tests': 200},
rollback_plan="Continue with existing tests"
))
roadmap.add_phase(MigrationPhase(
name="Database Migration Setup",
description="Implement dual-write pattern, lazy migration",
duration_weeks=3,
dependencies=["Test Coverage"],
success_metrics={'dual_write_working': True, 'data_consistency': '99.9%'},
rollback_plan="Disable dual-write, continue legacy DB only"
))
roadmap.add_phase(MigrationPhase(
name="Service Extraction - Phase 1",
description="Extract payment service using strangler fig",
duration_weeks=6,
dependencies=["Database Migration Setup"],
success_metrics={'service_deployed': True, 'error_rate': '<0.1%', 'traffic': '100%'},
rollback_plan="Route 100% traffic back to monolith via feature flag"
))
timeline = roadmap.generate_timeline()
```
## Stakeholder Communication Template
```python
# Weekly status report generator
from datetime import datetime
class ModernizationStatusReport:
def __init__(self, week_number: int):
self.week = week_number
self.completed = []
self.in_progress = []
self.blockers = []
self.metrics = {}
def generate_report(self) -> str:
"""Generate stakeholder-friendly report"""
return f"""
# Legacy Modernization - Week {self.week} Status
## Executive Summary
- **Progress**: {self._calculate_progress()}% complete
- **On Track**: {'Yes' if not self.blockers else 'Blocked'}
- **Risk Level**: {self._assess_risk_level()}
## This Week's Accomplishments
{self._format_list(self.completed)}
## In Progress
{self._format_list(self.in_progress)}
## Blockers & Risks
{self._format_list(self.blockers) if self.blockers else '- None'}
## Key Metrics
{self._format_metrics()}
## Next Week's Goals
{self._format_list(self.next_week_goals)}
""".strip()
def _format_list(self, items: list) -> str:
return '\n'.join(f"- {item}" for item in items)
def _format_metrics(self) -> str:
return '\n'.join(f"- {k}: {v}" for k, v in self.metrics.items())
```
## Quick Reference
| Assessment Area | Tools | Output |
|----------------|-------|--------|
| Code Quality | pylint, radon, sonarqube | Complexity, issues |
| Dependencies | pipdeptree, pydeps | Graph, circular deps |
| Technical Debt | SonarQube, CodeClimate | Debt hours, cost |
| Test Coverage | coverage.py, pytest-cov | Percentage, gaps |
| Security | bandit, safety | Vulnerabilities |
| Performance | cProfile, py-spy | Bottlenecks |
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |