Skip to main content
skill CX Codex

devops-automation · rohitg00 — Claude Code skill: CI/CD and setup

The devops-automation skill guides CI/CD design for GitHub Actions and configuration work with Docker, Kubernetes, Helm, and ArgoCD. Use it when planning an application build and deployment flow.

Apache-2.0 ★ 2,858 updated 2026-05-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add rohitg00/awesome-claude-code-toolkit --skill devops-automation -a claude-code
Open on GitHub

What devops-automation does

The skill lays out a GitHub Actions pipeline with separate lint, test, and deploy jobs, a Node.js version matrix, dependency caching, and deployment conditions. Its Docker guidance uses a multi-stage build, runs the final container as a non-root user, and adds a health check.

For Kubernetes, it includes a Deployment manifest with resource requests and probes, a Helm chart layout, and an ArgoCD Application example that syncs cluster state from Git. A Prometheus ServiceMonitor example accompanies advice on metrics, alerts, and secret storage. Check the examples against your project: the Dockerfile starts dist/server.js, while the Kubernetes manifest refers to a secret named api-secrets.

The skill recommends validating charts with helm lint and helm template, and pinning GitHub Actions versions by SHA. These snippets need project-specific edits; names, secrets, and deployment commands are examples, not a drop-in configuration.

What it helps with

  • split GitHub Actions into lint, test, and deploy jobs
  • build a multi-stage Dockerfile for a Node.js app
  • add resource settings and health probes to a Kubernetes Deployment
  • organize Helm values for separate environments
  • sync Kubernetes manifests from Git with ArgoCD

Example prompts for the agent

  • Design GitHub Actions for my app with linting, tests, and a deploy from main.
  • Write a multi-stage Dockerfile for this Node.js app and run the container as a non-root user.
  • Create a Helm chart and an ArgoCD manifest that syncs the app from Git.

How to install devops-automation

1Skills CLI (Vercel)

npx skills add rohitg00/awesome-claude-code-toolkit --skill devops-automation -a claude-code

2Manually: put the files in place

~/.claude/skills/devops-automation/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/devops-automation/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about devops-automation

How do I install devops-automation in Claude Code?

Run npx skills add rohitg00/awesome-claude-code-toolkit --skill devops-automation -a claude-code. The skill file is at ~/.claude/skills/devops-automation/SKILL.md.

What does the devops-automation skill do?

It guides CI/CD pipeline design and configuration for Docker, Kubernetes, Helm, and ArgoCD. It also covers monitoring and pipeline security practices.

How does devops-automation suggest checking a Helm chart?

Run helm lint to check the chart, then use helm template to inspect the rendered manifests before deployment.

Source text

SKILL.md · Apache-2.0
---
name: devops-automation
description: CI/CD pipeline design with GitHub Actions, Docker, Kubernetes, Helm, and GitOps patterns
---

# DevOps Automation

## GitHub Actions Workflow Structure

```yaml
name: CI/CD
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: 'npm'
      - run: npm ci
      - run: npm run lint

  test:
    runs-on: ubuntu-latest
    needs: lint
    strategy:
      matrix:
        node-version: [20, 22]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'
      - run: npm ci
      - run: npm test -- --coverage
      - uses: actions/upload-artifact@v4
        with:
          name: coverage-${{ matrix.node-version }}
          path: coverage/

  deploy:
    runs-on: ubuntu-latest
    needs: test
    if: github.ref == 'refs/heads/main'
    environment: production
    steps:
      - uses: actions/checkout@v4
      - run: ./deploy.sh
```

Key patterns:
- Use `concurrency` to cancel outdated runs
- Cache dependencies with setup action's `cache` option
- Use `needs` for job dependencies
- Gate deploys with `environment` protection rules
- Use matrix for cross-version testing

## Docker Multi-Stage Builds

```dockerfile
FROM node:22-alpine AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --production

FROM node:22-alpine AS builder
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:22-alpine AS runner
WORKDIR /app
RUN addgroup -g 1001 appgroup && adduser -u 1001 -G appgroup -S appuser
COPY --from=deps /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package.json ./
USER appuser
EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=3s CMD wget -qO- http://localhost:3000/health || exit 1
CMD ["node", "dist/server.js"]
```

Rules:
- Use specific image tags, never `latest`
- Run as non-root user
- Copy only necessary files into final stage
- Add `HEALTHCHECK` for orchestrator integration
- Use `.dockerignore` to exclude `node_modules`, `.git`, tests

## Kubernetes Deployment Manifest

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-server
  labels:
    app: api-server
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api-server
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: api-server
    spec:
      containers:
        - name: api
          image: registry.example.com/api:v1.2.3
          ports:
            - containerPort: 3000
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              cpu: 500m
              memory: 512Mi
          readinessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 5
            periodSeconds: 10
          livenessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 15
            periodSeconds: 20
          env:
            - name: DATABASE_URL
              valueFrom:
                secretKeyRef:
                  name: api-secrets
                  key: database-url
```

Always set resource requests and limits. Always define readiness and liveness probes. Use `maxUnavailable: 0` for zero-downtime deploys.

## Helm Chart Structure

```
chart/
  Chart.yaml
  values.yaml
  values-staging.yaml
  values-production.yaml
  templates/
    deployment.yaml
    service.yaml
    ingress.yaml
    hpa.yaml
    _helpers.tpl
