Claude Code Accelerators

Claude reads what an application already has, including its Copilot manifest, its own Terraform, its Dockerfiles and CI workflows. From those it writes the application's single app.yaml, deriving ports, health checks and build contexts rather than guessing them. It also classifies the application and wires it to shared identity.

What it catches

• Storage that won't survive containers: SQLite files and local JSON data on ephemeral task storage are flagged as blockers instead of being quietly lost on the next deploy
• Dependencies nobody uses: a declared cache or queue the code never connects to is removed rather than provisioned and paid for
• Driver-specific connection strings: postgresql:// vs postgresql+asyncpg:// mismatches that break a healthy database
• Collisions: overlapping network ranges, plus the DNS and certificate records the old pipeline still owns

Adoption is mostly deletion. Each application's hand-built pipeline is replaced by one manifest and two small Terraform roots, so there is less infrastructure code to maintain, not more.

Ask "what would it take to run this on Kubernetes?" and Claude renders the answer from the application's existing app.yaml. You get the Kubernetes manifests or Cloud Foundry manifest it would apply, plus a list of the things that don't carry over. The application doesn't have to be moved first.

What it produces

• Kubernetes: namespace per environment, Deployments, Services, Ingress, HorizontalPodAutoscalers, and backing-service bindings as Secrets or Crossplane-style claims
• Cloud Foundry: an application manifest, the cf create-service plan from the foundation's marketplace, and service bindings
• A precise gap list: platform-specific settings to replace, Dockerfiles a buildpack would ignore, services a stack has no mapping for

Pushing is previewed by default. It refuses when cf is targeted at the wrong org or space, or when the Kubernetes context isn't the one the stack catalog declares.

The gap list isn't guesswork. Every stack answers to the same written contract, ten obligations covering catalog, build, run, brokered services, explicit binding, secrets, routing, target guards and preview. A stack that can't meet one says so, and the skill reports it before anything is pushed.

On AWS Fargate, Claude stands up the infrastructure and checks which secrets still hold placeholders, then dispatches the CD pipeline, all from one place with no switching between repositories. Static sites deploy with a single guarded apply that uploads content and invalidates the CDN only when something changed.

Guards Claude cannot talk its way past

• Wrong cloud account: refused before Terraform ever contacts state storage
• Unpushed or mismatched code: a deploy of commits the pipeline can't see is refused; a branch that differs from what CD will build is flagged
• Placeholder secrets: CD won't deploy until required values are real, and Claude never writes secret values itself
• Destructive operations: teardown needs a typed confirmation and an explicit flag to touch the live colour
• Honest reporting: "dispatched" is never reported as "deployed"

Claude answers "what do we have?" from the stack catalogs and each application's own manifest, read fresh every time. There's no separate inventory to fall out of date. Doctor checks every application on every stack and reports each inconsistency: manifests that disagree with a catalog, apps that won't render for a stack they're listed on, AI model plans the marketplace doesn't offer.

It reads files, not live services, so it works offline, in CI, and on the day something is down.