cicd-pipeline-generator

Q: How do I install cicd-pipeline-generator?

Run npx skills add https://github.com/ailabs-393/ai-labs-claude-skills --skill cicd-pipeline-generator in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/cicd-pipeline-generator/ (personal) or .claude/skills/cicd-pipeline-generator/ (project).

by ailabs-393DevOps & Cloud

This skill should be used when creating or configuring CI/CD pipeline files for automated testing, building, and deployment. Use this for generating GitHub Actions workflows, GitLab CI configs, CircleCI configs, or other CI/CD platform configurations. Ideal for setting up automated pipelines for Node.js/Next.js applications, including linting, testing, building, and deploying to platforms like Vercel, Netlify, or AWS.

Installs: 980
Last 24h: —
Trending rank: —
Security: Not audited

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/ailabs-393/ai-labs-claude-skills --skill cicd-pipeline-generator

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads cicd-pipeline-generator automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

SKILL.md

The instructions your agent reads when the skill is triggered.

CI/CD Pipeline Generator

Overview

Generate production-ready CI/CD pipeline configuration files for various platforms (GitHub Actions, GitLab CI, CircleCI, Jenkins). This skill provides templates and guidance for setting up automated workflows that handle linting, testing, building, and deployment for modern web applications, particularly Node.js/Next.js projects.

Core Capabilities

1. Platform Selection

Choose the appropriate CI/CD platform based on project requirements:

GitHub Actions: Best for GitHub-hosted projects with native integration
GitLab CI/CD: Ideal for GitLab repositories with complex pipeline needs
CircleCI: Optimized for Docker workflows and fast build times
Jenkins: Suitable for self-hosted, highly customizable environments

Refer to references/platform-comparison.md for detailed platform comparisons, pros/cons, and use case recommendations.

2. Pipeline Configuration Generation

Generate pipeline configs following these principles:

Pipeline Stages

Structure pipelines with these standard stages:

Install Dependencies
- Checkout code from repository
- Setup runtime environment (Node.js version)
- Restore cached dependencies
- Install dependencies with npm ci
- Cache dependencies for future runs
Lint
- Run ESLint for code quality
- Run TypeScript type checking
- Fail fast on linting errors
Test
- Execute unit tests
- Execute integration tests
- Generate code coverage reports
- Upload coverage to reporting services (Codecov, Coveralls)
Build
- Create production build
- Verify build succeeds
- Store build artifacts
Deploy
- Deploy to staging (develop branch)
- Deploy to production (main branch)
- Run post-deployment smoke tests

Caching Strategy

Implement effective caching to speed up builds:

# Cache node_modules based on package-lock.json
cache:
  key: ${{ hashFiles('package-lock.json') }}
  paths:
    - node_modules/
    - .npm/

Environment Variables

Configure necessary environment variables:

NODE_ENV: Set to production for builds
Platform-specific tokens: Store as secrets
Build-time variables: Pass to build process

3. Template Usage

Use provided templates from assets/ directory:

GitHub Actions Template (assets/github-actions-nodejs.yml):

Multi-job workflow with lint, test, build, deploy
Matrix builds for multiple Node.js versions (optional)
Vercel deployment integration
Artifact uploading
Code coverage reporting

GitLab CI Template (assets/gitlab-ci-nodejs.yml):

Multi-stage pipeline
Dependency caching
Manual production deployment
Automatic staging deployment
Coverage reporting

To use a template:

Copy the appropriate template file
Place in the correct location:
- GitHub Actions: .github/workflows/ci.yml
- GitLab CI: .gitlab-ci.yml
Customize deployment targets, environment variables, and branch names
Add required secrets to platform settings

4. Deployment Configuration

Vercel Deployment

For GitHub Actions:

- uses: amondnet/vercel-action@v25
  with:
    vercel-token: ${{ secrets.VERCEL_TOKEN }}
    vercel-org-id: ${{ secrets.VERCEL_ORG_ID }}
    vercel-project-id: ${{ secrets.VERCEL_PROJECT_ID }}
    vercel-args: '--prod'

Required Secrets:

VERCEL_TOKEN: Get from Vercel account settings
VERCEL_ORG_ID: From Vercel project settings
VERCEL_PROJECT_ID: From Vercel project settings

Netlify Deployment

- run: |
    npm install -g netlify-cli
    netlify deploy --prod --dir=.next
  env:
    NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
    NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }}

AWS S3 + CloudFront

- uses: aws-actions/configure-aws-credentials@v4
  with:
    aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
    aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
    aws-region: us-east-1

- run: |
    aws s3 sync .next/static s3://${{ secrets.S3_BUCKET }}/static
    aws cloudfront create-invalidation --distribution-id ${{ secrets.CF_DIST_ID }} --paths "/*"

5. Testing Integration

Configure test execution with proper reporting:

Jest Configuration:

- name: Run tests with coverage
  run: npm test -- --coverage --coverageReporters=text --coverageReporters=lcov

- name: Upload coverage
  uses: codecov/codecov-action@v4
  with:
    files: ./coverage/lcov.info
    flags: unittests

Fail Fast Strategy:

# Run quick tests first
jobs:
  lint:  # Fails in ~30 seconds
  test:  # Fails in ~2 minutes
  build: # Fails in ~5 minutes
    needs: [lint, test]
  deploy:
    needs: [build]

6. Branch-Based Workflows

Implement different behaviors per branch:

Feature Branches / PRs:

Run lint + test only
No deployment
Add PR comments with test results

Develop Branch:

Run lint + test + build
Deploy to staging environment
Automatic deployment

Main Branch:

