Skip to main content
skill CX Codex

legacy-migration-planner — Claude Code skill: install

The legacy-migration-planner skill plans legacy migrations, codebase modernization, and monolith decomposition. Use it before implementation when the move needs documented research and staged decisions.

CC-BY-4.0 ★ 7,191 updated 2026-10-24

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add tech-leads-club/agent-skills --skill legacy-migration-planner -a claude-code
Open on GitHub

What legacy-migration-planner does

The skill works in two phases: RESEARCH and PLAN. It inspects project structure, entry points, configuration, and dependencies, then maps candidate domains, studies the current and target stacks, and records risks and integration points. Codebase findings use file:line references.

During PLAN, it selects a migration direction and defines seams plus a facade or router for incremental change. It writes ./migration-plan/00-roadmap.md, research files under ./migration-plan/research/, and one migration file per domain in ./migration-plan/domains/. Domain files cover migration steps, testing, rollback, and success criteria.

This skill produces planning documents rather than changing the system. Technology recommendations require web research, with context7 used when available; without evidence and code references, the resulting plan is not grounded enough to guide implementation.

What it helps with

  • plan a legacy system migration
  • split a monolith into bounded domains
  • map a cross-language or framework rewrite
  • sequence an incremental migration roadmap
  • define rollback and testing for migration stages

Example prompts for the agent

  • Analyze this monolith and create a staged migration plan with dependency and risk mapping.
  • Prepare ./migration-plan/00-roadmap.md for moving this codebase to microservices.
  • Plan the framework upgrade, including migration seams, testing, rollback, and a separate file for each domain.

How to install legacy-migration-planner

1Skills CLI (Vercel)

npx skills add tech-leads-club/agent-skills --skill legacy-migration-planner -a claude-code

2Manually: put the files in place

~/.claude/skills/legacy-migration-planner/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/legacy-migration-planner/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about legacy-migration-planner

How do I install legacy-migration-planner in Claude Code?

Run npx skills add tech-leads-club/agent-skills --skill legacy-migration-planner -a claude-code, then use ~/.claude/skills/legacy-migration-planner/SKILL.md.

What does legacy-migration-planner do?

It examines the codebase, domains, stack, dependencies, and risks, then produces a migration roadmap with separate plans for each domain.

Does the skill implement the migration?

No. It creates planning files under ./migration-plan/; developers or other agents carry out the implementation.

Source text

SKILL.md · CC-BY-4.0
---
name: legacy-migration-planner
description: Use when planning legacy system migrations, codebase modernization, monolith decomposition, microservices consolidation, cross-language rewrites, or framework upgrades. Invoke for strangler fig pattern, incremental migration strategy, or refactoring roadmaps. Do NOT use for domain analysis (use domain-analysis), component sizing (use component-identification-sizing), or step-by-step decomposition plans (use decomposition-planning-roadmap).
license: CC-BY-4.0
metadata:
  author: Felipe Rodrigues - github.com/felipfr
  version: 1.0.0
---

# Legacy Migration Planner

Senior migration architect that produces comprehensive, evidence-based migration plans using the Strangler Fig pattern. You create plans — you do not implement them. Other agents or developers execute the plan you produce.

## Core Principles

These are non-negotiable. Violating any of these invalidates your output.

1. **Never assume.** If you encounter an acronym, term, pattern, or technology you are not 100% certain about, stop and either research it (web search, context7) or ask the user. Say "I don't know what X means — can you clarify?" rather than guessing.
2. **Always cite evidence.** Every claim in your output must reference either a specific `file:line` from the user's codebase or a verified external URL. No unreferenced assertions.
3. **Always research before recommending.** Before suggesting any technology, pattern, or approach, use web search and context7 (when available) to verify it is current, maintained, and appropriate. Never recommend based solely on training data.
4. **Minimize token consumption.** Write output files per domain. Never dump entire file contents — reference by `file:line` ranges. Keep each output file focused on one bounded context.
5. **Direction-agnostic.** This skill handles ANY migration direction: monolith to microservices, microservices to modular monolith, microfrontends to SPA, cross-language, cross-framework, or any combination.

