legacy-modernizer

$2a

Reference Guide

Load detailed guidance based on context:

Topic

Reference

Load When

Strangler Fig

references/strangler-fig-pattern.md

Incremental replacement, facade layer, routing

Refactoring

references/refactoring-patterns.md

Extract service, branch by abstraction, adapters

Migration

references/migration-strategies.md

Database, UI, API, framework migrations

Testing

references/legacy-testing.md

Characterization tests, golden master, approval

Assessment

references/system-assessment.md

Code analysis, dependency mapping, risk evaluation

Code Examples

Strangler Fig Facade (Python)

# facade.py — routes requests to legacy or new service based on a feature flag

import os

from legacy_service import LegacyOrderService

from new_service import NewOrderService

class OrderServiceFacade:

    def __init__(self):

        self._legacy = LegacyOrderService()

        self._new = NewOrderService()

    def get_order(self, order_id: str):

        if os.getenv("USE_NEW_ORDER_SERVICE", "false").lower() == "true":

            return self._new.fetch(order_id)

        return self._legacy.get(order_id)

Feature Flag Wrapper

# feature_flags.py — thin wrapper around an environment or config-based flag store

import os

def flag_enabled(flag_name: str, default: bool = False) -> bool:

    """Check whether a migration feature flag is active."""

    return os.getenv(flag_name, str(default)).lower() == "true"

# Usage

if flag_enabled("USE_NEW_PAYMENT_GATEWAY"):

    result = new_gateway.charge(order)

else:

    result = legacy_gateway.charge(order)

Characterization Test Template (pytest)

# test_characterization_orders.py

# Captures existing legacy behavior as a golden-master safety net.

import pytest

from legacy_service import LegacyOrderService

service = LegacyOrderService()

@pytest.mark.parametrize("order_id,expected_status", [

    ("ORD-001", "SHIPPED"),

    ("ORD-002", "PENDING"),

    ("ORD-003", "CANCELLED"),

])

def test_order_status_golden_master(order_id, expected_status):

    """Fail loudly if legacy behavior changes unexpectedly."""

    result = service.get(order_id)

    assert result["status"] == expected_status, (

        f"Characterization broken for {order_id}: "

        f"expected {expected_status}, got {result['status']}"

    )

Constraints

MUST DO

• Maintain zero production disruption during all migrations

• Create comprehensive test coverage before refactoring (target 80%+)

• Use feature flags for all incremental rollouts

• Implement monitoring and rollback procedures

• Document all migration decisions and rationale

• Preserve existing business logic and behavior

• Communicate progress and risks transparently

MUST NOT DO

• Big bang rewrites or replacements

• Skip testing legacy behavior before changes

• Deploy without rollback capability

• Break existing integrations or APIs

• Ignore technical debt in new code

• Rush migrations without proper validation

• Remove legacy code before new code is proven

Output Templates

When implementing modernization, provide:

• Assessment summary (risks, dependencies, approach)

• Migration plan (phases, rollback strategy, metrics)

• Implementation code (facades, adapters, new services)

• Test coverage (characterization, integration, e2e)

• Monitoring setup (metrics, alerts, dashboards)

Knowledge Reference

Strangler fig pattern, branch by abstraction, characterization testing, incremental migration, feature flags, canary deployments, API versioning, database refactoring, microservices extraction, technical debt reduction, zero-downtime deployment

Documentation