Generated banner for GCP To AWS
Generated logo for GCP To AWS

GCP To AWS

ClineOfficialPublished by Cline

  • Skill
  • Workflow
  • Cloud and DevOps
  • Apache-2.0
  • Low risk

From the author

Migrate workloads from Google Cloud Platform to AWS — including AI and agentic workloads regardless of cloud provider. Triggers on: migrate from GCP, GCP to AWS, move off Google Cloud, migrate Terraform to AWS, migrate Cloud SQL to RDS, migrate GKE to EKS, migrate Cloud Run to Fargate, Google Cloud migration, migrate from OpenAI to Bedrock, move off OpenAI, switch from ChatGPT API to AWS, migrate from Gemini to Bedrock, migrate LangChain to Bedrock, migrate LangGraph to AWS, migrate agentic workloads to AWS, move AI workloads to AWS, migrate my AI app to AWS. Runs a 6-phase process: discover GCP resources from Terraform files, app code, or billing exports, clarify migration requirements, design AWS architecture, estimate costs, generate migration artifacts, and collect optional feedback. Clarify must finish before Design, Estimate, or Generate. Includes AI provider migration guidance (for example, OpenAI to Amazon Bedrock) by selecting closest-fit Bedrock model families for required modality, latency/quality
— the description by Cline

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The gcp-to-aws skill provides a deterministic, multi-phase process to migrate Google Cloud Platform (GCP) workloads to AWS. It supports infrastructure migration via Terraform analysis and AI workload migration by mapping models to Amazon Bedrock. The skill enforces a strict state machine, requiring discovery, clarification, design, estimation, and generation phases to ensure a reliable migration path. It includes specific logic for handling hybrid stacks, AI provider transitions, and complex infrastructure clustering.

What it does

  • Discovers GCP resources from Terraform, application code, or billing data.
  • Clarifies migration requirements through a structured questionnaire.
  • Designs AWS architecture based on GCP workload types and AI model requirements.
  • Estimates costs for the proposed AWS infrastructure and AI services.
  • Generates migration artifacts including Terraform configurations and AI provider adapters.
  • Provides specialized guidance for migrating AI workloads from Gemini or OpenAI to Amazon Bedrock.

When to use it

  • When you need to migrate existing GCP infrastructure to AWS.
  • When you are looking to move AI-driven applications from GCP or OpenAI to Amazon Bedrock.
  • When you have Terraform files or billing exports and need a structured migration plan.
  • When you require a step-by-step, validated approach to re-platforming cloud services.

Advantages

  • Enforces a rigorous, fail-closed state machine to prevent skipped steps.
  • Provides intelligent mapping of GCP services to AWS equivalents.
  • Includes specific logic for AI workload migration and model compatibility.
  • Supports multi-signal discovery using IaC, code, and billing data.
  • Ensures consistent artifact generation through a structured 6-phase process.

Usage examples

“Migrate my GKE and Cloud SQL setup to AWS.”
The agent initiates the discovery phase, analyzing your Terraform files to identify GKE and Cloud SQL resources, then guides you through the clarification and design phases for EKS and RDS.
“I need to move my LangChain app from OpenAI to Bedrock.”
The agent identifies the AI workload, selects the best-fit Bedrock model family, and generates the necessary provider adapters and migration documentation.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/cline/gcp-to-aws/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip gcp-to-aws.zip -d .agents/skills

Documentation by Cline

GCP-to-AWS Migration Skill

Philosophy

  • Re-platform by default: Select AWS services that match GCP workload types (e.g., Cloud Run → Fargate, Cloud SQL → RDS).

  • Dev sizing unless specified: Default to development-tier capacity (e.g., db.t4g.micro, single AZ). Upgrade only on user direction.

  • No human one-time migration costs: Do not present human labor, professional services, or people-time work as dollar estimates or "one-time migration cost" budget categories. Vendor charges grounded in data (for example GCP data transfer egress in the infra estimate when billing exists) are allowed.

  • Multi-signal approach: Design phase adapts based on available inputs — Terraform IaC for infrastructure, billing data for service mapping, and app code for AI workload detection.

  • BigQuery / google_bigquery_*: The skill does not recommend a specific AWS analytics or warehouse service. During Clarify, if discovery shows BigQuery (IaC google_bigquery_* and/or billing rows for BigQuery), you must surface the specialist advisory before Design (see references/phases/clarify/clarify.md). Design output uses Deferred — specialist engagement; keep directing the user to their AWS account team and/or a data analytics migration partner through Design, Estimate, and docs (see references/phases/design/design-infra.md BigQuery specialist gate).


Definitions

  • "Load" = Read the file using the Read tool and follow its instructions. Do not summarize or skip sections.

  • $MIGRATION_DIR = The run-specific directory under .migration/ (e.g., .migration/0226-1430/). Set during Phase 1 (Discover).


Context Loading Rules

Each phase loads reference files on demand. To keep per-turn context manageable and prevent instruction-following degradation:

  • Budget: Each phase should load no more than ~800 lines of instructions (excluding user artifacts like JSON profiles and MCP tool results).

  • Conditional loading: Reference files with trigger conditions (e.g., agentic_profile.is_agentic == true) MUST NOT be loaded unless the condition is met. Do not speculatively load files.

  • No duplication: Model mapping tables, pricing data, and shared warnings exist in one canonical file. Other files reference them; they do not copy them inline.

  • Progressive depth: Phase orchestrators (design.md, generate.md) contain short routing logic that points to detailed sub-files. Load the sub-file only when its path is selected.

Conditional reference files (load ONLY when condition is true):

FileCondition
design-refs/ai-gemini-to-bedrock.mdai-workload-profile.json exists AND summary.ai_source = "gemini" or "both"
design-refs/ai-openai-to-bedrock.mdai-workload-profile.json exists AND summary.ai_source = "openai" or "both"
design-refs/ai-anthropic-to-bedrock.mdai-workload-profile.json exists AND summary.ai_source = "anthropic"
design-refs/ai.mdai-workload-profile.json exists AND summary.ai_source = "other"
design-refs/design-ref-harness.mdagentic_profile.is_agentic == true AND ai_constraints.agentic.migration_approach == "harness"
design-refs/design-ref-agentic-to-agentcore.mdagentic_profile.is_agentic == true AND ai_constraints.agentic.migration_approach == "strands"
shared/retarget-gotchas.mdagentic_profile.is_agentic == true AND ai_constraints.agentic.migration_approach == "retarget"

When adding new reference files, verify the phase's total loaded instructions remain under budget. If a new file would exceed ~800 lines when combined with other loaded refs, split it or make it conditional.

Hybrid stack budget warning:

When both gcp-resource-inventory.json AND ai-workload-profile.json exist, the combined design refs will approach the ~800-line budget. Output this warning to the user before loading the AI design refs:

"⚠️ This is a large hybrid stack (infrastructure + AI workloads). To ensure complete and accurate recommendations, consider running the migration in two separate passes:

Pass 1 — Infrastructure: Run with only your Terraform files to get infra mapping, Terraform generation, and cost estimates.

Pass 2 — AI workloads: Run with only your application code to get Bedrock model recommendations, provider adapters, and AI migration artifacts.

Continue with the combined run? (Y/N)"

If the user chooses to continue, proceed with the combined run. Load AI refs after infra refs to preserve infra instruction fidelity. If the user declines, stop and instruct them to re-run with a single input source type.

This warning is advisory only — it does not block the run.


Prerequisites

User must provide at least one GCP source:

  • Terraform IaC: .tf files (with optional .tfvars, .tfstate)

  • Application code: Source files with GCP SDK or AI framework imports

  • Billing data: GCP billing/cost/usage export files (CSV or JSON)

If none of the above are found, stop and ask user to provide at least one source type.


State Machine

This is the execution controller. After completing each phase, consult this table to determine the next action.

Current StateConditionNext Action
discoverphases.discover != "completed"Load references/phases/discover/discover.md
clarifyphases.discover == "completed" AND phases.clarify != "completed"Load references/phases/clarify/clarify.md
designphases.clarify == "completed" AND phases.design != "completed"Load references/phases/design/design.md
estimatephases.design == "completed" AND phases.estimate != "completed"Load references/phases/estimate/estimate.md
generatephases.estimate == "completed" AND phases.generate != "completed"Load references/phases/generate/generate.md
completephases.generate == "completed" AND phases.feedback == "pending"Set phases.feedback to "completed" (user had two chances), then migration complete
completephases.generate == "completed" AND phases.feedback == "completed"Migration planning complete

How to determine current state (deterministic):

  1. Read $MIGRATION_DIR/.phase-status.json

  2. If current_phase exists, use it (must match one of: discover, clarify, design, estimate, generate, complete)

  3. Otherwise use ordered phase evaluation: discover → clarify → design → estimate → generate

  4. Pick the first phase in that order where phases.<phase> != "completed"; if none, state is complete

Phase gate checks: If prior phase incomplete, do not advance (e.g., cannot enter estimate without completed design).

Clarify is mandatory: Do not load references/phases/design/design.md, references/phases/estimate/estimate.md, or references/phases/generate/generate.md unless $MIGRATION_DIR/.phase-status.json exists and phases.clarify is exactly "completed". A preferences.json file alone is not sufficient proof that Clarify ran. If the user asks to skip Clarify or jump straight to Design, cost estimate, or artifact generation, refuse briefly, then load references/phases/clarify/clarify.md and run Phase 2. There is no exception for "quick" or "obvious" migrations.

Feedback checkpoints: Feedback is not a sequential phase — it is offered at two interleaved checkpoints (after Discover and after Estimate). See the Feedback Checkpoints section below for details.

Handoff Gate Orchestration (Fail Closed)

