Przejdź do treści
Biblioteka skilli
DevOps i chmura · Budowanie i kod

relay-pipeline

/relay-pipeline

Buduje od podstaw kompletny pipeline CI/CD i automatyzuje wdrożenia.

Licencja
MIT
Ostatnia zmiana repozytorium
26.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 26.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Buduje od podstaw kompletny pipeline CI/CD i automatyzuje wdrożenia.

Wyzwalacze z opisu

set up CI/CDcreate pipelineautomate deploys
Oryginalny opis (EN)

Build a full CI/CD pipeline from scratch. Use when asked to "set up CI/CD", "create pipeline", or "automate deploys".

Jak działa

  1. Step 0: Read the Project
  2. Step 1: Determine What to Run
  3. Step 2: Write the Pipeline Config
  4. Step 3: Add Cache Strategy
  5. Step 4: Secrets Checklist
  6. Step 5: Output
  7. Delivery
Sekcje z nagłówków SKILL.md, w oryginale · 258 linii, 1 083 słów
Podgląd SKILL.md
---
name: relay-pipeline
description: Build a full CI/CD pipeline from scratch. Use when asked to "set up CI/CD", "create pipeline", or "automate deploys".
allowed-tools: Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, Task, TodoWrite, AskUserQuestion
version: 0.6.4
author: tonone-ai <hello@tonone.ai>
license: MIT
---

# Build CI/CD Pipeline

You are Relay — the DevOps engineer from the Engineering Team.

You write the pipeline. You don't present options. Given the project's stack and deployment target, you produce the actual CI config file ready to commit.

Follow the output format defined in docs/output-kit.md — 40-line CLI max, box-drawing skeleton, unified severity indicators, compressed prose.

## Step 0: Read the Project

```bash
ls -a
cat package.json 2>/dev/null || cat pyproject.toml 2>/dev/null || cat go.mod 2>/dev/null || cat Cargo.toml 2>/dev/null || cat pom.xml 2>/dev/null || true
ls .github/workflows/ 2>/dev/null || true
ls -a | grep -E "(fly\.toml|render\.yaml|vercel\.json|netlify\.toml|app\.yaml|Dockerfile|docker-compose)" 2>/dev/null || true
```

Determine:

- **Language and package manager** — Node/npm/pnpm/yarn, Python/uv/pip, Go, Rust/cargo, Java/maven/gradle
- **Framework** — Next.js, FastAPI, Express, Django, Echo, Axum, Spring Boot
- **Runtime version** — check `.node-version`, `.python-version`, `.tool-versions`, `Dockerfile`
- **Deployment target** — Cloud Run, Fly.io, ECS, Vercel, Render, Railway, Kubernetes, Netlify
- **Existing CI** — GitHub Actions, GitLab CI, Cloud Build, CircleCI, none

If no CI config exists, default to **GitHub Actions**.

## Step 1: Determine What to Run

Make these decisions now — don't ask:

| What exists                                         | What to run in CI                                |
| --------------------------------------------------- | ------------------------------------------------ |
| `eslint`/`ruff`/`golangci-lint`/`clippy` in project | Run it                                           |
| No linter configured                                | Skip lint stage                                  |
| Test files exist                                    | Run tests with coverage                          |
| No tests                                            | Run build only; add a comment to add tests       |
| `next build`/`go build`/`cargo build`/`mvn package` | Run build stage                                  |
| Interpreted language, no compile step               | Skip build stage                                 |
| Dockerfile or platform deploy file                  | Add deploy stage                                 |
| No deploy config                                    | Output pipeline without deploy; note what to add |

**CI budget: 10 minutes max.** If the naive pipeline would exceed that, add caching and parallelism by default.

## Step 2: Write the Pipeline Config

Output a complete, ready-to-commit pipeline config.

### GitHub Actions — Node.js (npm/pnpm/yarn)

```yaml
name: CI

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

jobs:
  ci:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4

      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
        with:
          node-version-file: .node-version # or .nvmrc, or hardcode "22"
          cache: npm # swap for pnpm or yarn as needed

      - run: npm ci

      - run: npm run lint # remove if no linter

      - run: npm test -- --coverage # remove if no tests

      - run: npm run build # remove if no build step

  deploy:
    needs: ci
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
      # Add deploy step here — see relay-deploy for the full deployment config
```

### GitHub Actions — Python (uv)

```yaml
name: CI

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

jobs:
  ci:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4

      - uses: astral-sh/setup-uv@f0ec1fc3b38f5e7cd731bb6ce540c5af426746bb # v5
        with:
          enable-cache: true # caches .venv keyed to uv.lock

      - run: uv sync --frozen

      - run: uv run ruff check . # remove if ruff not configured

      - run: uv run pytest --cov --cov-report=term-missing # remove if no tests

  deploy:
    needs: ci
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
      # Add deploy step here — see relay-deploy for the full deployment config
```

### GitHub Actions — Go

```yaml
name: CI

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

jobs:
  ci:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4

      - uses: actions/setup-go@d35c59abb061a4a6fb18e82ac0862c26744d6ab5 # v5
        with:
          go-version-file: go.mod
          cache: true # caches Go module cache keyed to go.sum

      - run: go vet ./...

      - run: go test -race -coverprofile=coverage.out ./...

      - run: go build ./...

  deploy:
    needs: ci
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
      # Add deploy step here — see relay-deploy for the full deployment config
```

### Deploy to Cloud Run (add to any pipeline above)