```

```yaml
# values.yaml
replicaCount: 2
image:
  repository: registry.example.com/api
  tag: latest
  pullPolicy: IfNotPresent
resources:
  requests:
    cpu: 100m
    memory: 128Mi
  limits:
    cpu: 500m
    memory: 512Mi
ingress:
  enabled: true
  host: api.example.com
autoscaling:
  enabled: true
  minReplicas: 2
  maxReplicas: 10
  targetCPUUtilization: 70
```

Use `values-{env}.yaml` overrides per environment. Lint charts with `helm lint`. Test with `helm template` before deploying.

## ArgoCD GitOps Pattern

```yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: api-server
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/org/k8s-manifests
    targetRevision: main
    path: apps/api-server
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true
```

GitOps principles:
- Git is the single source of truth for cluster state
- All changes go through PRs (no `kubectl apply` in production)
- ArgoCD auto-syncs from Git to cluster
- Enable `selfHeal` to revert manual cluster changes
- Separate app code repos from deployment manifest repos

## Monitoring Stack

```yaml
# Prometheus ServiceMonitor
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: api-server
spec:
  selector:
    matchLabels:
      app: api-server
  endpoints:
    - port: metrics
      interval: 15s
      path: /metrics
```

Key metrics to expose:
- `http_request_duration_seconds` (histogram) - request latency by route and status
- `http_requests_total` (counter) - request count by route and status
- `process_resident_memory_bytes` (gauge) - memory usage
- `db_query_duration_seconds` (histogram) - database query latency

Alert on: error rate >1%, P99 latency >2s, memory >80% of limit, pod restarts >3 in 10 minutes.

## Pipeline Best Practices

1. Keep CI under 10 minutes (parallelize jobs, cache aggressively)
2. Run linting and type checking before tests
3. Use ephemeral environments for PR previews
4. Pin all action versions to SHA, not tags
5. Store secrets in GitHub Secrets, never in workflow files
6. Use OIDC for cloud provider authentication (no long-lived keys)
7. Tag images with git SHA, not `latest`
8. Run security scans (Trivy, Snyk) on container images in CI

© rohitg00 · Apache-2.0 · rohitg00/awesome-claude-code-toolkit

Similar skills

All skills for DevOps and infrastructure →

devops-automation by other authors comes first.

devops-automation claude-office-skills devops-automation — a skill that lays out DevOps workflows: CI/CD pipelines, alert routing, incident response and server provisioning. Useful when you need deploy and on-call steps written down. CX Codex +1 5,000installs devops-cicd miles990 devops-cicd — a skill that hands your agent working templates for pipelines, infrastructure as code and deployment strategies. Useful when you need a real workflow file, not vague advice. CX Codex +1 610installs devops-engineer https://github.com/Jeffallan The devops-engineer skill creates Dockerfiles, CI/CD configs, Kubernetes manifests, and IaC templates. Use it for deployments, platform work, and incident response. CX Codex +1 12,400installs devops mrgoonie devops — a skill for Claude Code that handles deployments to Cloudflare, Docker, Google Cloud and Kubernetes. Also loads in Codex, Cursor, GitHub Copilot, Gemini CLI and OpenCode. CX Codex +1 1,000installs devops-automator curiositech devops-automator — a skill that turns your AI coder into a DevOps engineer: designs pipelines, writes Terraform and Kubernetes configs, sets up GitOps. Use it when building infrastructure or automating deployments. CX Codex +1 219installs devops-excellence majiayu000 devops-excellence enforces DevOps best practices: eliminates root users in containers, strips static secrets, and configures OIDC in pipelines. CX Codex +1 114installs gem-devops-guidelines official github gem-devops-guidelines is a GitHub Copilot skill for reviewing infrastructure, CI/CD, Docker, Kubernetes, and mobile releases. It runs during deployment planning or production readiness checks. CX Codex +1 35installs

From the same set178

The whole set →
legal-advisor legal-advisor creates terms of service, privacy policies, and software licenses matching GDPR or CCPA standards. Connects legal requirements directly to technical safeguards. CX Codex ★ 2,858repo stars benchmarking-specialist The benchmarking-specialist subagent plans benchmarks, load tests, and system comparisons. Use it when performance claims need repeatable measurements and a documented method. CX Codex ★ 2,858repo stars sales-engineer sales-engineer — a subagent that handles the technical side of selling: spins up demo environments, writes proof-of-concept code, builds integration guides, and runs competitive analysis. CX Codex ★ 2,858repo stars academic-researcher academic-researcher runs systematic literature reviews, inspects study methodology, and compiles evidence across papers. Built for technical and scientific research. CX Codex ★ 2,858repo stars technology-scout technology-scout is a Claude Code subagent that evaluates emerging technologies, compares build-versus-buy options, and assesses vendors to inform adoption decisions. CX Codex ★ 2,858repo stars react-patterns react-patterns is a Claude Code skill with React 19 patterns for Server Components, Server Actions, Suspense, and state management. CX Codex +1 ★ 2,858repo stars data-engineering The data-engineering skill offers patterns for ETL pipelines, data warehouses, and Apache Spark jobs. Use it to shape data quality checks and warehouse schemas. CX Codex +1 ★ 2,858repo stars python-best-practices python-best-practices guides Claude Code toward modern Python style: type hints, dataclasses, async code, project layout and pytest setup. CX Codex +1 ★ 2,858repo stars

Project sponsors

Companies that keep this analytics open