What is the strangler fig pattern in this context?

A phased migration approach that progressively replaces parts of a monolith with new services while routing traffic to both during the transition.

How are rollbacks automated?

Rollback triggers are defined in the orchestration layer and actions are automated to restore previous routing weights, feature flags, and state while preserving recovery data.

How is progress tracked and reported?

Progress is tracked via the orchestration payload (migration, routing, progress, rollback) and exposed through dashboards and logs for visibility.

strangler-fig-orchestrator

npx machina-cli add skill a5c-ai/babysitter/strangler-fig-orchestrator --openclaw

Files (1)

SKILL.md

2.5 KB

Strangler Fig Orchestrator Skill

Orchestrates the strangler fig pattern implementation for gradual migration from legacy to modern systems with traffic routing and cutover management.

Purpose

Enable incremental migration for:

Traffic routing configuration
Feature flag management
Gradual cutover orchestration
Rollback coordination
Legacy component sunset

Capabilities

1. Traffic Routing Configuration

Configure API gateway rules
Set up routing weights
Handle header-based routing
Manage path-based routing

2. Feature Flag Management

Create feature flags
Control rollout percentage
Manage user segments
Handle A/B testing

3. Gradual Cutover Orchestration

Plan cutover phases
Execute incremental shifts
Monitor health metrics
Coordinate teams

4. Rollback Coordination

Define rollback triggers
Automate rollback
Preserve state
Document recovery

5. Progress Tracking

Track migration progress
Monitor adoption rates
Report on status
Visualize timeline

6. Legacy Component Sunset

Plan decommissioning
Verify no traffic
Archive data
Clean up resources

Tool Integrations

Tool	Purpose	Integration Method
API Gateways	Traffic routing	Config/API
LaunchDarkly	Feature flags	API
Split.io	Feature management	API
Consul	Service mesh	API
Istio	Traffic management	Config

Output Schema

{
  "orchestrationId": "string",
  "timestamp": "ISO8601",
  "migration": {
    "legacy": {
      "system": "string",
      "endpoints": []
    },
    "modern": {
      "system": "string",
      "endpoints": []
    }
  },
  "routing": {
    "strategy": "string",
    "rules": [],
    "currentWeights": {}
  },
  "progress": {
    "phase": "string",
    "percentMigrated": "number",
    "remainingEndpoints": []
  },
  "rollback": {
    "available": "boolean",
    "lastCheckpoint": "string"
  }
}

Integration with Migration Processes

monolith-to-microservices: Gradual extraction
legacy-decommissioning: Sunset planning

Related Skills

api-compatibility-analyzer: Contract verification

Related Agents

strangler-implementation-agent: Implementation
microservices-decomposer: Service extraction

Source

git clone https://github.com/a5c-ai/babysitter/blob/main/plugins/babysitter/skills/babysit/process/specializations/code-migration-modernization/skills/strangler-fig-orchestrator/SKILL.md

View on GitHub

Overview

Orchestrates strangler fig-based migration from legacy to modern systems by coordinating traffic routing, feature flag rollout, and phased cutovers. It supports rollback, progress tracking, and sunset planning for legacy components, ensuring a safe, auditable transition.

How This Skill Works

It configures API gateway routing (weights, headers, and path rules), integrates with flag tools (LaunchDarkly, Split.io), and manages gradual shifts. It emits a structured orchestration payload (migration, routing, progress, rollback) to guide automation and auditing.

When to Use It

Starting a legacy-to-modern migration where traffic can be split using canary or weighted routing
Coordinating phased cutover with defined rollback triggers and health monitors
Running feature-flag driven experiments during migration to compare modern vs legacy behavior
Sunsetting legacy components with verified no traffic remaining and data archival
Orchestrating monolith-to-microservices migration with API gateways and service meshes

Quick Start

Step 1: Define legacy and modern endpoints and identify cutover phases
Step 2: Configure routing strategy (weights, headers, paths) and feature flags
Step 3: Initiate gradual cutover, monitor health metrics, and respond to alerts

Best Practices

Define clear cutover phases and success criteria before starting
Align routing weights with feature flag rollout and monitoring goals
Automate rollback triggers and preserve essential state for recovery
Maintain a real-time progress dashboard and auditable logs
Verify traffic no longer reaches sunset components before decommissioning

Example Use Cases

Monolith-to-microservices migration with Istio routing and gradual service extraction
Legacy API sunset managed via API gateway weights and header-based routing
Feature-flag controlled A/B tests during migration using LaunchDarkly
Service mesh-based gradual rollback coordination in a critical API
End-to-end migration plan with Split.io managed feature flags and monitoring

Frequently Asked Questions

Add this skill to your agents