Most CI/CD pipelines have the same bottleneck, and it’s not the code. Tests pass, the PR merges, and then someone has to build the image, check environment variables, run the Terraform plan, deploy, and verify the health check. Each step is a context switch. Each one is a chance for something to slip.

Agent skills can run the full deploy sequence in a single session. Define the steps once, the agent runs them in order, and you get a pass/fail report at the end. Here’s how to wire them together.

Map your pipeline to skills

A typical deploy has five stages, and each one maps to a skill:

  1. Pre-deploy validation — env vars, migration status, rollback readiness
  2. Container build — generate or audit Dockerfiles, build images
  3. Infrastructure provisioning — plan and apply IaC changes
  4. Deploy — push to your platform (Cloudflare, Netlify, VPS, etc.)
  5. Post-deploy verification — E2E tests, health endpoints, release confirmation

You don’t need all five. A static site on Netlify skips steps 2 and 3. A Terraform-heavy backend might skip 4 if the apply handles the rollout. Match the pipeline to your stack.

Stage 1: Pre-deploy validation

The Deployment Validator skill runs a checklist before anything ships. Env vars exist and aren’t empty. Database migrations are current. Health endpoints respond. Rollback plan is reviewed.

Install: gh skill install VoltAgent/awesome-agent-skills/deployment-validator

Run this after CI passes and before the deploy starts. The agent reads your env template, diffs it against what’s actually set in the target environment, and flags anything missing. If your rollback plan is “redeploy the previous image,” it confirms that image still exists in your registry.

Output is a structured report: what passed, what failed, and a drafted notification for your team. Anything fails, the pipeline stops. No deploy until every check is green.

Stage 2: Container builds

The Docker Containerization Skill generates Dockerfiles and docker-compose configs, but the CI/CD use case is auditing. Point it at an existing Dockerfile and it catches the stuff that causes slow builds or security issues in production.

Install: gh skill install docker/labs-ai-tools-for-devs

It checks layer ordering (dependencies before source code, so cache hits work), non-root user config, health check definitions, and whether you’re accidentally copying test fixtures or node_modules into your production image. That last one is more common than anyone admits.

For multi-service projects, it generates docker-compose configs with correct networking, volume mounts, and dependency ordering. It also catches the “works on my machine” problems: platform-specific base images, BuildKit features missing in older Docker versions, and .dockerignore files that don’t actually exclude what they should.

Stage 3: Infrastructure provisioning

This one is straightforward. The Terraform skill runs terraform plan, reads the output, and tells you in plain language what will change: new resources, modified resources, destroyed resources.

Install: gh skill install hashicorp/agent-skills/terraform

The pattern is plan-then-gate. The agent formats the diff and waits for approval before applying. In an automated pipeline, configure it to auto-apply if the plan only adds or modifies resources, and auto-block if it destroys anything. That single rule prevents most infrastructure accidents.

The other use case is drift detection. Schedule a weekly plan-only run. If someone made a manual change in the console or a provider updated its defaults, the agent flags it before your next real deploy surfaces the problem for you.

Stage 4: Platform deploy

This depends on where you’re deploying. Two skills cover the most common targets.

The Cloudflare Wrangler Skill deploys Workers, sets environment secrets, runs D1 migrations, and manages KV/R2 bindings. Install: gh skill install cloudflare/wrangler

The Netlify Functions Skill handles serverless function deploys, scheduled tasks, edge functions, and environment variables. It also manages deploy previews for PR-based workflows. Install: gh skill install netlify/netlify-functions

If you’re deploying to a VPS or Kubernetes, no dedicated skill needed. The agent runs deploy scripts through the shell. A dedicated skill gives you tighter error handling and structured output, but kubectl apply or ssh deploy@prod ./deploy.sh works fine here.

Stage 5: Post-deploy verification

The Web App Tester skill runs Playwright against your live deployment. It navigates pages, fills forms, clicks through critical flows, and screenshots anything that fails.

Install: gh skill install anthropics/skills/web-app-tester

After deploy, point it at your production URL with the flows that matter: login, core feature, payment if applicable, logout. Pass/fail for each flow, with screenshots of failure states so you see exactly what broke.

For API-only services, skip the browser testing. A curl to /health checking for a 200 and valid JSON is often enough. The Deployment Validator handles this too, so you can reuse it post-deploy.

Wiring them together

Individual skills are useful. Chaining them is where it gets interesting. Here’s a full pipeline for a containerized app deploying to production:

1. Deployment Validator  — check env vars, migrations, rollback plan
2. Docker Skill          — audit Dockerfile, build image
3. Terraform             — plan infra changes, apply if safe
4. Platform deploy       — push image / deploy function
5. Web App Tester        — run E2E against production

In Claude Code, this runs as a single session. Tell the agent: “Run the deploy pipeline for staging.” It picks up each skill in order, stops on any failure, and reports the result.

Missing env var in step 1? The agent never reaches step 2. Terraform plan shows a resource destruction? It stops and asks for confirmation. Broken login flow in step 5? You know before users do.

Each skill produces structured output that feeds the next one. The validator confirms the environment is ready, so Docker knows it can build. Terraform confirms infrastructure is current, so the deploy can proceed. One step’s success is the next step’s precondition.

Start small

You don’t need the full five-stage pipeline on day one. Pick the stage where you lose the most time or make the most mistakes. For most teams, that’s either pre-deploy validation or post-deploy testing. Install one skill, run it manually a few times, and expand from there.

Grow the pipeline from pain, not ambition. Never forgotten an environment variable? Skip the validator. Dockerfiles already solid? Skip the audit. Automate the parts that actually break.

FAQ

Can I run this in GitHub Actions instead of locally?

Some teams trigger a Claude Code session from a GitHub Action on every merge to main. The skills work the same way, they just execute in CI instead of on your machine. You need the agent runtime available in your CI environment.

What happens if a skill fails mid-pipeline?

The agent stops and reports what happened. No subsequent steps run. Fix the issue, re-run from the failed step. Skills don’t have side effects on failure: a failed Terraform plan doesn’t apply anything, a failed Docker build doesn’t push an image.

Do I need all these skills for a static site?

No. A Netlify static site might only need the Netlify Functions Skill for deploys and the Web App Tester for smoke tests. Skip Docker, skip Terraform.