home / skills / aidotnet / moyucode / ci-cd-generator

ci-cd-generator skill

/skills/community/ci-cd-generator

This skill generates production-ready CI/CD pipelines for GitHub Actions, GitLab CI, Azure DevOps, and Jenkins across build, test, deploy, caching, and secrets.

npx playbooks add skill aidotnet/moyucode --skill ci-cd-generator

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.4 KB
---
name: ci-cd-generator
description: 为GitHub Actions、GitLab CI、Azure DevOps和Jenkins生成CI/CD流水线,包含构建、测试、部署阶段、缓存和密钥管理。
metadata:
  short-description: 生成CI/CD流水线配置
---

# CI/CD Generator Skill

## Description
Generate continuous integration and deployment pipelines for various platforms.

## Trigger
- `/cicd` command
- User requests CI/CD configuration
- User needs deployment pipeline

## Prompt

You are a DevOps expert that creates production-ready CI/CD pipelines.

### GitHub Actions - Full Stack App

```yaml
name: CI/CD Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

env:
  NODE_VERSION: '20'
  DOTNET_VERSION: '8.0.x'

jobs:
  test-frontend:
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: ./web
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'
          cache-dependency-path: web/package-lock.json
      
      - name: Install dependencies
        run: npm ci
      
      - name: Lint
        run: npm run lint
      
      - name: Type check
        run: npm run typecheck
      
      - name: Test
        run: npm run test -- --coverage
      
      - name: Build
        run: npm run build

  test-backend:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}
      
      - name: Restore dependencies
        run: dotnet restore
      
      - name: Build
        run: dotnet build --no-restore
      
      - name: Test
        run: dotnet test --no-build --verbosity normal

  deploy:
    needs: [test-frontend, test-backend]
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/checkout@v4
      
      - name: Deploy to Azure
        uses: azure/webapps-deploy@v2
        with:
          app-name: ${{ secrets.AZURE_APP_NAME }}
          publish-profile: ${{ secrets.AZURE_PUBLISH_PROFILE }}
```

### GitLab CI

```yaml
stages:
  - test
  - build
  - deploy

variables:
  NODE_VERSION: "20"

cache:
  key: ${CI_COMMIT_REF_SLUG}
  paths:
    - node_modules/
    - .npm/

test:
  stage: test
  image: node:${NODE_VERSION}
  script:
    - npm ci --cache .npm
    - npm run lint
    - npm run test -- --coverage
  coverage: '/Lines\s*:\s*(\d+\.?\d*)%/'
  artifacts:
    reports:
      coverage_report:
        coverage_format: cobertura
        path: coverage/cobertura-coverage.xml

build:
  stage: build
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

deploy:
  stage: deploy
  only:
    - main
  script:
    - kubectl set image deployment/app app=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
```

### Docker Build & Push

```yaml
- name: Build and push Docker image
  uses: docker/build-push-action@v5
  with:
    context: .
    push: true
    tags: |
      ghcr.io/${{ github.repository }}:latest
      ghcr.io/${{ github.repository }}:${{ github.sha }}
    cache-from: type=gha
    cache-to: type=gha,mode=max
```

## Tags
`ci-cd`, `devops`, `automation`, `github-actions`, `deployment`

## Compatibility
- Codex: ✅
- Claude Code: ✅

Overview

This skill generates production-ready CI/CD pipelines for GitHub Actions, GitLab CI, Azure DevOps, and Jenkins. It produces builds, tests, deployments, caching, and secret management configured for typical full-stack and container workflows. The outputs are practical pipeline templates you can adapt to your project structure and cloud targets.

How this skill works

Provide the repository layout, languages, and target platform and the skill emits a complete pipeline file with stages for install, linting, testing, building, artifact handling, caching, and deployment. It includes secrets wiring, conditional deploys (for main branch), job dependencies, and optional Docker build-and-push steps. Templates include sensible defaults for Node.js, .NET, Docker, and Kubernetes deployments that you can customize.

When to use it

  • You need a ready-to-run CI/CD configuration for GitHub Actions, GitLab CI, Azure DevOps, or Jenkins.
  • You want a consistent pipeline covering build, test, and deploy with caching and artifact handling.
  • You need Docker image build-and-push with registry tagging and cache optimization.
  • You want CI jobs separated by frontend/backend or service boundaries with clear dependencies.
  • You need deployment steps gated to main branch and integrated secret management.

Best practices

  • Specify runtime versions with variables or env to keep pipelines reproducible.
  • Use job-level caches (npm, Docker layer cache) and cache keys tied to lockfiles or commit refs.
  • Separate lint/typecheck/test/build into distinct jobs to speed feedback and allow parallel runs.
  • Protect deploy steps with branch or environment conditions and require successful tests before deployment.
  • Store sensitive values in platform secrets and reference them only in deploy steps.

Example use cases

  • Full-stack repo: separate GitHub Actions jobs for web (Node.js) and API (.NET) with a final Azure Web App deploy.
  • GitLab CI pipeline for Node app: caching node_modules, coverage reporting, Docker build and push to registry, and kubectl image update.
  • Docker-centric workflow: build-and-push action using registry tags for latest and commit SHA with build cache to speed subsequent runs.
  • Monorepo scenario: per-package test jobs that run in parallel, followed by a centralized build and release job.
  • CI for Kubernetes deploys: build image, push to registry, then update deployment image via kubectl or GitOps trigger.

FAQ

Can generated pipelines handle monorepos?

Yes. The skill can create per-package or per-folder jobs with working-directory settings and dependencies to coordinate parallel tests and centralized builds.

How are secrets managed in templates?

Secrets are referenced via platform secret stores (e.g., GitHub Secrets, GitLab CI/CD variables, Azure DevOps Pipelines variables). The templates include placeholders and usage examples for deploy credentials and publish profiles.