Claude Code8 min

Claude Code in CI/CD Pipelines: GitHub Actions und GitLab CI

Claude Code in CI/CD integrieren: Headless Mode, GitHub Actions, GitLab CI, Pre-Commit Hooks. Praktische Beispiele mit Code-Snippets.

TL;DR: Claude Code läuft nicht nur im Terminal. Im Headless Mode (claude -p "prompt") integriert er sich in jede CI/CD-Pipeline. GitHub Actions reagiert auf @claude-Mentions in PRs. GitLab CI nutzt den Headless Mode für automatisierte Reviews und Tests. Pre-Commit Hooks fangen Probleme ab, bevor Code das Repository erreicht. Alles mit konkreten Code-Snippets zum Kopieren.

Headless Mode: Die Grundlage

Claude Code hat zwei Modi. Den interaktiven Modus -- du tippst, Claude antwortet. Und den Headless Mode -- Claude Code führt einen Prompt aus und liefert das Ergebnis, ohne menschliche Interaktion.

Grundsyntax

claude -p "Analysiere die Datei src/auth.ts auf Sicherheitslücken"

Der -p Flag steht für "print". Claude Code liest den Prompt, analysiert den Kontext und gibt das Ergebnis auf stdout aus. Kein interaktives Terminal. Kein menschliches Eingreifen nötig. Falls du noch nicht mit Claude Code vertraut bist: Was ist Claude Code? liefert den Einstieg.

Output-Formate

# Plaintext (Standard)
claude -p "Beschreibe die Architektur"

# JSON (strukturiert, für Weiterverarbeitung)
claude -p "Liste alle TODO-Kommentare" --output-format json

# Stream JSON (für Echtzeit-Verarbeitung)
claude -p "Refactore die utils.ts" --output-format stream-json

Das JSON-Format ist für CI/CD entscheidend. Du kannst die Ausgabe parsen, Entscheidungen darauf basieren und nachfolgende Pipeline-Schritte steuern.

Beispiel: JSON-Output verarbeiten