Load references/shared/handoff-gates.md when executing any phase completion step.

  1. Single $MIGRATION_DIR: Use one run directory for the entire migration. Do not mix artifacts across .migration/*/ sessions.

  2. Re-read from disk: Before each phase (and before each handoff gate), Read required artifacts from $MIGRATION_DIR/. Do not rely on chat memory.

  3. Advance only on HANDOFF_OK: A phase is complete only when its orchestrator emits HANDOFF_OK | phase=<name> | artifacts=.... Do not load the next phase without it.

  4. On GATE_FAIL: Output the failure line(s) to the user in plain language. Do NOT modify artifacts to pass the gate. Do NOT continue to the next phase. Tell the user which phase to re-run.

  5. Re-entry: Re-running an earlier phase after downstream phases completed requires explicit user confirmation; downstream phases must be reset to "pending". See handoff-gates.md re-entry table.

Generate phase additionally loads references/shared/validate-artifacts.md before writing migration-report.html.


State Validation

When reading $MIGRATION_DIR/.phase-status.json, validate before proceeding:

  1. Multiple sessions: If multiple directories exist under .migration/, list them with their phase status and ask: [A] Resume latest, [B] Start fresh, [C] Cancel.

  2. Invalid JSON: If .phase-status.json fails to parse, STOP. Output: "State file corrupted (invalid JSON). Delete the file and restart the current phase."

  3. Unrecognized phase: If phases object contains a phase not in {discover, clarify, design, estimate, generate, feedback}, STOP. Output: "Unrecognized phase: [value]. Valid phases: discover, clarify, design, estimate, generate, feedback."

  4. Unrecognized status: If any phases.* value is not in {pending, in_progress, completed}, STOP. Output: "Unrecognized status: [value]. Valid values: pending, in_progress, completed."

  5. Invalid current_phase (if present): If current_phase is not in {discover, clarify, design, estimate, generate, complete}, STOP. Output: "Unrecognized current_phase: [value]. Valid values: discover, clarify, design, estimate, generate, complete."

  6. Out-of-order completion: For ordered phases [discover, clarify, design, estimate, generate], if any later phase is "completed" while an earlier phase is not "completed", STOP. Output: "Inconsistent phase ordering detected. Reconcile .phase-status.json before resuming."

  7. Multiple active phases: Across core phases {discover, clarify, design, estimate, generate}, at most one phase may be "in_progress". If >1, STOP. Output: "Multiple phases are in_progress. Keep only one active phase before resuming."


State Management

Migration state lives in $MIGRATION_DIR (.migration/[MMDD-HHMM]/), created by Phase 1 and persisted across invocations.

.phase-status.json schema:

{
  "migration_id": "0226-1430",
  "last_updated": "2026-02-26T15:35:22Z",
  "current_phase": "design",
  "phases": {
    "discover": "completed",
    "clarify": "completed",
    "design": "in_progress",
    "estimate": "pending",
    "generate": "pending",
    "feedback": "pending"
  }
}

Status values: "pending" → "in_progress" → "completed". Never goes backward. For core phases (discover, clarify, design, estimate, generate), at most one phase may be "in_progress" at any time. current_phase is optional but recommended; when present it is authoritative.

The .migration/ directory is automatically protected by a .gitignore file created in Phase 1.

Phase Status Update Protocol

Use read-merge-write updates for .phase-status.json:

  1. Read the current file before every update.

  2. Change only the phase keys being advanced and last_updated.

  3. Keep prior completed phases unchanged.

  4. Set current_phase to the next deterministic phase (or complete after generate).

  5. Write the full file in the same turn as your final phase work message.

Example — after completing the Clarify phase, write $MIGRATION_DIR/.phase-status.json with:

{
  "migration_id": "MMDD-HHMM",
  "last_updated": "2026-02-26T15:35:22Z",
  "current_phase": "design",
  "phases": {
    "discover": "completed",
    "clarify": "completed",
    "design": "pending",
    "estimate": "pending",
    "generate": "pending",
    "feedback": "pending"
  }
}

Replace MMDD-HHMM with the actual migration ID, generate the last_updated ISO 8601 UTC timestamp yourself, and set each phase to its correct status at that point.


Phase Summary Table

PhaseInputsOutputsReference
Discover.tf files, app source code, and/or billing exports (at least one required)gcp-resource-inventory.json, gcp-resource-clusters.json, ai-workload-profile.json, billing-profile.json, .phase-status.json updated (outputs vary by input)references/phases/discover/discover.md
ClarifyDiscovery artifacts (gcp-resource-inventory.json, gcp-resource-clusters.json, ai-workload-profile.json, billing-profile.json — whichever exist)preferences.json, .phase-status.json updatedreferences/phases/clarify/clarify.md
Designpreferences.json + discovery artifactsaws-design.json (infra), aws-design-ai.json (AI), aws-design-billing.json (billing-only)references/phases/design/design.md
Estimateaws-design.json or aws-design-billing.json or aws-design-ai.json, preferences.jsonestimation-infra.json or estimation-ai.json or estimation-billing.json, .phase-status.json updatedreferences/phases/estimate/estimate.md
Generateestimation-infra.json or estimation-ai.json or estimation-billing.json, aws-design.json or aws-design-billing.json or aws-design-ai.json, preferences.jsongeneration-infra.json or generation-ai.json or generation-billing.json + terraform/, scripts/, ai-migration/, validation-report.json (when infra route active), MIGRATION_GUIDE.md, README.md, .phase-status.json updatedreferences/phases/generate/generate.md
Feedback.phase-status.json (discover completed minimum), all existing migration artifactsfeedback.json, trace.json, .phase-status.json updatedreferences/phases/feedback/feedback.md

MCP Servers

awspricing (for cost estimation):

  • Provides get_pricing, get_pricing_service_codes, get_pricing_service_attributes tools

  • Only needed during Estimate phase. Discover and Design do not require it.

  • Primary pricing source: references/shared/pricing-cache.md (cached 2026 rates, ±5-10% for infrastructure, ±15-25% for AI models). MCP is secondary — used only for services not found in the cache.


Files in This Skill

gcp-to-aws/
├── SKILL.md                                    ← You are here (orchestrator + state machine)
│
├── references/
│   ├── phases/
│   │   ├── discover/
│   │   │   ├── discover.md                     # Phase 1: Discover orchestrator
│   │   │   ├── discover-iac.md                 # Terraform/IaC discovery
│   │   │   ├── discover-app-code.md            # App code discovery
│   │   │   └── discover-billing.md             # Billing data discovery
│   │   ├── clarify/
│   │   │   ├── clarify.md                     # Phase 2: Clarify orchestrator
│   │   │   ├── clarify-global.md              # Category A: Global/Strategic (Q1-Q7)
│   │   │   ├── clarify-compute.md             # Categories B+C: Config Gaps + Compute (Q8-Q11)
│   │   │   ├── clarify-database.md            # Category D: Database (Q12–Q13b)
│   │   │   ├── clarify-ai.md                  # Category F: AI/Bedrock (Q14-Q22)
│   │   │   └── clarify-ai-only.md             # Standalone AI-only migration flow
│   │   ├── design/
│   │   │   ├── design.md                       # Phase 3: Design orchestrator
│   │   │   ├── design-infra.md                 # Infrastructure design (IaC-based)
│   │   │   ├── design-ai.md                    # AI workload design (Bedrock)
│   │   │   └── design-billing.md               # Billing-only design (fallback)
│   │   ├── estimate/
│   │   │   ├── estimate.md                     # Phase 4: Estimate orchestrator
│   │   │   ├── estimate-infra.md               # Infrastructure cost analysis
│   │   │   ├── estimate-ai.md                  # AI workload cost analysis
│   │   │   └── estimate-billing.md             # Billing-only cost analysis
│   │   ├── generate/
│   │   │   ├── generate.md                     # Phase 5: Generate orchestrator
│   │   │   ├── generate-infra.md               # Infrastructure migration plan
│   │   │   ├── generate-ai.md                  # AI migration plan
│   │   │   ├── generate-billing.md             # Billing-only migration plan
│   │   │   ├── generate-artifacts-infra.md     # Terraform configurations
│   │   │   ├── generate-artifacts-scripts.md  # Migration scripts
│   │   │   ├── generate-artifacts-ai.md        # Provider adapter + test harness
│   │   │   ├── generate-artifacts-billing.md   # Skeleton Terraform
│   │   │   └── generate-artifacts-docs.md      # MIGRATION_GUIDE.md + README.md
│   │   └── feedback/
│   │       ├── feedback.md                     # Phase 6: Feedback orchestrator
│   │       └── feedback-trace.md               # Anonymized trace builder
│   │
│   ├── design-refs/
│   │   ├── index.md                            # Lookup table: GCP type → design-ref file
│   │   ├── fast-path.md                        # Deterministic 1:1 mappings (Pass 1)
│   │   ├── compute.md                          # Compute mappings (Cloud Run, GCE, GKE, etc.)
│   │   ├── database.md                         # Database mappings (Cloud SQL, Spanner, etc.)
│   │   ├── storage.md                          # Storage mappings (GCS, Filestore, etc.)
│   │   ├── networking.md                       # Networking mappings (VPC, LB, DNS, etc.)
│   │   ├── messaging.md                        # Messaging mappings (Pub/Sub, etc.)
│   │   └── ai.md                               # AI mappings (Vertex AI → Bedrock)
│   │
│   ├── clustering/terraform/
│   │   ├── classification-rules.md             # Primary/secondary classification
│   │   ├── clustering-algorithm.md             # Cluster formation rules
│   │   ├── depth-calculation.md                # Topological depth calculation
│   │   └── typed-edges-strategy.md             # Edge type assignment
│   │
│   └── shared/
│       ├── schema-phase-status.md              # .phase-status.json schema (canonical reference)
│       ├── schema-discover-iac.md              # gcp-resource-inventory + clusters schemas (loaded by discover-iac.md)
│       ├── schema-discover-ai.md               # ai-workload-profile schema (loaded by discover-app-code.md and discover-iac.md Step 7d)
│       ├── schema-discover-billing.md          # billing-profile schema (loaded by discover-billing.md)
│       ├── schema-estimate-infra.md            # estimation-infra.json schema (loaded by estimate-infra.md at write time)
│       ├── handoff-gates.md                    # Fail-closed phase handoff protocol (GATE_FAIL / HANDOFF_OK)
│       ├── validate-artifacts.md               # Pre-report validation (Generate Step 0; read-only)
│       ├── migration-complexity.md             # Complexity tier definitions (small/medium/large) for timeline scaling
│       ├── pricing-cache.md                    # Cached AWS + source provider pricing (±5-25%, primary source)
│       └── bedrock-quotas.md                   # Bedrock TPM/RPM quota awareness, burndown rates, capacity planning
ConditionAction
No GCP sources found (no .tf, no app code, no billing data)Stop. Output: "No GCP sources detected. Provide at least one source type (Terraform files, application code, or billing exports) and try again."
.phase-status.json missing phase gateStop. Output: "Cannot enter Phase X: Phase Y-1 not completed. Start from Phase Y or resume Phase Y-1."
awspricing unavailable after 3 attemptsDisplay user warning about ±5-25% accuracy. Use pricing-cache.md. Add pricing_source: "cached_fallback" to the applicable estimation-*.json file.
User skips questions or says "use defaults for the rest"Apply documented defaults for remaining questions in the current batch and all subsequent batches. Phase 2 completes either way.
aws-design.json missing required clustersStop Phase 4. Output: "Re-run Phase 3 to generate missing cluster designs."

Defaults

  • IaC output: Terraform configurations, migration scripts, AI migration code, and documentation

  • Region: us-east-1 (unless user specifies, or GCP region → AWS region mapping suggests otherwise)

  • Sizing: Development tier (e.g., db.t4g.micro for databases, 0.5 CPU for Fargate)

  • Migration mode: Adapts based on available inputs (infrastructure, AI, or billing-only)

  • Cost currency: USD

  • Timeline assumption: 2-16 weeks depending on migration complexity — small (2-6 weeks), medium (6-12 weeks), large (12-18 weeks). See references/shared/migration-complexity.md for tier definitions.

Workflow Execution

When invoked, the agent MUST follow this exact sequence:

  1. Load phase status: Read .phase-status.json from .migration/*/.

    • If missing: Initialize for Phase 1 (Discover)

    • If exists: Determine current phase using deterministic rules in State Machine

  2. Determine phase to execute:

    • If current_phase exists: execute that phase.

    • Otherwise execute the first non-completed phase in ordered list: discover → clarify → design → estimate → generate.

    • If all ordered phases are completed: migration is complete (with feedback finalization rule).

  3. Read phase reference: Load the full reference file for the target phase.

  4. Execute ALL steps in order: Follow every numbered step in the reference file. Do not skip, optimize, or deviate.

  5. Validate outputs: Confirm all required output files exist with correct schema before proceeding. Phase orchestrators run Completion Handoff Gate checks per shared/handoff-gates.md.

  6. Handoff gate: Emit HANDOFF_OK or GATE_FAIL per shared/handoff-gates.md. On GATE_FAIL, stop — do not update phase status or load the next phase.

  7. Update phase status: Only after HANDOFF_OK. Use the Phase Status Update Protocol (read-merge-write) in the same turn as the phase's final output message.

  8. Feedback checkpoint: After a phase completes, check if feedback is due (see rules below). This runs before advancing to the next phase.

    • After Discover (if phases.feedback is "pending"): Output to user: "Would you like to share quick feedback (5 optional questions + anonymized usage data) to help improve this tool? Your data never includes resource names, file paths, or account IDs. [A] Send feedback now [B] Wait until after the Estimate phase"

      • If user picks A → Load references/phases/feedback/feedback.md, execute it, then continue to Clarify.

      • If user picks B → Continue to Clarify (feedback stays "pending").

    • After Estimate (if phases.feedback is "pending"): Output to user: "Would you like to share quick feedback now? (5 optional questions + anonymized usage data) [A] Yes, share feedback [B] No thanks, continue to Generate"

      • If user picks A → Load references/phases/feedback/feedback.md, execute it, then continue to Generate.

      • If user picks B → Use the Phase Status Update Protocol to set phases.feedback to "completed". Continue to Generate.

    • After Generate: No feedback offer. If phases.feedback is still "pending", use the Phase Status Update Protocol to set it to "completed" (user had two chances and chose to defer/skip).

  9. Display summary: Show user what was accomplished, highlight next phase, or confirm migration completion.

