rewrite-planner

Plan incremental component rewrites using the strangler fig pattern.

Updated May 6, 2026

Search Tags:#migration #incremental development #strangler fig #stack migration #component rewrite

Ready to run

npx skills add https://github.com/crgarcia12/compy --skill rewrite-planner-crgarcia12

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: rewrite-planner
Source: https://github.com/crgarcia12/compy/tree/main/.github/skills/rewrite-planner
Command: npx skills add https://github.com/crgarcia12/compy --skill rewrite-planner-crgarcia12

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill helps in planning a component-by-component rewrite from one stack to another, using the strangler fig pattern. It ensures a smooth transition with minimal downtime.

Core Features & Use Cases

Component-by-Component Rewrite: Incrementally rewrite components while keeping the rest running.
Strangler Fig Pattern: Guides the process with a facade or routing layer directing traffic.
Dependency Ordering: Prioritizes components based on dependencies for a safe migration.
Data Migration: Plans data movement from old to new components.
Integration Shim: Facilitates coexistence of old and new components.
Cutover Criteria: Defines conditions for decommissioning old components.
Behavioral Deltas: Tracks changes in behavior for testing and documentation.

Quick Start

Generate a rewrite plan for migrating your application from Express to Fastify using the rewrite-planner skill.

Frequently Asked Questions about rewrite-planner

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I plan an incremental stack migration without downtime?▼

Incremental stack migration uses the strangler fig pattern to rewrite components one by one behind a routing facade, directing traffic to new components while the old system continues running. This ensures a smooth transition with minimal downtime.

What is the strangler fig pattern for component rewrites?▼

The strangler fig pattern incrementally replaces legacy components by routing traffic through a facade to new implementations. It assesses component boundaries, orders rewrites by dependency, and defines coexistence and cutover strategies for safe decommissioning.

How do I order component rewrites during a stack migration?▼

Ordering component rewrites requires prioritizing based on dependency analysis to ensure safe migration. By assessing component boundaries and existing codebase architecture, you can sequence rewrites to prevent breaking downstream dependencies during the transition.

Do I need existing architecture and ADRs to plan a component rewrite?▼

Planning a component rewrite requires analysis of existing architecture, ADRs, and the current codebase. This analysis is necessary to assess component boundaries, define mappings, and accurately outline coexistence and cutover strategies for the migration.

What's the best way to handle data migration between old and new components?▼

Handling data migration involves planning data movement from old to new components using an integration shim. This shim facilitates coexistence while tracking behavioral deltas to ensure data consistency and accurate testing during the cutover process.

When should I decommission old components during a stack migration?▼

Old components should be decommissioned once defined cutover criteria are met. These criteria establish the exact conditions for safely retiring legacy code after verifying that new components fully handle the expected traffic and behavioral requirements.