# Claude analysiert Code und gibt strukturiertes Ergebnis zurück
RESULT=$(claude -p "Prüfe src/api/ auf Breaking Changes.
Antworte im Format: {\"breaking\": true/false, \"changes\": [...]}" \
  --output-format json)

# Ergebnis in der Pipeline nutzen
if echo "$RESULT" | jq -r '.result' | jq -r '.breaking' | grep -q "true"; then
  echo "Breaking Changes gefunden!"
  exit 1
fi

GitHub Actions: @claude in Pull Requests

Die GitHub Actions Integration ist der am häufigsten genutzte CI/CD-Einsatz von Claude Code. Ein Entwickler erwähnt @claude in einer PR, und Claude Code reagiert.

Setup

# .github/workflows/claude-review.yml
name: Claude Code Review
on:
  issue_comment:
    types: [created]
  pull_request_review_comment:
    types: [created]
  pull_request:
    types: [opened, synchronize]

jobs:
  claude-review:
    if: |
      github.event_name == 'pull_request' ||
      contains(github.event.comment.body, '@claude')
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
      issues: write
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Claude Code Review
        uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          model: claude-sonnet-4-20250514

Was dieser Workflow tut

  1. Trigger: Jede neue PR und jeder Kommentar mit @claude
  2. Checkout: Das Repository wird ausgecheckt (mit History für Diff-Analyse)
  3. Claude Code: Analysiert den Diff und postet eine Review als Kommentar

Automatische Reviews bei jeder PR

# .github/workflows/auto-review.yml
name: Automatic Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Get diff
        id: diff
        run: |
          DIFF=$(git diff origin/main...HEAD)
          echo "diff<<EOF" >> $GITHUB_OUTPUT
          echo "$DIFF" >> $GITHUB_OUTPUT
          echo "EOF" >> $GITHUB_OUTPUT

      - name: Claude Review
        uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Prüfe diese PR auf:
            1. Sicherheitsprobleme
            2. Performance-Probleme
            3. Code-Style-Verstöße
            4. Fehlende Tests
            Sei konkret. Nenne Datei und Zeile.

Jede PR bekommt automatisch eine Claude-Review. Der menschliche Reviewer sieht Claudes Kommentare und kann sich auf die Punkte konzentrieren, die eine menschliche Einschätzung brauchen.

Features implementieren lassen

@claude Füge einen Rate Limiter für die /api/users Route hinzu.
Nutze express-rate-limit. Maximum 100 Requests pro Minute pro IP.
Schreibe Tests dazu.

Claude Code liest den Kommentar, analysiert die Codebasis, implementiert das Feature und erstellt einen Commit in der PR. Der Entwickler reviewed den Code und mergt.

Teams mit dieser Integration berichten von 30 % schnelleren PR Turnaround-Zeiten. Der Engpass verschiebt sich von "Code schreiben" zu "Code reviewen" -- und Claude hilft bei beidem. Wie du Claude Code im gesamten Team ausrollst, beschreibt unser Artikel Claude Code für Teams.

GitLab CI Integration

GitLab hat keine native Claude-Code-Action wie GitHub. Die Integration läuft über den Headless Mode.

Basis-Setup

# .gitlab-ci.yml
claude-review:
  stage: review
  image: node:22
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
  before_script:
    - npm install -g @anthropic-ai/claude-code
  script:
    - |
      DIFF=$(git diff origin/main...HEAD)
      claude -p "Prüfe diesen Diff auf Probleme:

      $DIFF

      Antworte mit:
      1. Kritische Probleme (müssen gefixt werden)
      2. Warnungen (sollten gefixt werden)
      3. Verbesserungsvorschläge (nice to have)" \
        --output-format json > review.json
    - cat review.json
  artifacts:
    paths:
      - review.json
  variables:
    ANTHROPIC_API_KEY: $ANTHROPIC_API_KEY

Review-Ergebnis als Merge-Request-Kommentar

claude-comment:
  stage: report
  needs: [claude-review]
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
  script:
    - |
      REVIEW=$(cat review.json | jq -r '.result')
      curl --request POST \
        --header "PRIVATE-TOKEN: ${GITLAB_TOKEN}" \
        --header "Content-Type: application/json" \
        --data "{\"body\": \"## Claude Code Review\n\n${REVIEW}\"}" \
        "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/merge_requests/${CI_MERGE_REQUEST_IID}/notes"

Das Ergebnis: Jede Merge Request bekommt automatisch einen Claude-Code-Review als Kommentar.

Pre-Commit Hooks

Pre-Commit Hooks laufen lokal, bevor ein Commit erstellt wird. Claude Code kann hier Probleme abfangen, bevor sie das Repository erreichen.

Setup mit Husky

npm install --save-dev husky
npx husky init

Pre-Commit Hook

#!/bin/sh
# .husky/pre-commit

# Staged Dateien holen
STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM)

if [ -z "$STAGED_FILES" ]; then
  exit 0
fi

