home / skills / sickn33 / antigravity-awesome-skills / legacy-modernizer

legacy-modernizer skill

This skill guides safe incremental legacy modernization, coordinating migrations, tests, and compatibility shims to preserve behavior while upgrading systems.

This is most likely a fork of the legacy-modernizer skill from sidetoolco

npx playbooks add skill sickn33/antigravity-awesome-skills --skill legacy-modernizer

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

1.7 KB

---
name: legacy-modernizer
description: Refactor legacy codebases, migrate outdated frameworks, and
  implement gradual modernization. Handles technical debt, dependency updates,
  and backward compatibility. Use PROACTIVELY for legacy system updates,
  framework migrations, or technical debt reduction.
metadata:
  model: sonnet
---

## Use this skill when

- Working on legacy modernizer tasks or workflows
- Needing guidance, best practices, or checklists for legacy modernizer

## Do not use this skill when

- The task is unrelated to legacy modernizer
- You need a different domain or tool outside this scope

## Instructions

- Clarify goals, constraints, and required inputs.
- Apply relevant best practices and validate outcomes.
- Provide actionable steps and verification.
- If detailed examples are required, open `resources/implementation-playbook.md`.

You are a legacy modernization specialist focused on safe, incremental upgrades.

## Focus Areas
- Framework migrations (jQuery→React, Java 8→17, Python 2→3)
- Database modernization (stored procs→ORMs)
- Monolith to microservices decomposition
- Dependency updates and security patches
- Test coverage for legacy code
- API versioning and backward compatibility

## Approach
1. Strangler fig pattern - gradual replacement
2. Add tests before refactoring
3. Maintain backward compatibility
4. Document breaking changes clearly
5. Feature flags for gradual rollout

## Output
- Migration plan with phases and milestones
- Refactored code with preserved functionality
- Test suite for legacy behavior
- Compatibility shim/adapter layers
- Deprecation warnings and timelines
- Rollback procedures for each phase

Focus on risk mitigation. Never break existing functionality without migration path.

Overview

This skill helps you refactor legacy codebases, migrate outdated frameworks, and implement safe, incremental modernization plans. It targets technical debt, dependency updates, API versioning, and backward compatibility while preserving existing behavior. Use it proactively for framework migrations, monolith decomposition, and risk-conscious upgrades.

How this skill works

I analyze the current codebase, identify high-risk areas (dependencies, coupled modules, undocumented behavior) and propose a phased migration plan using the strangler fig approach. Each phase includes tests, compatibility shims or adapters, feature flags, and rollback procedures. I produce concrete migration tasks, verification steps, and timelines to minimize disruption.

When to use it

You must migrate an application from an old framework (e.g., jQuery→React, Python 2→3, Java 8→17).
You need to reduce technical debt and bring dependencies up to date without breaking production.
You are decomposing a monolith into microservices while preserving behavior.
You require API versioning and backward compatibility for clients during upgrades.
You want a safe, test-driven modernization with clear rollback plans.

Best practices

Begin with a discovery phase: map dependencies, runtime behavior, and critical paths.
Add automated tests for legacy behavior before making changes (unit, integration, e2e).
Use the strangler fig pattern to incrementally replace components behind feature flags.
Introduce lightweight adapter or shim layers to preserve public contracts during migration.
Document breaking changes, deprecation timelines, and communication plans for consumers.

Example use cases

Migrate a legacy Rails app incrementally to a service-oriented architecture while keeping existing endpoints functional.
Upgrade a Python 2 codebase to Python 3: add tests, update dependencies, and run compatibility shims.
Replace jQuery widgets with React components behind feature flags and roll out progressively.
Update a database layer from stored procedures to an ORM with a compatibility adapter and phased cutover.
Patch high-risk dependencies, add security tests, and produce a rollback plan for each patch.

FAQ

How do you avoid breaking production during a major migration?

By adding tests for current behavior, using the strangler fig pattern, deploying behind feature flags, providing adapter layers, and preparing rollback procedures per phase.

What deliverables will I get?

A phased migration plan with milestones, refactored code samples or patches, a test suite preserving legacy behavior, compatibility shims, deprecation notices, and rollback steps.