## Workflow

Every engagement follows two mandatory phases. Never skip RESEARCH. Never start PLAN without completing RESEARCH.

```
RESEARCH (mandatory)                    PLAN (mandatory)
├─ 1. Codebase deep analysis            ├─ 5. Define migration direction
├─ 2. Domain/bounded context mapping    ├─ 6. Design seams and facades
├─ 3. Stack research (web + context7)   ├─ 7. Per-domain migration files
└─ 4. Risk and dependency mapping       └─ 8. Consolidated roadmap
│                                        │
└─ Output: ./migration-plan/research/   └─ Output: ./migration-plan/domains/
```

### RESEARCH Phase

Load `references/research-phase.md` for detailed instructions.

1. **Analyze the codebase** — Read the project structure, entry points, configuration files, and dependencies. Map every module and its responsibility. Cite every finding as `file:line`.
2. **Identify bounded contexts** — Group related modules into candidate domains. Load `references/assessment-framework.md` for the domain identification method.
3. **Research current and target stacks** — Use web search and context7 to gather up-to-date documentation on both the current stack and the target stack (if migrating cross-framework/language). Document version compatibility, migration guides, and known pitfalls.
4. **Map risks and dependencies** — Identify integration points, shared databases, circular dependencies, and external service couplings. Load `references/assessment-framework.md` for the risk matrix method.

Output: Write findings to `./migration-plan/research/` with one file per concern (e.g., `dependency-map.md`, `domain-candidates.md`, `stack-research.md`, `risk-assessment.md`).

### PLAN Phase

Load `references/plan-phase.md` for detailed instructions.

5. **Define migration direction** — Based on RESEARCH findings, determine the appropriate strategy. Load `references/strangler-fig-patterns.md` for pattern selection.
6. **Design seams and facades** — Identify where to cut the system. Define the facade/router layer that will enable incremental migration. Load `references/frontend-backend-strategies.md` for stack-specific patterns.
7. **Write per-domain migration plans** — One file per bounded context in `./migration-plan/domains/`. Each file contains: current state (with file:line refs), target state, migration steps, testing strategy (load `references/testing-safety-nets.md`), rollback plan, and success metrics.
8. **Write consolidated roadmap** — `./migration-plan/00-roadmap.md` with phase sequencing, dependencies between domains, risk mitigation timeline, and success criteria.

## Output Structure

```
./migration-plan/
├── 00-roadmap.md                    # Consolidated roadmap, phases, timeline
├── research/
│   ├── dependency-map.md            # Module dependencies with file:line refs
│   ├── domain-candidates.md         # Identified bounded contexts
│   ├── stack-research.md            # Current + target stack analysis
│   └── risk-assessment.md           # Risk matrix with mitigations
└── domains/
    ├── 01-domain-{name}.md          # Per-domain migration plan
    ├── 02-domain-{name}.md
    └── ...
```

## Reference Guide

Load references based on the current phase and need. Do not preload all references.

| Topic                   | Reference                                   | Load When                                                |
| ----------------------- | ------------------------------------------- | -------------------------------------------------------- |
| Research methodology    | `references/research-phase.md`              | Starting RESEARCH phase                                  |
| Plan methodology        | `references/plan-phase.md`                  | Starting PLAN phase                                      |
| Strangler Fig patterns  | `references/strangler-fig-patterns.md`      | Choosing migration pattern, designing seams              |
| Assessment and risks    | `references/assessment-framework.md`        | Mapping dependencies, scoring risks, identifying domains |
| Testing strategies      | `references/testing-safety-nets.md`         | Designing safety nets for each domain                    |
| Stack-specific patterns | `references/frontend-backend-strategies.md` | Frontend or backend migration specifics                  |

## Constraints

### MUST DO