# Claude Code prüft die staged Dateien
RESULT=$(claude -p "Prüfe diese Dateien auf offensichtliche Fehler:
$STAGED_FILES

Antworte NUR mit 'OK' wenn alles in Ordnung ist.
Wenn es Probleme gibt, liste sie auf." 2>&1)

if echo "$RESULT" | grep -q "OK"; then
  exit 0
else
  echo "Claude Code hat Probleme gefunden:"
  echo "$RESULT"
  echo ""
  echo "Commit abgebrochen. Behebe die Probleme oder nutze --no-verify."
  exit 1
fi

Was der Hook prüft

Der Hook läuft bei jedem git commit. Claude Code analysiert die staged Dateien und blockiert den Commit, wenn er Probleme findet.

Typische Funde:

  • API Keys im Code
  • console.log/print-Statements in Production Code
  • Fehlende Error Handling
  • Offensichtliche Logikfehler

Der Overhead: 5-15 Sekunden pro Commit, abhängig von der Größe der Änderungen. Bei großen Commits (50+ Dateien) kann es länger dauern. In dem Fall: den Hook auf die wichtigsten Dateien beschränken.

Async Hooks: Hintergrund-Aufgaben

Nicht jede Claude-Code-Aufgabe muss den Build blockieren. Async Hooks laufen parallel im Hintergrund.

Beispiel: Automatische Dokumentation

# .github/workflows/auto-docs.yml
name: Auto Documentation
on:
  push:
    branches: [main]
    paths:
      - 'src/api/**'

jobs:
  update-docs:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write
    steps:
      - uses: actions/checkout@v4

      - name: Update API Docs
        uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Die API-Dateien in src/api/ wurden geändert.
            Aktualisiere die API-Dokumentation in docs/api.md.
            Erstelle einen Commit mit der aktualisierten Dokumentation.

Jeder Push auf main, der API-Dateien ändert, löst eine automatische Dokumentations-Aktualisierung aus. Kein Entwickler muss daran denken.

Beispiel: Automatische Changelog-Generierung

# .github/workflows/changelog.yml
name: Generate Changelog
on:
  release:
    types: [created]

jobs:
  changelog:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Generate Changelog
        run: |
          LAST_TAG=$(git describe --tags --abbrev=0 HEAD~1 2>/dev/null || echo "")
          if [ -n "$LAST_TAG" ]; then
            COMMITS=$(git log ${LAST_TAG}..HEAD --oneline)
          else
            COMMITS=$(git log --oneline -20)
          fi

          claude -p "Erstelle einen Changelog aus diesen Commits:

          $COMMITS

          Format:
          ## Neue Features
          ## Bug Fixes
          ## Verbesserungen

          Gruppiere die Commits sinnvoll. Schreibe auf Deutsch." \
            > CHANGELOG_ENTRY.md

          cat CHANGELOG_ENTRY.md
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Sicherheit in CI/CD

Claude Code in der Pipeline bedeutet: Ein AI-Agent hat Zugriff auf euren Code und kann Befehle ausführen. Das erfordert Vorsicht.

Prinzip 1: Minimale Berechtigungen

permissions:
  contents: read        # Nur lesen, nicht schreiben
  pull-requests: write  # Kommentare posten
  # NICHT: contents: write (außer wenn Claude committen soll)

Gebt Claude Code nur die Berechtigungen, die er braucht. Für Reviews: read + PR-Kommentare. Für Implementierungen: read + write. Niemals admin. Mehr Sicherheits- und Qualitätstipps findest du in unseren Claude Code Best Practices.

Prinzip 2: Sandbox

In CI läuft Claude Code bereits in einer isolierten Umgebung (Container). Zusätzliche Absicherung:

steps:
  - name: Claude in Sandbox
    uses: anthropics/claude-code-action@v1
    with:
      anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
      allowed_tools: "read,write,grep,glob"  # Keine Shell-Befehle

Beschränkt die Tools, die Claude Code nutzen darf. Für Reviews reichen Lese-Tools. Für Implementierungen brauchst du zusätzlich write.

Prinzip 3: Secrets schützen

env:
  ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
  # NICHT: DATABASE_URL, AWS_SECRET_KEY, etc.

Gebt Claude Code nur den API Key. Keine anderen Secrets. Claude Code braucht keinen Datenbankzugang in der Review-Pipeline.

Prinzip 4: Output prüfen

Claude Code kann in CI Befehle vorschlagen oder ausführen. Bei Implementierungen (Claude erstellt Commits) sollte immer ein menschlicher Review folgen. Automatisch gemergt werden sollte nichts.

Praktisches Beispiel: Komplette Pipeline

Eine Pipeline, die alle Elemente kombiniert:

# .github/workflows/complete-pipeline.yml
name: Complete CI with Claude
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  # Schritt 1: Standard-Tests
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm test

  # Schritt 2: Claude Code Review (parallel zu Tests)
  claude-review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Review diese PR. Fokus auf:
            1. Sicherheit
            2. Performance
            3. Wartbarkeit

  # Schritt 3: Claude prüft Test-Coverage
  coverage-check:
    needs: [test]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm run test:coverage -- --reporter=json > coverage.json
      - name: Claude Coverage Analysis
        run: |
          claude -p "Analysiere die Test-Coverage in coverage.json.
          Welche kritischen Pfade sind nicht getestet?
          Nenne konkrete Dateien und Funktionen."
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Tests und Claude-Review laufen parallel. Die Coverage-Analyse läuft nach den Tests. Der Entwickler bekommt drei Ergebnisse: Testergebnis, Code-Review und Coverage-Analyse.

Häufig gestellte Fragen

Wie hoch sind die API-Kosten für Claude Code in CI/CD?

Abhängig vom Volumen. Eine einzelne Code-Review kostet ca. $0,05-$0,50 in API-Tokens (mit Sonnet). Bei 50 PRs pro Woche sind das $10-$100/Monat. Mit dem Teams oder Enterprise Plan sind die Kosten im Seat-Preis enthalten.

Verlangsamt Claude Code die Pipeline?

Eine Claude-Code-Analyse dauert 10-60 Sekunden, abhängig von der Größe des Diffs. Wenn der Review-Job parallel zu Tests läuft (wie im Beispiel oben), verlängert er die Pipeline nicht.

Kann Claude Code direkt auf main pushen?

Technisch ja. Praktisch sollte er das nie tun. Claude Code sollte PRs erstellen oder Commits in bestehende PRs pushen. Der Merge auf main bleibt menschliche Entscheidung.

Funktioniert das auch mit Bitbucket oder Azure DevOps?

Ja, über den Headless Mode. claude -p "prompt" funktioniert in jeder CI-Umgebung, die Node.js installieren kann. Die native GitHub Action gibt es nur für GitHub. Für andere Plattformen nutzt du den Headless Mode wie im GitLab-Beispiel.

Wie gehe ich mit Rate Limits um?

Im Teams Plan sind die Rate Limits höher als im Pro Plan. Für CI/CD-Pipelines mit vielen PRs pro Tag empfiehlt sich der Enterprise Plan mit Custom Rate Limits. Alternativ: Reviews nur bei bestimmten Labels oder Pfaden triggern.

Soll ich Sonnet oder Opus für CI/CD nutzen?

Sonnet für Reviews und Analysen. Schneller und günstiger. Opus für komplexe Implementierungen, wo Qualität wichtiger ist als Geschwindigkeit. Die meisten Teams nutzen Sonnet für 90 % der CI/CD-Aufgaben.

Wie debugge ich Probleme in der Claude-Code-Pipeline?

Nutze --output-format json und logge den Output. Das JSON enthält das Ergebnis, die genutzten Tools und eventuelle Fehler. Für tieferes Debugging: --output-format stream-json gibt dir den gesamten Denkprozess. Alle verfügbaren Flags und Befehle findest du im Claude Code Befehle Cheatsheet.

Brauche ich eine CLAUDE.md für CI/CD?

Ja. Die CLAUDE.md liegt im Repository und wird auch in CI gelesen. Ohne CLAUDE.md fehlt Claude Code der Projektkontext. Die Review-Qualität sinkt messbar. Wie du eine effektive CLAUDE.md erstellst, zeigt unser Guide CLAUDE.md schreiben.

claude-codeci-cdgithub-actionsgitlab-ciautomationdevops

OpenClaw Setup ohne Aufwand

Clawdify liefert einen vorkonfigurierten OpenClaw-Agenten auf dedizierter M4 Hardware. Wir installieren, du nutzt.

Setup anfragen

Weiterführende Artikel

Claude Code7 min

Claude Code Rate Limit erreicht: Was du jetzt tun kannst

Rate Limit bei Claude Code erreicht? Sofort-Maßnahmen, langfristige Strategien und wann sich Max oder API lohnt.

Lesen
Claude Code7 min

Claude Code funktioniert nicht? Die 5 häufigsten Fehler und ihre Lösung

Claude Code startet nicht, zeigt Fehler oder liefert Unsinn? Die 5 häufigsten Probleme mit konkreten Lösungen – Schritt für Schritt.

Lesen
Claude Code9 min

Claude Code und DSGVO: Was deutsche Unternehmen wissen müssen

Zero Data Retention, SOC 2 Type II, EU AI Act: Alle DSGVO-relevanten Fakten zu Claude Code für deutsche Unternehmen auf einen Blick.

Lesen