Engineering LegacyMigrationStrangler Fig

Legacy Modernizer

Legacy code modernization: strangler fig pattern, incremental migration strategies, dependency upgrades, framework migration paths, and rewrite risk assessment.

A legacy modernization expert who assesses rewrite versus migrate risk honestly, designs strangler fig facades to extract functionality incrementally, and guides teams through framework migrations (AngularJS → Angular, Class Components → Hooks, Python 2 → 3) with automated tooling and characterization tests. Avoids big-bang rewrites and focuses on shipping value at each migration step.

Added Mar 20, 2026

$npx skills add johnefemer/skillfish --skill legacy-modernizer

Capabilities Real Examples Get Started Models & Context Works Great With

What This Skill Can Do

Concrete capabilities you get when you install this skill.

Assess rewrite vs. incremental migration risk with a structured decision framework

Apply the strangler fig pattern to extract modules behind a routing facade

Write characterization tests to lock existing behavior before refactoring

Automate migrations with codemods: jscodeshift, ast-grep, OpenRewrite

Plan and execute framework migrations with backward-compatible intermediary steps

Prioritize migration targets by business value, defect rate, and change frequency

Real Conversations

See how the Legacy Modernizer skill responds to actual requests. These are representative examples of what your AI agent will produce.

You

We have a large AngularJS (1.x) app that we need to migrate to Angular 17+. A full rewrite would take 18 months. Is there an incremental path?

Agent

Yes — use Angular's official ngUpgrade library to run both frameworks simultaneously. You migrate component by component while shipping features throughout.

The hybrid bootstrapping approach:

// main.ts — bootstrap Angular with UpgradeModule
import { UpgradeModule } from '@angular/upgrade/static';

@NgModule({
  imports: [BrowserModule, UpgradeModule],
})
export class AppModule {
  constructor(private upgrade: UpgradeModule) {}
  ngDoBootstrap() {
    this.upgrade.bootstrap(document.body, ['legacyApp']); // boots AngularJS
  }
}

Migration sequence (leaf components first):

Pick a leaf component (no dependencies on other AngularJS directives)
Write it in Angular as a standalone component
Downgrade it so AngularJS can use it:

import { downgradeComponent } from '@angular/upgrade/static';

// AngularJS module registers the Angular component as a directive
angular.module('legacyApp').directive(
  'newButtonComponent',
  downgradeComponent({ component: ButtonComponent })
);

Replace the old AngularJS directive with the new component in templates
Delete the old directive once all usages are replaced
Repeat up the component tree

What to migrate first (in order):

Shared UI components (buttons, inputs, tables) — used everywhere, high payoff
Services — upgrade Angular services and downgrade for AngularJS use
Route by route — once a route's components are all Angular, cut the whole route

Reality check: This works well for apps up to ~500 components. For 2,000+ components, evaluate a parallel build approach where the new app is built alongside and traffic is gradually shifted via a feature flag.

You

Our 10-year-old PHP 5.6 monolith handles e-commerce for a $50M/year business. The team wants to rewrite in Node.js. How do we decide whether to rewrite or migrate incrementally?

Agent

This decision is one of the highest-stakes technical choices you'll make. Here's an honest framework:

Signals that favor incremental migration (strangler fig):

The business is generating revenue and cannot tolerate 6+ months of feature freeze
The existing system has undocumented business logic (PHP 5.6 always does)
The team doesn't have deep experience with the new stack yet
Your test coverage is <30% (no safety net for a rewrite)

Signals that favor a rewrite:

The data model is so corrupt that migration ETL would be more work than the rewrite
The codebase has <5,000 lines and is mostly CRUD with well-understood behavior
The technology gap is a security liability (PHP 5.6 has no security support)

For your situation, I'd recommend strangler fig:

Phase 1 (months 1-3): Routing facade
  Nginx routes new endpoints → Node.js
             old endpoints → PHP 5.6
  Deploy both stacks behind one domain

Phase 2 (months 3-9): Extract high-value services first
  - Product catalog (read-heavy, easy to cache)
  - Customer authentication (security priority given PHP 5.6)
  - Order placement (highest business risk — do last)

Phase 3 (months 9-18): Extract checkout and payments
  - Highest complexity, highest risk — do this after team has Node.js production experience

Phase 4: Sunset PHP when it handles <5% of traffic

The PHP 5.6 security risk is urgent: Before the migration produces results, upgrade to PHP 8.x as a stopgap. PHP 5.6 has known unpatched CVEs. This is a 2-week project and buys you time to migrate properly.

Full rewrite timelines are always 2–3x the initial estimate for a $50M system. Strangler fig ships value to users in month 3, not month 18.

Get Started

How to install and use this skill in your preferred environment.

Skills are designed for AI coding agents (Claude Code, Cursor, Windsurf) and IDE-based workflows where the agent can read files, run scripts, and act on your codebase.

Models & Context

Which AI models and context windows work best with this skill.

Recommended Models

Claude Sonnet 4 or GPT-4o for migration strategy reasoning. Framework-specific migration tooling (ngUpgrade, jscodeshift) changes frequently — verify API versions before generating migration scripts.

Context Window

SKILL.md ~4KB. Full migration planning sessions with architecture diagrams benefit from 64K+ context.

Pro tips for best results

1

Be specific

Include numbers — users, budget, RPS — so the skill can size the architecture.

2

Share constraints

Compliance needs, team size, and existing stack all improve the output.

3

Iterate

Start with a high-level design, then ask follow-ups for IaC, cost analysis, or security review.

4

Combine skills

Pair with companion skills below for end-to-end coverage.

Works Great With

These skills complement Legacy Modernizer for end-to-end coverage. Install them together for better results.

Migration Architect

Migration planning, compatibility checking, and rollback generation.

MigrationPlanning

Tech Debt Tracker

Codebase debt scanner, prioritizer, and trend dashboard.

Tech DebtQuality

Senior Architect

System architecture design, dependency analysis, and technical decisions.

ArchitectureDesign

Refactoring Specialist

Systematic refactoring: code smell identification, refactoring patterns catalog, safe refactoring workflows with tests, IDE automation, and quality measurement.

RefactoringCode Smells

$ skillfish add johnefemer/skillfish --all # install all skills at once

Ready to try Legacy Modernizer?

Install the skill and start getting expert-level guidance in your workflow — any agent, any IDE.