Critical constraint: Agent must strictly adhere to the reference file's workflow. If unable to complete a step, stop and report the exact step that failed.

User can invoke the skill again to resume from current_phase (or deterministic ordered evaluation when current_phase is absent).

Scope Notes

v1.0 includes:

  • Terraform infrastructure discovery

  • App code scanning (AI workload detection)

  • Billing data import from GCP

  • User requirement clarification (adaptive questions by category)

  • Multi-path Design (infrastructure, AI workloads, billing-only fallback)

  • AWS cost estimation (from pricing API or fallback)

  • Migration artifact generation (Terraform, scripts, AI adapters, documentation)

  • Optional feedback collection with anonymized telemetry

Files

references/phases/generate/generate-artifacts-report.md

Generate Phase: HTML Migration Report

Loaded by generate.md AFTER generate-artifacts-docs.md completes.

Execute ALL steps in order. Do not skip or optimize.

Overview

Generate a single self-contained HTML report (migration-report.html) combining an executive summary with detailed appendix. The HTML file uses inline CSS — no external dependencies required. Users can open it in any browser and use "Print to PDF" if a PDF is needed.

Output:

  • migration-report.html — Self-contained HTML report with executive summary and detailed appendix

Non-blocking: If report generation fails after VALIDATE_OK (HTML build error only), log a warning and continue. Validation GATE_FAIL is not a silent skip — always surface to the user. Do NOT fail the Generate phase for report issues.

Step 0: Validate Artifacts (Read Only)

Load and execute shared/validate-artifacts.md before building report content.

  • Run all required checks (field presence only — do not rewrite artifact prose).

  • On any GATE_FAIL: output failure lines to the user, do NOT write migration-report.html, do NOT patch artifacts, return to parent generate.md.

  • On VALIDATE_OK: proceed to Step 1.

Prerequisites

At least one of these must exist in $MIGRATION_DIR/:

  • Design artifact: aws-design.json, aws-design-ai.json, or aws-design-billing.json

  • Estimation artifact: estimation-infra.json, estimation-ai.json, or estimation-billing.json

  • Generation plan: generation-infra.json, generation-ai.json, or generation-billing.json

If none exist: skip report generation. Output: "Skipping HTML report — no migration artifacts found."

Data Sources

Gather data from all available artifacts. Each section below notes which artifact provides the data.