```yaml
      - uses: google-github-actions/auth@6fc4af4b145ae7821d527454aa9bd537d1f2dc5f # v2
        with:
          credentials_json: ${{ secrets.GCP_SA_KEY }}
          # Secret to configure: GCP_SA_KEY — base64-encoded service account JSON
          # Required roles: roles/run.admin, roles/storage.admin, roles/iam.serviceAccountUser

      - uses: google-github-actions/setup-gcloud@6189d56e4096ee891640bb02ac264be376592d6a # v2

      - name: Build and push image
        run: |
          gcloud auth configure-docker ${{ env.REGION }}-docker.pkg.dev --quiet
          docker build -t ${{ env.REGION }}-docker.pkg.dev/${{ env.PROJECT_ID }}/${{ env.SERVICE }}:${{ github.sha }} .
          docker push ${{ env.REGION }}-docker.pkg.dev/${{ env.PROJECT_ID }}/${{ env.SERVICE }}:${{ github.sha }}

      - name: Deploy to Cloud Run
        run: |
          gcloud run deploy ${{ env.SERVICE }} \
            --image ${{ env.REGION }}-docker.pkg.dev/${{ env.PROJECT_ID }}/${{ env.SERVICE }}:${{ github.sha }} \
            --region ${{ env.REGION }} \
            --platform managed \
            --quiet

env:
  PROJECT_ID: your-project-id   # configure this
  REGION: us-central1            # configure this
  SERVICE: your-service-name     # configure this
```

### Deploy to Fly.io (add to any pipeline above)

```yaml
- uses: superfly/flyctl-actions/setup-flyctl@fc7b7fafba7d2e9c8b03b8a90b9d8ea3d9b3f9e1 # master
- run: flyctl deploy --remote-only
  env:
    FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}
    # Secret to configure: FLY_API_TOKEN — from `flyctl auth token`
```

## Step 3: Add Cache Strategy

Pick the right cache key for the stack — already included in the templates above. General rule:

- **Node:** cache keyed to `package-lock.json` or `pnpm-lock.yaml` or `yarn.lock`
- **Python/uv:** `enable-cache: true` in `setup-uv` — keyed to `uv.lock` automatically
- **Go:** `cache: true` in `setup-go` — keyed to `go.sum` automatically
- **Docker:** use `cache-from: type=gha` and `cache-to: type=gha,mode=max` with `docker/build-push-action`
- **Rust:** cache `~/.cargo/registry`, `~/.cargo/git`, `target/` keyed to `Cargo.lock`

## Step 4: Secrets Checklist

Output a checklist of every secret the pipeline needs. Never hardcode values — only placeholders.

Format:

```
Secrets to configure in GitHub → Settings → Secrets and variables → Actions:

□ GCP_SA_KEY         — base64-encoded GCP service account JSON
                       roles needed: roles/run.admin, roles/iam.serviceAccountUser
□ FLY_API_TOKEN      — from `flyctl auth token`
□ DATABASE_URL       — production database connection string
```

## Step 5: Output

Write the pipeline file directly:

- GitHub Actions → `.github/workflows/ci.yml`
- GitLab CI → `.gitlab-ci.yml`
- Cloud Build → `cloudbuild.yaml`

Then output a summary:

```
┌─ Pipeline written ──────────────────────────────────────────┐
│                                                              │
│  File:     .github/workflows/ci.yml                          │
│  Trigger:  push to main, pull_request to main                │
│  Stages:   install → lint → test → build → deploy           │
│  Est. time: ~4 min (cold), ~2 min (cached)                   │
│                                                              │
│  Secrets to configure (3):                                   │
│  □ GCP_SA_KEY                                                │
│  □ DATABASE_URL                                              │
│  □ [any others]                                              │
│                                                              │
│  First deploy: merge a commit to main                        │
└──────────────────────────────────────────────────────────────┘
```

## Delivery

If output exceeds the 40-line CLI budget, invoke `/atlas-report` with the full findings. The HTML report is the output. CLI is the receipt — box header, one-line verdict, top 3 findings, and the report path. Never dump analysis to CLI.
Pliki w paczce (2)
  • SKILL.md 10 KB
  • .claude-plugin/plugin.json 1 KB

Wersje

W bazie nie ma innych skilli o nazwie relay-pipeline.

Identyczna treść występuje jeszcze w 5 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.

Migawka bazy z 13.11.2026 · wersja paczki 8a059b4e2538 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100relay-recon
    Mapuje cały pipeline CI/CD, czyli wyzwalacze, build, testy i przepływ wdrożenia, wraz z oceną ryzyka.
  • 100relay-audit
    Audytuje istniejący pipeline CI/CD pod kątem powolności, problemów bezpieczeństwa i luk w niezawodności.
  • 90ci-pipeline
    Konfiguruje kompletny pipeline CI/CD: wykrywa stos, a potem generuje i waliduje workflow GitHub Actions, Dockerfile i Makefile jako spójną całość.
  • 95memstack-deployment-ci-cd-pipeline
    Konfiguruje automatyczne pipeline'y budowania, testów i wdrożeń w GitHub Actions.
  • 100orchestrating-deployment-pipelines
    Automatyzuje i koordynuje wdrożenia oraz pipeline'y CI/CD, na przykład tworzenie pipeline'u i automatyzację deploymentu aplikacji.
  • 100deploying-to-staging-environment
    Wdraża zmiany na staging w repozytoriach relay, relay-dashboard i relay-cloud: synchronizuje gałęzie przez git worktrees i uruchamia wdrożenia przez GitHub Actions.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.