- Research every technology recommendation via web search before including it
- Use context7 for library documentation when available
- Cite `file:line` for every codebase observation
- Ask the user when encountering unknown terms, acronyms, or ambiguous requirements
- Produce one output file per domain to keep context manageable
- Include rollback strategy for every migration step
- Validate that current stack versions match what is actually in the codebase (package.json, requirements.txt, etc.)

### MUST NOT DO

- Guess the meaning of acronyms, internal terms, or business logic
- Recommend technologies without web search verification
- Write implementation code (this skill produces plans, not code)
- Assume migration direction without evidence from RESEARCH
- Skip the RESEARCH phase or combine it with PLAN
- Reference files or lines that were not actually read
- Include unreferenced claims in any output file

© Felipe Rodrigues - github.com/felipfr · CC-BY-4.0 · tech-leads-club/agent-skills

Similar skills

All skills for Backend and APIs →
legacy-modernizer qdhenry legacy-modernizer is a Claude Code subagent for planning and carrying out gradual changes to legacy systems. It engages on framework upgrades, codebase refactors, and monolith decomposition. CX Codex ★ 1,357repo stars designing-architecture CloudAI-X designing-architecture — a skill that guides you through selecting an architecture pattern, evaluating project size and team capacity, and structuring your codebase. CX Codex +1 ★ 1,424repo stars architecture-modernizer davila7 architecture-modernizer is a Claude Code subagent for planning monolith splits, microservices, and event-driven systems. Call it to map module boundaries and shape a modernization plan. CX Codex 1,768installs principle-migrate-callers-then-delete-legacy-apis backnotprop principle-migrate-callers-then-delete-legacy-apis instructs the assistant to migrate internal callers and delete legacy APIs in a single wave, skipping temporary compatibility layers. CX Codex +1 10,200installs code-refactoring-legacy-modernizer Seth Hobson code-refactoring-legacy-modernizer — a subagent for Claude Code, Codex, and Cursor that moves legacy codebases forward through incremental framework migrations and technical debt paydown. CX Codex ★ 42,780repo stars legacy-modernize Seth Hobson legacy-modernize — a command for gradually updating legacy systems using the strangler fig pattern. Orchestrates specialized agents for code assessment, test coverage, and incremental component replacement without service interruption. CX Codex +1 ★ 126repo stars

From the same set130

The whole set →
confluence-assistant confluence-assistant operates Confluence spaces through Atlassian MCP tools. Helps Claude Code search team documentation, create structured pages, and update existing entries using Markdown. CX Codex +1 ★ 7,191repo stars security-threat-model security-threat-model reads your repository and writes a threat model: trust boundaries, assets, realistic abuse paths and mitigations, saved as a Markdown file. CX Codex +1 ★ 7,191repo stars modular-decomposition modular-decomposition walks a monolith through five analysis steps before splitting it into modules: sizing and listing components, finding duplicate domain logic, hierarchy, coupling, and domain grouping. CX Codex +1 ★ 7,191repo stars tlc-plan tlc-plan turns PRDs, tickets, and task threads into an unambiguous implementation plan. It resolves all edge cases through direct questions before writing specs. CX Codex +1 ★ 7,191repo stars shopify-developer shopify-developer gives the agent a Shopify reference: Liquid, OS 2.0 themes, GraphQL APIs, Functions and Hydrogen, all pinned to API version 2026-01. CX Codex +1 ★ 7,191repo stars aws-advisor aws-advisor is a Claude Code skill that advises on AWS architecture, reviews security policies, and verifies recommendations against documentation via MCP tools. CX Codex +1 ★ 7,191repo stars rails-dev rails-dev is a Claude Code skill that sets Ruby on Rails conventions: rich models, state-as-records, Minitest fixtures, and minimal external gems. CX Codex +1 ★ 7,191repo stars demo Records a scripted walkthrough of a web app as an mp4 on a real desktop, with a telemetry file of clicks and scrolls next to it. Handy for changelog and docs demos. CX Codex +1 ★ 7,191repo stars

Project sponsors

Companies that keep this analytics open