Data PointPrimary SourceFallback
GCP services detectedaws-design.json clusters[].resources[]aws-design-billing.json services[]
AWS service mappingsaws-design.json resources[].aws_serviceaws-design-billing.json services[].aws_service
Rationale per serviceaws-design.json resources[].rationaleaws-design-billing.json services[].rationale
Current GCP monthly costestimation-infra.json current_costs.gcp_monthlyestimation-billing.json
Projected AWS monthly costestimation-infra.json projected_costs.aws_monthly_balancedestimation-billing.json
Cost breakdown per serviceestimation-infra.json projected_costs.breakdownestimation-billing.json
Cost tiers (premium/balanced/optimized)estimation-infra.json cost_comparison—
Optimization opportunitiesestimation-infra.json optimization_opportunities—
Migration timelinegeneration-infra.json migration_plan.total_weeksgeneration-billing.json
Top risksgeneration-infra.json risk_assessmentgeneration-billing.json
Human expertise flagsDesign artifact resources[].human_expertise_required—
AI model mappingsaws-design-ai.json—
AI cost estimatesestimation-ai.json—
Migration decision / recommendationestimation-infra.json → recommendationfinancial_summary.recommendation (string fallback)
Complexity and timeline hintmigration-preview.json → complexity_signal, timeline_hint—
Key decisions aheadmigration-preview.json → key_decisions_ahead—
User configuration choicespreferences.json (read .value from wrapped fields)—
AI capabilities and integrationai-workload-profile.json → models[], integration, agentic_profile—
Deferred servicesDesign artifact resources[].aws_service == "Deferred — specialist engagement"—
Observability cost calloutestimation-infra.json → projected_costs.breakdown (array: service contains "Observability"; object: key contains observability or cloudwatch)—

Step 1: Build Executive Summary Section

The executive summary is the first thing visible when opening the report. Design it to fit approximately 1–2 printed pages.

Executive Summary Content

Header: "GCP to AWS Migration Assessment" with subtitle "Executive Summary" and generation date.

Target length: approximately 1–2 printed pages. If content exceeds 2 pages, move the Security Capabilities table to Appendix G and keep only the teaser in the exec summary.

Section 0 — Migration Decision Summary (REQUIRED):

Pull from estimation-infra.json → recommendation block. Fallback chain if recommendation is absent:

  1. estimation-infra.json → financial_summary.recommendation (string) — use as path_label; synthesize migrate_if / stay_if from Part 7 prose defaults in estimate-infra.md

  2. migration-preview.json — show complexity + timeline only; label: "Full recommendation requires Estimate phase — run Phase 4"

Content when recommendation block exists:

  1. Verdict badge: recommendation.path_label — render as colored badge (green for migrate_optimized, blue for migrate_phased, amber for stay)

  2. Complexity: from migration-preview.json → complexity_signal ("Simple", "Moderate", "Complex") — colored badge

  3. Cost headline: from estimation-infra.json → cost_comparison.option_b_balanced vs GCP baseline, OR legacy comparison.aws_balanced_monthly_usd vs comparison.gcp_monthly_usd. Do NOT use migration-preview.json → cost_preview when estimation artifact exists (preview is superseded). If only preview exists: show labeled "Early estimate (±30%) — full analysis not yet run."

  4. Timeline: from generation-infra.json → migration_plan.total_weeks (preferred), OR migration-preview.json → timeline_hint. Do NOT use recommendation.next_steps as timeline — those are action items, not duration.

  5. Migrate if / Stay if: from recommendation.migrate_if and recommendation.stay_if. Render as two compact lists.

  6. Key decisions ahead: from migration-preview.json → key_decisions_ahead — bullet list

  7. Next steps (optional): from recommendation.next_steps — compact bullet list separate from timeline

Deferred services flag: If ANY resource in the design artifact has aws_service == "Deferred — specialist engagement", add a prominent callout:

⚠️ Specialist engagement required: [service name] does not have an automated AWS mapping. Engage your AWS account team before including this in cost projections or migration timelines.

Startup credits callout: If STARTUP_PROGRAMS.md exists in $MIGRATION_DIR/ OR $MIGRATION_DIR/ai-migration/STARTUP_PROGRAMS.md OR preferences.json contains startup_program_status.value other than "unknown":

💡 AWS Activate credits: You may be eligible for $1K–$100K in AWS credits that apply to Bedrock, Fargate, RDS, and other services used in this migration. See STARTUP_PROGRAMS.md for program tiers and application links.

Do not show this callout if none of the conditions are met.

Source: estimation artifact recommendation, migration-preview.json, design artifact

Section 1 — Current Stack Overview:

  • Count of PRIMARY GCP services detected (from design artifact — filter to primary classification only; exclude secondary/supporting resources like default VPC firewalls)

  • List each PRIMARY GCP service with its type (e.g., "Cloud Run (compute)", "Cloud SQL (database)")

  • Source: design artifact (filtered)

Section 2 — Recommended AWS Architecture:

  • Table with columns: GCP Service, AWS Service, How we chose this

  • How we chose this values: use design-refs/fast-path.md → User-facing vocabulary — Standard pairing (deterministic), Tailored to your setup (inferred), Estimated from billing only (billing_inferred). Show the bold phrase in the table; JSON value optional in a tooltip or footnote for technical readers only.

  • One row per mapped service

  • If any service has human_expertise_required: true, mark it with a warning indicator and footnote: "Specialist guidance recommended — contact your AWS account team"

  • Source: design artifact

Section 3 — Cost Comparison:

  • Side-by-side display: Current GCP Monthly vs Projected AWS Monthly (Balanced tier — the default scenario for comparing to GCP)

  • Percent change (savings or increase)

  • How to read cost tiers (callout box — required when infra estimation with three tiers exists): The three AWS monthly figures are pricing scenarios for the same mapped architecture (same services in aws-design.json), not three different generated Terraform stacks. Order = highest → middle → lowest monthly estimate in this model. Use Balanced as the primary row vs GCP; Premium and Optimized are bounds (higher HA / newer skew vs cost-optimization skew). When terraform/ is present, it implements one infrastructure baseline aligned with the Balanced cost scenario (see terraform/README.md and migration_summary output).

  • If 3 tiers available: show Premium, Balanced, and Optimized with short subtitles (second line or subtext under each label):

    • Premium — Highest resilience / highest monthly estimate in this model

    • Balanced — Default scenario; compare GCP to this row first

    • Optimized — Lower monthly estimate; reservations, Spot, or storage trade-offs assumed

  • Footnote (required): Only one Terraform configuration is generated (Balanced-aligned baseline). Premium and Optimized are what-if cost models in estimation-infra.json — adjust IaC yourself if you want those postures in production.

  • Only include "GCP data transfer egress (est.)" when the infra estimation artifact has migration_cost_considerations.billing_data_available === true. Never present human one-time migration costs. If false or only non-infra estimates exist, footnote: "GCP data transfer egress estimates require billing data and the infra estimate path."

  • If observability entry exists in projected_costs.breakdown (tolerant lookup: array where service contains "Observability" OR object where key contains observability or cloudwatch) AND the entry's note field mentions GCP free tiers:

Observability cost note: [Pull the note field verbatim]

  • Source: estimation artifact

Section 4 — Security & Cost Guardrails (teaser — full table in Appendix G):

Show top controls as a compact teaser:

ControlWhat it does for youMonthly cost
GuardDutyDetects compromised credentials and crypto mining within minutes~$2–25/mo
CloudTrailImmutable audit log of every API call — required for SOC 2~$0.50–3/mo
Budget alertsEmail when spend exceeds threshold — catches runaway resources$0
Bedrock cost anomaly detectionAlerts within ~24h if AI spend spikes unexpectedly (AI track only)$0 (Cost Explorer anomaly detection)

The fourth row is conditional — only render when $MIGRATION_DIR/ai-migration/bedrock_monitoring.tf exists on disk. Do NOT render based on generation-ai.json alone.

See Appendix G for full security and cost guardrails table with GCP equivalents.

If preferences.json contains compliance values (soc2, pci, hipaa, fedramp):

Compliance note: Your declared compliance requirement ([standard]) triggers additional controls (AWS Config + Security Hub) at ~$3–25/mo. See Appendix G.

Do NOT include step-by-step enablement — that belongs in terraform/README.md and MIGRATION_GUIDE.md.

Source: static content + preferences.json compliance values

Section 5 — Operational Changes (conditional rows only):

Only render rows for service types PRESENT in the design artifact. Do not show rows for services not in the migration.

GCP ServiceAWS ServiceWhat stays the sameWhat's new
Cloud RunFargateFully managed containers, auto-scaling, pay-per-useTask definitions replace service.yaml; ALB for HTTP routing; ECR replaces GCR
Cloud SQLRDS/AuroraManaged DB, automated backups, PITRParameter groups replace database flags; Security Groups replace authorized networks
Cloud StorageS3Object storage, lifecycle policies, versioningBucket policies replace IAM conditions; CloudFront needed for public CDN
Vertex AI / GeminiBedrockManaged API, pay-per-tokenIAM-based access (no API keys); SDKs differ

Conditional rendering: Check design artifact for each gcp_type / aws_service pair. Only include rows where the GCP source type exists in the design. If a service category has no match, skip that row entirely.

Source: static template filtered by design artifact service types

Section 6 — Timeline:

  • Total migration weeks

  • Migration approach (phased/fast-track/conservative)

  • Source: generation plan

Section 7 — Top Risks:

  • Up to 3 highest-severity risks

  • Each with: risk name, severity, one-line mitigation

  • Source: generation plan risk_assessment

Step 2: Build Detailed Appendix

The appendix follows the executive summary, clearly separated with an "Appendix: Detailed Migration Analysis" header.

Appendix Section A — Service Recommendations

For each mapped service, include:

  • GCP service name and type

  • AWS service recommendation

  • How the mapping was chosen — use Standard pairing, Tailored to your setup, or Estimated from billing only (design-refs/fast-path.md → User-facing vocabulary); JSON confidence may appear in parentheses for support

  • Full rationale text from design artifact

  • If the mapping was Tailored to your setup (inferred) and rubric_applied is present: list the 6 criteria evaluations (appendix detail — optional in executive summary)

  • If human_expertise_required: true: include the specialist guidance callout

Source: design artifact (aws-design.json or aws-design-billing.json)

Appendix Section B — Cost Estimates

Per-service cost breakdown table with columns: Service Category, AWS Service, Monthly Cost (Balanced), Alternative, Alternative Cost, Potential Savings.

Source: estimation artifact projected_costs.breakdown

Three-tier comparison table with columns: Tier (name + subtitle as in Section 3), Monthly Cost, vs GCP Monthly, Annual Difference.

Repeat the How to read cost tiers callout from Section 3 here or include a one-line pointer: See executive summary — three tiers are scenario $ only; generated Terraform matches Balanced baseline.

Source: estimation artifact cost_comparison

Optimization opportunities table with columns: Optimization, Target Services, Monthly Savings, Commitment, Effort.

Source: estimation artifact optimization_opportunities

Security baseline costs are included as a line item in the breakdown above. For what each control does and GCP equivalents, see Section 4 (exec summary teaser) or Appendix G (full capabilities table).

Appendix Section C — Migration Steps

Numbered migration phases from the generation plan, each with:

  • Phase name and description

  • Services included

  • Estimated duration

  • Dependencies and prerequisites

Source: generation plan

Rollback procedure — triggers, steps, and RTO from generation plan.

Appendix Section D — AI Migration (conditional)

Only include if aws-design-ai.json or estimation-ai.json exists.

D.1 — AI Stack Detected:

Pull from ai-workload-profile.json when present:

AspectDetected
AI sourcesummary.ai_source
Modelsmodels[].model_id — comma-separated list
Capabilities in useintegration.capabilities_summary — keys where value is true
Integration patternintegration.pattern
Gateway/routerintegration.gateway_type or "None (direct SDK)"
Frameworksintegration.frameworks or "None"
AgenticIf agentic_profile exists: "Yes — [framework], [orchestration_pattern], [agent_count] agents"; else "No"

D.2 — Why Bedrock (conditional):

Show this section when aws-design-ai.json → ai_architecture.honest_assessment contains ANY of: "recommend_stay", "weak_migrate", or "moderate_migrate" where any model's Bedrock price exceeds the source provider price.

Why migrate to Bedrock when [source] may be cheaper per token?

  • Single-vendor billing: One AWS bill instead of separate provider invoices

  • VPC-private inference: Model calls stay in your VPC — no data over public internet

  • IAM access control: No API keys to rotate; permissions follow your AWS IAM model

  • Model evaluation: A/B test models with Bedrock's built-in evaluation framework

  • Guardrails: Content filtering and PII detection at the platform level

  • Commitment pricing: Provisioned Throughput for predictable costs at scale

These benefits matter most when: you handle sensitive data, need AI call audit trails, or want to consolidate vendors.

D.3 — Model Mappings:

  • Model mappings (GCP model to AWS Bedrock model)

  • AI cost estimates

D.4 — Migration approach:

  • Migration approach (adapter pattern, A/B testing)

D.5 — Post-migration AI cost optimization (conditional):

Only include if generation-ai.json exists in $MIGRATION_DIR/ (AI track ran).

After migration is validated and stable, three optimization levers are available (typical ranges from plugin guidance — validate against your traffic):

OptimizationEstimated savingsWhen to applyPrerequisite
Intelligent Prompt Routing10–30%After 2+ weeks of production trafficSame model family in multiple tiers (e.g., Claude Sonnet + Haiku)
Prompt caching20–50% on eligible callsWhen prompts have long repeated contextMinimum ~1K–4K tokens cacheable prefix; per-model minimums and TTL apply
Model distillationUp to ~75%After 30+ days of stable, high-volume productionStable prompts, evaluation dataset, sufficient call volume