Run lint + test + build
Deploy to production
Manual approval (optional)
Create release tags

Example:

deploy_staging:
  if: github.ref == 'refs/heads/develop'
  # Deploy to staging

deploy_production:
  if: github.ref == 'refs/heads/main'
  environment: production  # Requires manual approval
  # Deploy to production

Workflow Decision Tree

Follow this decision tree to generate the appropriate pipeline:

Which platform?
- GitHub → Use assets/github-actions-nodejs.yml
- GitLab → Use assets/gitlab-ci-nodejs.yml
- CircleCI/Jenkins → Adapt GitHub Actions template
- Unsure → Consult references/platform-comparison.md
What stages are needed?
- Always include: Lint, Test, Build
- Optional: Security scanning, E2E tests, performance tests
- Add deployment stage if deploying from CI
Which deployment platform?
- Vercel → Use Vercel deployment examples
- Netlify → Use Netlify CLI approach
- AWS → Use AWS Actions/CLI
- Custom → Implement custom deployment script
What triggers?
- On push to main/develop
- On pull request
- On tag creation
- Manual workflow dispatch
What environment variables needed?
- Platform tokens (Vercel, Netlify, AWS)
- API keys for external services
- Build-time environment variables
- Feature flags

Best Practices

Security

Store all secrets in platform secret management (never in code)
Use least-privilege tokens (read-only when possible)
Rotate secrets regularly
Audit secret access permissions
Never log secrets (use *** masking)

Performance

Cache dependencies aggressively
Parallelize independent jobs
Use matrix builds for multi-version testing
Fail fast: Run quick checks before slow ones
Optimize Docker layer caching

Reliability

Pin exact Node.js versions (18.x not just 18)
Commit lockfiles (package-lock.json)
Add retry logic for flaky external services
Set reasonable timeouts (10-15 minutes max)
Use continue-on-error for non-critical steps

Maintainability

Add comments explaining complex logic
Use reusable workflows/templates
Keep configs DRY (Don't Repeat Yourself)
Version control all pipeline changes
Document required secrets in README

Common Patterns

Multi-Environment Deployment

deploy_staging:
  environment: staging
  if: github.ref == 'refs/heads/develop'

deploy_production:
  environment: production
  if: github.ref == 'refs/heads/main'
  needs: [deploy_staging]

Matrix Testing

strategy:
  matrix:
    node-version: [16.x, 18.x, 20.x]
    os: [ubuntu-latest, windows-latest]

Conditional Steps

- name: Deploy
  if: github.event_name == 'push' && github.ref == 'refs/heads/main'
  run: npm run deploy

Artifact Management

- name: Upload build
  uses: actions/upload-artifact@v4
  with:
    name: build-output
    path: .next/
    retention-days: 7

- name: Download build
  uses: actions/download-artifact@v4
  with:
    name: build-output

Troubleshooting

Pipeline Failures

Check action/job logs for error messages
Verify environment variables and secrets are set
Test commands locally before adding to pipeline
Check for platform-specific issues in documentation

Slow Builds

Verify cache is working (check cache hit/miss logs)
Parallelize independent jobs
Use faster runners if available
Optimize dependency installation

Deployment Failures

Verify deployment tokens are valid
Check platform status pages
Review deployment logs
Test deployment commands locally

Resources

Templates (`assets/`)

github-actions-nodejs.yml: Complete GitHub Actions workflow
gitlab-ci-nodejs.yml: Complete GitLab CI pipeline

Reference Documentation (`references/`)

platform-comparison.md: Detailed comparison of CI/CD platforms, deployment targets, best practices, and common patterns

Example Usage

User Request: "Create a GitHub Actions workflow that runs tests and deploys to Vercel"

Steps:

Copy assets/github-actions-nodejs.yml template
Create .github/workflows/ directory if it doesn't exist
Save as .github/workflows/ci.yml
Update deployment section with Vercel credentials
Add secrets to GitHub repository settings:
- VERCEL_TOKEN
- VERCEL_ORG_ID
- VERCEL_PROJECT_ID
Commit and push to trigger workflow

User Request: "Set up GitLab CI with staging and production environments"

Steps:

Copy assets/gitlab-ci-nodejs.yml template
Save as .gitlab-ci.yml in repository root
Configure GitLab CI/CD variables:
- VERCEL_TOKEN
- Other deployment credentials
Review manual approval settings for production
Commit to trigger pipeline

Advanced Configuration

Monorepo Support

paths:
  - 'apps/frontend/**'
  - 'packages/**'

Scheduled Runs

on:
  schedule:
    - cron: '0 2 * * *'  # Daily at 2 AM

External Service Integration

- name: Notify Slack
  uses: 8398a7/action-slack@v3
  with:
    status: ${{ job.status }}
    webhook_url: ${{ secrets.SLACK_WEBHOOK }}

Security Scanning

- name: Run security audit
  run: npm audit --audit-level=moderate

- name: Check for vulnerabilities
  uses: snyk/actions/node@master
  env:
    SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}

FAQ

What does the cicd-pipeline-generator skill do?

How do I install cicd-pipeline-generator?

Run npx skills add https://github.com/ailabs-393/ai-labs-claude-skills --skill cicd-pipeline-generator in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/cicd-pipeline-generator/ (personal) or .claude/skills/cicd-pipeline-generator/ (project).

Which AI agents can use cicd-pipeline-generator?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is cicd-pipeline-generator safe to install?

No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.

Who maintains cicd-pipeline-generator?

It is published by ailabs-393 in ailabs-393/ai-labs-claude-skills. It has 980 recorded installs.