Implementation Plan Generator

Produce a deterministic, execution-ready implementation plan including local dev runbook and CI/CD setup. This skill does not execute – it only generates the plan.

Prerequisites

• •Selected stack from stack-selection
• •Architecture brief from architecture-refinement

Plan Phases

The implementation plan covers 10 mandatory phases:

1. •Foundation - Accounts, environments, regions, DNS
2. •Networking & Security - IAM, secrets, network boundaries
3. •Data Layer - Database provisioning, backups, migrations
4. •Local Development - Local orchestration, dependencies, parity
5. •CI/CD Pipeline - Build, test, deploy automation
6. •Application Delivery - Scaffolding, runtime config
7. •Observability - Logging, metrics, tracing, alerting
8. •Cost Controls - Budgets, guardrails, tagging
9. •Reliability - DR strategy, failover, RTO/RPO
10. •Hardening - Security hardening, runbooks

The following phases have dedicated standalone skills that can also be invoked directly:

• •local-dev-plan - Phase 4: Generate local development environment plans
  • •"Create a local dev setup for React + PostgreSQL"
• •cicd-plan - Phase 5: Generate CI/CD pipeline configurations
  • •"Create GitHub Actions workflow for my app"

Output Contract

implementation_plan:
  plan_id: "<unique id>"
  created_at: "<ISO timestamp>"
  stack_id: "<reference>"

  assumptions:
    - "<assumption>"

  phases:
    - phase: 1
      name: "Foundation"
      goals: []
      steps:
        - id: "1.1"
          name: "<step name>"
          description: "<description>"
          outputs: []

    - phase: 2
      name: "Networking & Security Baseline"
      goals: []
      steps: []

    - phase: 3
      name: "Data Layer Setup"
      goals: []
      steps: []

    - phase: 4
      name: "Local Development Environment"
      goals: []
      steps: []

    - phase: 5
      name: "CI/CD Pipeline"
      goals: []
      steps: []

    - phase: 6
      name: "Application Delivery"
      goals: []
      steps: []

    - phase: 7
      name: "Observability"
      goals: []
      steps: []

    - phase: 8
      name: "Cost Controls"
      goals: []
      steps: []

    - phase: 9
      name: "Reliability Posture"
      goals: []
      steps: []

    - phase: 10
      name: "Hardening Checklist"
      goals: []
      steps: []

  summary:
    total_phases: 10
    total_steps: <count>
    critical_decisions: []
    risks:
      - risk: "<risk>"
        mitigation: "<mitigation>"

Phase 1: Foundation

Goals: Set up cloud accounts, define environments, configure access

Steps:

• •1.1 Create Cloud Accounts/Projects
• •1.2 Define Environment Model (dev/staging/prod)
• •1.3 Configure Regions
• •1.4 Set Up DNS

Phase 2: Networking & Security

Goals: Implement least-privilege, secrets management, network security

Steps:

• •2.1 Design IAM Model
• •2.2 Configure Secrets Management
• •2.3 Define Network Boundaries
• •2.4 Apply Security Policies

Phase 3: Data Layer

Goals: Provision database, configure backups, establish migrations

Steps:

• •3.1 Provision Database
• •3.2 Configure Backups
• •3.3 Set Up Migrations
• •3.4 Configure HA/Replication (if required)

Phase 4: Local Development

Use the local-dev-plan skill for detailed planning (can be invoked directly).

Goals: Enable full local development, minimize time-to-first-run

Key outputs:

• •Local orchestration setup (docker-compose/k8s/hybrid/aspire)
• •Dependencies runbook
• •Seeding & migrations workflow
• •Local secrets strategy
• •Prod parity documentation

Offline Considerations (when required)

If offline requirement is transient or higher, include:

• •

  Offline Storage Strategy:

  • •Technology selection (IndexedDB, SQLite WASM, localStorage)
  • •Data model for offline access
  • •Storage limits and quota handling
• •

  Sync Strategy:

  • •Background sync implementation
  • •Conflict resolution approach (last-write-wins, merge, CRDT)
  • •Retry and backoff policies
• •

  Failure Modes:

  • •Network detection and status handling
  • •Graceful degradation patterns
  • •User feedback during offline/sync states
• •

  Testing Offline Scenarios:

  • •Offline mode simulation in local dev
  • •Sync conflict test cases
  • •Data integrity verification

Phase 5: CI/CD Pipeline

Use the cicd-plan skill for detailed planning (can be invoked directly).

Goals: Automate build/test/deploy, enforce quality gates

Key outputs:

• •Repository structure
• •Branching strategy
• •CI pipeline (build, test, lint, security scan)
• •CD pipeline per environment
• •Rollback procedures

Phase 6: Application Delivery

Goals: Scaffold application, configure runtime

Steps:

• •6.1 Application Scaffolding
• •6.2 Runtime Configuration
• •6.3 Environment Variable Contract
• •6.4 Deployment Topology

Phase 7: Observability

Goals: Centralized logging, metrics, tracing, alerting

Steps:

• •7.1 Logging Setup
• •7.2 Metrics Setup
• •7.3 Dashboards
• •7.4 Tracing Setup
• •7.5 Alerting

Phase 8: Cost Controls

Goals: Budget visibility, guardrails, attribution

Steps:

• •8.1 Budget Alerts
• •8.2 Cost Guardrails
• •8.3 Tagging Strategy

Phase 9: Reliability

Goals: Meet availability target, implement DR

Steps:

• •9.1 DR Strategy
• •9.2 Failover Configuration
• •9.3 RTO/RPO Validation

Phase 10: Hardening

Goals: Security hardening, operational readiness

Steps:

• •10.1 Security Hardening Checklist
• •10.2 Operational Runbooks
• •10.3 Operational Readiness Review

Next Step

This plan is ready for execution. Consider invoking skill-improvement at end of flow to capture learnings.