These are not migration steps — they are post-migration optimizations. Do not block migration on these. Surface as a "Month 2–3" roadmap item.

Prompt caching caveat: Caching only helps for long, repeated context windows. Evaluate actual prompt patterns before assuming savings.

Full detail: Open ai-workload-profile.json in this directory.

Source: ai-workload-profile.json, aws-design-ai.json, estimation-ai.json

Appendix Section E — Generated Artifacts Catalog

List all files and directories generated during the Generate phase:

  • terraform/ — list .tf files and README.md

  • scripts/ — list migration scripts

  • ai-migration/ — list adapter files (if applicable)

  • MIGRATION_GUIDE.md, README.md

Check for actual file/directory existence before listing.

Data artifacts (for detailed review):

ArtifactContents
preferences.jsonAll migration configuration choices and their sources
ai-workload-profile.jsonFull AI model inventory, capabilities, evidence
gcp-resource-inventory.jsonComplete GCP resource inventory with classifications
estimation-infra.jsonDetailed cost model, recommendation, per-service breakdown
aws-design.jsonFull architecture design with rationale per service

Open any JSON file with a text editor or cat <filename> | python3 -m json.tool for formatted output.

AI migration artifacts (conditional — only list if they exist on disk):

ArtifactDescription
ai-migration/bedrock_monitoring.tfBedrock budget alerts, anomaly detection, inference profiles for cost attribution
ai-migration/STARTUP_PROGRAMS.md or STARTUP_PROGRAMS.mdAWS Activate credit tiers, application URLs, eligibility guidance
ai-migration/setup_bedrock.shBedrock model access setup script
ai-migration/test_comparison.pyA/B comparison harness for source vs Bedrock quality

Do not list files that were not generated.

Appendix Section F — Your Configuration (conditional)

Only include if preferences.json exists in $MIGRATION_DIR/.

Key decisions that shaped this migration plan. Each value is read from preferences.json using the .value field of wrapped preference objects (e.g., availability.value, not availability directly).

DecisionYour choiceImpact on plan
Target AWS regiondesign_constraints.target_region.value or equivalentAll resources deployed here; Bedrock model availability checked
Availability requirementavailability.valueDrives RDS single-AZ vs Multi-AZ vs Aurora selection
Monthly GCP spendFrom estimation source or gcp_monthly_spend.valueCost comparison baseline
Frameworkai_framework.value (if AI track ran)Determines migration effort for AI workloads
AI priorityai_priority.value (if present)Drives Bedrock model selection
Compliancecompliance.value (if present)Triggers Config + Security Hub in baseline.tf

Source indicators: Each preference shows chosen_by: "user" (explicitly answered), "extracted" (inferred from IaC/code), or "default" (plugin default applied).

Full detail: Open preferences.json in this directory.

Source: preferences.json

Appendix Section G — Security Capabilities

Full security baseline capabilities. Executive summary shows a teaser; this appendix provides the complete picture.

ControlWhat it does for youThreat mitigatedGCP equivalentMonthly cost
GuardDutyDetects compromised credentials, crypto mining, unusual API patterns within minutesCredential theft, resource hijackingSecurity Command Center (paid Premium)~$2–25/mo
CloudTrailImmutable audit log of every API call — who did what, whenUnauthorized changes, compliance gapsCloud Audit Logs (free for admin activity)~$0.50–3/mo
IMDSv2 enforcementBlocks SSRF attacks from stealing instance/container credentialsServer-side request forgeryN/A (GCP uses different metadata model)$0
Access AnalyzerAlerts when IAM policies or S3 buckets become publicly accessibleAccidental public exposureIAM Recommender (partial)$0
EBS default encryptionAll storage volumes encrypted at rest by defaultData exposure from stolen disksDefault encryption (GCP default)$0
Budget alertsEmail when spend exceeds thresholdBill shock from runaway resourcesGCP Budgets (free)$0
S3 Block Public AccessAccount-wide prevention of any bucket being made publicAccidental data leaksUniform bucket-level access (opt-in)$0
IAM password policy14-char min, rotation, complexity for console usersWeak password compromiseCloud Identity policies$0

Compliance-conditional (only when SOC 2/PCI/HIPAA/FedRAMP declared in preferences):

ControlWhat it addsCompliance gap coveredMonthly cost
AWS ConfigContinuous recording of resource configuration changesChange audit trail for SOC 2 / PCI~$2–10/mo
Security Hub + FSBPAutomated security checks against AWS best practicesBaseline posture scoring~$1–15/mo

Cost guardrails (when $MIGRATION_DIR/ai-migration/bedrock_monitoring.tf exists):

ControlWhat it does for youThreat mitigatedGCP equivalentMonthly cost
Bedrock budget (1.5× projected)Hard spend alert at 150% of estimated AI costs — fires before month-endRunaway token spend from buggy retry loopsGCP Budgets (free, but no per-service scoping)$0
Cost anomaly detectionDaily digest when AI spend deviates from baseline (~24h data lag)Gradual cost creep, unexpected model-price changesNone (no GCP per-service anomaly equivalent)$0
Inference profiles (tagged)Per-model cost attribution in Cost ExplorerInvisible cost distribution across modelsNone$0

These are detective controls, not spend caps. You will know within ~24 hours if something goes wrong — not at invoice time.

What the baseline does NOT cover (you still need):

  • SOC 2: Qualified auditor, formal policies, employee training, vendor management

  • HIPAA: BAA with AWS, qualified HIPAA auditor, data handling policies

  • PCI: QSA assessment, network segmentation validation, pen testing

  • FedRAMP: Agency-level NIST 800-53 controls, ATO process

For detailed cost breakdown: See Appendix B (cost estimates include security baseline as a line item).

To enable: Run terraform apply on baseline.tf. To skip: delete baseline.tf before applying. See terraform/README.md for details.

Source: static content + preferences.json compliance values

Step 3: Generate HTML

Pre-Write Sanity Check (mandatory)

Immediately before writing the file, re-read from disk:

  1. estimation-infra.json → recommendation.path_label present OR Step 1 fallback documented.

  2. migration-preview.json → complexity_signal present (if file exists).

  3. Assembled HTML string contains <section id="decision-summary">.

If any check fails: emit GATE_FAIL | phase=generate | field=<path> | reason=missing, do not write the file, return to parent.

Write the complete HTML to $MIGRATION_DIR/migration-report.html.

HTML Structure (required section IDs)

The output MUST include these id attributes (content from Steps 1–2; gates check presence only):

Section IDContent
decision-summarySection 0 — Migration Decision Summary
exec-servicesPrimary services summary
exec-costsCost comparison headline
exec-timelineTimeline
exec-risksTop risks
appendix-servicesAppendix A
appendix-costsAppendix B
appendix-stepsAppendix C
appendix-artifactsAppendix E

Optional IDs (include when data exists): appendix-ai, appendix-config, appendix-security.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>GCP to AWS Migration Assessment</title>
  <style>
    /* All CSS inline — see CSS specification below */
  </style>
</head>
<body>
  <div class="report">
    <div class="executive-summary">
      <section id="decision-summary"><!-- Section 0 --></section>
      <section id="exec-services"><!-- Primary services --></section>
      <section id="exec-costs"><!-- Cost headline --></section>
      <section id="exec-timeline"><!-- Timeline --></section>
      <section id="exec-risks"><!-- Top risks --></section>
    </div>
    <div class="appendix">
      <section id="appendix-services"><!-- Appendix A --></section>
      <section id="appendix-costs"><!-- Appendix B --></section>
      <section id="appendix-steps"><!-- Appendix C --></section>
      <!-- <section id="appendix-ai"> when AI artifacts exist -->
      <section id="appendix-artifacts"><!-- Appendix E --></section>
      <!-- <section id="appendix-config"> when preferences.json exists -->
      <!-- <section id="appendix-security"> Appendix G -->
    </div>
    <footer>
      Generated by GCP to AWS Migration Advisor — draft for review; verify figures against source JSON artifacts before executive sign-off.
    </footer>
  </div>
</body>
</html>
CSS Specification

The inline CSS must include:

Layout:

  • body: font-family system-ui, -apple-system, sans-serif; max-width 900px; margin 0 auto; padding 40px 20px; color #1a1a2e; background #ffffff; line-height 1.6

  • .report: single container

Typography:

  • h1: font-size 1.8rem; color #1a1a2e; border-bottom 3px solid #ff9900; padding-bottom 8px

  • h2: font-size 1.4rem; color #232f3e; margin-top 2rem

  • h3: font-size 1.1rem; color #545b64

Tables:

  • table: width 100%; border-collapse collapse; margin 1rem 0

  • th: background #232f3e; color white; padding 10px 12px; text-align left; font-size 0.85rem

  • td: padding 8px 12px; border-bottom 1px solid #e8e8e8; font-size 0.85rem

  • tr:hover: background #f5f5f5

Cards (for executive summary metrics):

  • .metric-card: display inline-block; background #f8f9fa; border 1px solid #e8e8e8; border-radius 8px; padding 16px 24px; margin 8px; text-align center; min-width 160px

  • .metric-value: font-size 1.6rem; font-weight bold; color #232f3e

  • .metric-label: font-size 0.8rem; color #687078; text-transform uppercase

Cost comparison highlight:

  • .cost-savings: color #067d68 (green for savings)

  • .cost-increase: color #d13212 (red for increase)

Warning callout (for human_expertise_required):

  • .callout-warning: background #fff8e1; border-left 4px solid #ff9900; padding 12px 16px; margin 1rem 0; border-radius 0 4px 4px 0

Confidence badges (visible text = user-facing vocabulary, not JSON):

  • .badge: display inline-block; padding 2px 8px; border-radius 12px; font-size 0.75rem; font-weight 600

  • .badge-deterministic: background #e6f4ea; color #137333 — label Standard pairing

  • .badge-inferred: background #fef7e0; color #b05a00 — label Tailored to your setup

  • .badge-billing: background #fce8e6; color #c5221f — label Estimated from billing only

Verdict badges (Section 0):

  • .badge-verdict-migrate: background #e6f4ea; color #137333 — migrate_optimized

  • .badge-verdict-phased: background #e8f0fe; color #1a73e8 — migrate_phased

  • .badge-verdict-stay: background #fef7e0; color #b05a00 — stay

  • .badge-complexity: background #f1f3f4; color #545b64 — complexity signal

Print styles:

  • @media print: hide nothing, adjust margins, ensure page breaks before .appendix

Footer:

  • footer: margin-top 3rem; padding-top 1rem; border-top 1px solid #e8e8e8; text-align center; color #687078; font-size 0.8rem

Content Rules
  1. All data must come from artifacts — do not invent numbers or services. If an artifact field is missing, omit that section.

  2. Currency formatting: All cost values displayed as $X,XXX.XX with dollar sign and commas.

  3. Percentage formatting: Include + or - prefix. Use green styling for savings, red for increases.

  4. No external resources: No CDN links, no external fonts, no images. Everything inline.

  5. Valid HTML5: Output must be valid, well-formed HTML5.

Step 4: Self-Check

After generating the HTML file, verify:

  1. Required section IDs: decision-summary, exec-services, exec-costs, exec-timeline, exec-risks, appendix-services, appendix-costs, appendix-steps, appendix-artifacts each appear exactly once as <section id="...">. If any missing: treat as build failure (warn user; do not fail Generate phase).

  2. Data accuracy: Cost figures in HTML match the estimation artifact values exactly

  3. Conditional sections: AI appendix only present if AI artifacts exist; billing caveats shown when billing_data_available is false; Bedrock monitoring row only when bedrock_monitoring.tf exists; startup credits callout only when STARTUP_PROGRAMS.md or preference indicates eligibility

  4. Section 0: Migration Decision Summary present when estimation or preview artifacts exist; uses recommendation.path_label when block present

  5. Human expertise flags: Warning callouts appear for all services with human_expertise_required: true

  6. Valid HTML: Opening and closing tags match, no broken table structures

  7. No placeholders: No [placeholder] or TODO text in the report output

  8. Footer disclaimer: Footer contains "draft for review"

Step 5: Open Report in Browser

After writing the HTML file, open it in the user's default browser so they can view it immediately.

Run: open "$MIGRATION_DIR/migration-report.html" (macOS) or xdg-open "$MIGRATION_DIR/migration-report.html" (Linux).

If the open command fails, fall back to presenting the full file path to the user:

Migration report ready — open in your browser:
file://$MIGRATION_DIR/migration-report.html

Completion

Report to the parent orchestrator. Do NOT update .phase-status.json — the parent generate.md handles phase completion.

Output:

Migration report saved to $MIGRATION_DIR/migration-report.html

Report sections:
- Executive Summary: Section 0 Migration Decision Summary, [services count] primary services, [cost comparison], [timeline]
- Appendix A: Service Recommendations
- Appendix B: Cost Estimates
- Appendix C: Migration Steps
- [Appendix D: AI Migration — if applicable]
- Appendix E: Artifacts Catalog
- [Appendix F: Your Configuration — if preferences.json exists]
- Appendix G: Security Capabilities

Requirements and compatibility

Written for: Claude Code

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Names Claude Code tools, Needs an MCP server

Security

What our scanner noticed· Low risk

  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Cline
Publisher
Cline (Official)
Source
cline/skills · skills/gcp-to-aws · commit 2637846
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Cline.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download gcp-to-aws.zip