Blog

Claude Code Skills nutzen: CI/CD einfach gemacht

Ashley Innocent

Ashley Innocent

22 January 2026

Claude Code Skills nutzen: CI/CD einfach gemacht

enterprise.banner.title

enterprise.banner.feature1

enterprise.banner.feature2

enterprise.banner.feature3

enterprise.banner.ctaB

Wenn Sie nach einer Möglichkeit gesucht haben, Intelligenz in Ihre CI/CD-Pipeline zu integrieren, ohne sich mit komplexen Automatisierungsskripten herumschlagen zu müssen, könnten Claude Code Skills genau das Richtige für Sie sein. Diese maßgeschneiderten, KI-gestützten Workflows automatisieren alles von Pre-Commit-Sicherheitsprüfungen bis zur Bereitstellungsvalidierung. Sie definieren sie mithilfe von Anweisungen in natürlicher Sprache anstelle von anfälligen Shell-Skripten.

Was Claude Code Skills für CI/CD leistungsstark macht:

💡
Bauen Sie API-zentrierte Pipelines? Kombinieren Sie Claude Code Skills mit Apidog für eine End-to-End-API-Automatisierung. Apidog bietet visuelles API-Testing, automatisierte Testgenerierung aus OpenAPI-Spezifikationen und CI/CD-fähige CLI-Tools, die sich nahtlos in Ihre Skills integrieren lassen. Testen Sie Apidog kostenlos, um Ihre API-Workflows zu beschleunigen.
Schaltfläche

In diesem Leitfaden erfahren Sie, was Claude Code Skills sind, wie Sie benutzerdefinierte CI/CD-Workflows erstellen und welche praktischen Beispiele Sie noch heute implementieren können.

Claude Code Skills verstehen

Was sind Skills?

Claude Code Skills sind maßgeschneiderte, wiederverwendbare KI-Workflows, die die Fähigkeiten von Claude Code erweitern. Stellen Sie sie sich als intelligente Skripte vor, die Folgendes können:

Im Gegensatz zu traditionellen Skripten, die einer starren Logik folgen, nutzen Skills die Denkfähigkeiten von Claude, um Grenzfälle zu behandeln, Verbesserungen vorzuschlagen und sich an wechselnde Bedingungen anzupassen.

Wie Skills funktionieren

Skills funktionieren über mehrere Schlüsselmechanismen:

1. Vom Benutzer aufrufbare Befehle

# Einen Skill mit einem Slash-Befehl ausführen
/deploy-validation --env production
/security-review
/ci-pipeline-monitor --branch main

2. Erlaubte Tools

Skills legen fest, welche Tools sie verwenden können:

3. Lebenszyklus-Hooks

Skills können Aktionen zu bestimmten Zeitpunkten auslösen:

4. Planungsdateien

Skills können den Zustand mithilfe von Markdown-Dateien beibehalten, um den Fortschritt zu verfolgen, Ergebnisse zu speichern und fortsetzbare Workflows zu ermöglichen.

Warum Skills in CI/CD überragend sind

Traditionelle CI/CD-Skripte versagen leicht, wenn unerwartete Bedingungen auftreten. Skills bringen Intelligenz in die Automatisierung:

Skill-Anatomie: Komponenten und Struktur

Verzeichnisstruktur

Skills befinden sich in .claude/skills/ mit diesem Layout:

.claude/
├── skills/
│   ├── deploy-validation/
│   │   ├── SKILL.md              # Skill-Manifest und Anweisungen
│   │   ├── planning.md           # Zustandsverfolgung (optional)
│   │   └── scripts/              # Helfer-Skripte (optional)
│   ├── security-review/
│   │   └── SKILL.md
│   └── ci-monitor/
│       └── SKILL.md
└── skills.md                     # Index aller Skills

Das SKILL.md Manifest

Jeder Skill beginnt mit einem YAML-Frontmatter, gefolgt von Markdown-Anweisungen:

---
name: deploy-validation
version: "1.0.0"
description: Validiert die Bereitstellungsbereitschaft mit umfassenden Prüfungen
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Edit
  - Grep
  - Glob
hooks:
  SessionStart:
    - matcher: command
      command: "echo '[Bereitstellungs-Validator] Startet Pre-Deployment-Checks...'"
  Stop:
    - matcher: command
      command: "echo '[Bereitstellungs-Validator] Prüfungen abgeschlossen. Überprüfen Sie die Ausgabe oben.'"
---

# Skill zur Bereitstellungsvalidierung

Umfassende Pre-Deployment-Validierung für Produktions-Releases.

## Nutzung

```bash
/deploy-validation --env production
/deploy-validation --env staging --dry-run
/deploy-validation --skip-tests  # Vorsichtig verwenden

Was dieser Skill leistet

Umgebungsverifizierung

Code-Qualitätsprüfungen

Tests

Build-Validierung

Sicherheits-Scanning

Dokumentationsprüfung

Bereitstellungsbericht

Anweisungen für Claude

Beim Aufruf diesem Prozess folgen:

  1. Kommandozeilenargumente parsen, um Umgebung und Optionen zu bestimmen
  2. Aktuellen Git-Branch und Commit-SHA überprüfen
  3. Jeden Validierungsschritt nacheinander ausführen
  4. Bei jedem Fehler das Problem protokollieren und fortfahren (alle Fehler sammeln)
  5. Nach allen Prüfungen einen zusammenfassenden Bericht erstellen
  6. Wenn kritische Prüfungen fehlgeschlagen sind, mit Fehlercode 1 beenden
  7. Wenn alle Prüfungen bestanden wurden, mit Code 0 beenden und eine Erfolgsmeldung anzeigen

---

CI/CD-Anwendungsfälle für Skills

1. Pre-Commit-Validierung

Skill: /pre-commit-guard

Validiert Änderungen automatisch vor Commits:

Linting und Formatierung
Sicherheitsscans auf Geheimnisse
Ausführung von Unit-Tests
Dateigrößenprüfungen
Erkennung von Breaking Changes

Vorteil: Probleme erkennen, bevor sie in die Codebasis gelangen.

2. Pull-Request-Analyse

Skill: /pr-review

Intelligente PR-Überprüfung, die:

Codeänderungen auf Qualitätsprobleme analysiert
Auf Sicherheitslücken prüft
Die Testabdeckung verifiziert
Verbesserungen vorschlägt
Überprüfungskommentare generiert

Vorteil: Konsistente, gründliche Code-Überprüfung ohne menschliche Engpässe.

3. Automatisierte Test-Workflows

Skill: /test-runner

Intelligente Testausführung, die:

Erkennt, welche Tests für Änderungen relevant sind
Tests in optimaler Reihenfolge ausführt
Fehler analysiert und Korrekturen vorschlägt
Abdeckungsberichte generiert
Testleistungs-Trends verfolgt

Vorteil: Schnelleres Feedback durch intelligente Testauswahl.

4. Bereitstellungsvalidierung

Skill: /deploy-validator

Pre-Deployment-Checks, einschließlich:

Validierung der Umgebungskonfiguration
Überprüfung der Abhängigkeiten
Datenbank-Migrationsprüfungen
API-Kompatibilitätstests
Erkennung von Performance-Regressionen

Vorteil: Bereitstellungsfehler verhindern, bevor sie auftreten.

5. CI-Pipeline-Überwachung

Skill: /ci-monitor

Überwacht den Pipeline-Zustand:

Verfolgt die Erfolgsraten von Builds
Identifiziert "flaky" Tests (unzuverlässige Tests)
Analysiert Performance-Trends
Warnt bei Verschlechterung
Schlägt Optimierungen vor

Vorteil: Proaktive Pipeline-Wartung und -Optimierung.

6. Release-Automatisierung

Skill: /release-manager

Orchestriert den Release-Prozess:

Versionserhöhung
Changelog-Generierung
Tag-Erstellung
Überprüfung der Build-Artefakte
Entwurf von Release Notes

Vorteil: Konsistente, fehlerfreie Releases.

7. API-Testautomatisierung

Skill: /api-test-runner

Für Teams, die APIs entwickeln, kombinieren Sie Claude Code Skills mit Apidog für eine umfassende API-Validierung:

Testfälle generieren: API-Tests aus OpenAPI/Swagger-Spezifikationen erstellen
Automatisierte Tests ausführen: Apidog-Testsammlungen in Ihrer Pipeline ausführen
Antworten validieren: Statuscodes, Schemas und Antwortzeiten überprüfen
Abhängigkeiten simulieren: Mock-Server für isolierte Tests einrichten
Abdeckung verfolgen: Die Testabdeckung von API-Endpunkten überwachen

Beispiel für Skill-Integration:
/api-test-runner --collection ./tests/api-collection.json --env production
Vorteil: API-Regressionen vor der Bereitstellung erkennen, mit visuellem Debugging und detaillierten Berichten. Die CI/CD-Integration von Apidog macht es einfach, API-Tests zu jeder Pipeline hinzuzufügen.Ihren ersten CI/CD-Skill erstellenLassen Sie uns einen praktischen Skill erstellen: ein Tool zur Sicherheitsüberprüfung, das Code vor Commits prüft.Schritt 1: Das Skill-Verzeichnis erstellenmkdir -p .claude/skills/security-review
Schritt 2: Das Skill-Manifest schreibenErstellen Sie .claude/skills/security-review/SKILL.md:---
name: security-review
version: "1.0.0"
description: Sicherheits-Scan für gängige Schwachstellen und Geheimnisse
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Grep
  - Glob
  - Write
hooks:
  SessionStart:
    - matcher: command
      command: "echo '[Sicherheitsüberprüfung] Startet Sicherheits-Scan...'"
  Stop:
    - matcher: command
      command: "echo '[Sicherheitsüberprüfung] Scan abgeschlossen'"
---

# Skill zur Sicherheitsüberprüfung

Scannt Code auf Sicherheitsprobleme vor Commits.

## Nutzung

```bash
/security-review                    # Alle geänderten Dateien scannen
/security-review --all              # Die gesamte Codebasis scannen
/security-review --file src/auth.js # Spezifische Datei scannen
ErkennungsmusterDieser Skill prüft auf:Hartcodierte GeheimnisseAPI-SchlüsselPasswörterPrivate SchlüsselZugangstokenHäufige SchwachstellenSQL-Injection-MusterXSS-SchwachstellenBefehlsinjektionPfadüberquerung (Path Traversal)Unsichere KonfigurationenDebug-Modus aktiviertUnsichere StandardeinstellungenFehlende AuthentifizierungSchwache KryptographieAbhängigkeitsproblemeBekannte anfällige PaketeVeraltete AbhängigkeitenVerdächtige PaketeAnweisungenBeim Aufruf:Scan-Bereich festlegenWenn Flag --all: gesamte Codebasis scannenWenn --file angegeben: diese Datei scannenStandard: nur im Git gestagte/geänderte Dateien scannenNach Geheimnissen suchenGrep verwenden, um Muster zu finden wie:(api[_-]?key|password|secret|token)\s*[:=]\s*['"]\w+['"]-----BEGIN (RSA |)PRIVATE KEY-----Gängige Geheimnisformate (AWS, GitHub, etc.)Dateien in .gitignore ignorierennode_modules, vendor, etc. überspringenNach Schwachstellenmustern suchenSQL-Injection: rohes SQL mit String-VerkettungXSS: unescaped Benutzereingaben in HTMLBefehlsinjektion: Shell-Ausführung mit BenutzereingabenCode mit Read-Tool lesen, um den Kontext zu analysierenAbhängigkeiten scannenAuf package-lock.json, requirements.txt, etc. prüfenBash verwenden, um Sicherheits-Scanner auszuführen:npm audit für Node.jspip-audit für Pythonbundle audit für RubyBericht generierenAlle Funde auflisten mit:Dateipfad und ZeilennummerProblemtyp und SchweregradEmpfohlene KorrekturSpeichern unter .claude/security-reports/{date}.mdZusammenfassung im Terminal anzeigenExit-StatusExit 0, wenn keine Probleme gefunden wurdenExit 1, wenn Probleme mit hohem Schweregrad vorliegenExit 2, wenn Scan nicht abgeschlossen werden konnte
### Schritt 3: Den Skill registrieren

Zu .claude/skills.md hinzufügen:

```markdown
# Verfügbare Skills

## Sicherheit & Qualität

### /security-review
Sicherheits-Scan für Schwachstellen und Geheimnisse.
- **Version**: 1.0.0
- **Nutzung**: `/security-review [--all] [--file PATH]`
- **Wann zu verwenden**: Vor Commits, während der PR-Überprüfung
Schritt 4: Den Skill testen# In Claude Code
/security-review
Claude führt nun den Sicherheitsüberprüfungs-Workflow aus und prüft Ihren Code auf Probleme.Erweiterte Skill-MusterMuster 1: Zustandserhaltende Workflows mit PlanungsdateienFür mehrstufige Prozesse verwenden Sie Planungsdateien, um den Fortschritt zu verfolgen:---
name: release-manager
version: "1.0.0"
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Write
  - Edit
---

# Release Manager

Verwaltet den vollständigen Release-Prozess.

## Zustandsverwaltung

Dieser Skill verwendet `planning.md`, um den Release-Fortschritt zu verfolgen:

```markdown
# Fortschritt Release v2.5.0

## Phase 1: Pre-Release-Validierung [ABGESCHLOSSEN]
- [x] Vollständige Test-Suite ausführen
- [x] Codeabdeckung prüfen > 80%
- [x] Nach Sicherheitsproblemen scannen

## Phase 2: Versionserhöhung [IN BEARBEITUNG]
- [x] package.json aktualisieren
- [ ] CHANGELOG.md aktualisieren
- [ ] Dokumentation aktualisieren

## Phase 3: Build & Tag [ANSTEHEND]
- [ ] Produktions-Build erstellen
- [ ] Smoke-Tests ausführen
- [ ] Git-Tag erstellen
- [ ] In die Registry pushen

## Phase 4: Post-Release [ANSTEHEND]
- [ ] GitHub-Release erstellen
- [ ] Release Notes aktualisieren
- [ ] Team benachrichtigen
AnweisungenPrüfen, ob planning.md existiertWenn ja: von der letzten unvollständigen Phase fortsetzenWenn nein: neue Planungsdatei erstellenJede Phase ausführen:Kontrollkästchen aktualisieren, wenn Aufgaben abgeschlossen sindFortschritt nach jedem Schritt speichernBei Unterbrechung kann später fortgesetzt werdenFür jede Aufgabe:Voraussetzungen überprüfenAktion ausführenErgebnis validierenPlanungsdatei aktualisieren
### Muster 2: Bedingte Workflows

Skills können sich an den Projekttyp anpassen:

```markdown
## Anweisungen

1. **Projekttyp erkennen**
   - Prüfen auf `package.json` → Node.js-Projekt
   - Prüfen auf `requirements.txt` → Python-Projekt
   - Prüfen auf `Cargo.toml` → Rust-Projekt

2. **Entsprechende Tests ausführen**
   - Node.js: `npm test`
   - Python: `pytest`
   - Rust: `cargo test`

3. **Abdeckungsberichte generieren**
   - Node.js: Jest/Istanbul verwenden
   - Python: pytest-cov verwenden
   - Rust: Tarpaulin verwenden
Muster 3: Parallele AusführungFür unabhängige Aufgaben diese gleichzeitig ausführen:## Anweisungen

1. **Parallele Prüfungen** (gleichzeitig ausführen):
   - Linting (ESLint, Prettier)
   - Typ-Prüfung (TypeScript)
   - Sicherheits-Scan (npm audit)
   - Dokumentations-Build

2. **Ergebnisse sammeln**
   - Warten, bis alle Aufgaben abgeschlossen sind
   - Ergebnisse aggregieren
   - Eventuelle Fehler melden
Muster 4: Interaktive EntscheidungsfindungSkills können Benutzereingaben anfordern:## Anweisungen

1. **Bereitstellungsrisiken analysieren**
   - Nach Breaking Changes suchen
   - Migrationsskripte überprüfen
   - Komplexität des Rollbacks bewerten

2. **Wenn HOHES Risiko erkannt wird**
   - Ergebnisse dem Benutzer präsentieren
   - Fragen: "Trotzdem bereitstellen? (ja/nein/abbrechen)"
   - Wenn ja: mit der Bereitstellung fortfahren
   - Wenn nein: abbrechen und Entscheidung protokollieren
   - Wenn abbrechen: ohne Aktion beenden

3. **Wenn GERINGES Risiko**
   - Bereitstellung automatisch genehmigen
   - Entscheidung für Audit protokollieren
Skills mit GitHub Actions integrierenMethode 1: Direkter Skill-AufrufFügen Sie Claude Code zu Ihrem GitHub Actions-Workflow hinzu:# .github/workflows/security-scan.yml
name: Sicherheits-Scan

on:
  pull_request:
    branches: [main, develop]

jobs:
  security-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Claude Code installieren
        run: |
          curl -fsSL https://install.claude.com | sh

      - name: Sicherheitsüberprüfung ausführen
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude /security-review --all

      - name: Bericht hochladen
        if: always()
        uses: actions/upload-artifact@v3
        with:
          name: security-report
          path: .claude/security-reports/
Methode 2: Benutzerdefinierte GitHub ActionErstellen Sie eine wiederverwendbare Action:# .github/actions/claude-skill/action.yml
name: 'Claude Code Skill ausführen'
description: 'Führt einen Claude Code Skill in CI aus'
inputs:
  skill-name:
    description: 'Name des auszuführenden Skills'
    required: true
  skill-args:
    description: 'Argumente, die an den Skill übergeben werden sollen'
    required: false
    default: ''
  api-key:
    description: 'Anthropic API-Schlüssel'
    required: true

runs:
  using: 'composite'
  steps:
    - name: Claude einrichten
      shell: bash
      run: |
        curl -fsSL https://install.claude.com | sh

    - name: Skill ausführen
      shell: bash
      env:
        ANTHROPIC_API_KEY: ${{ inputs.api-key }}
      run: |
        claude /${{ inputs.skill-name }} ${{ inputs.skill-args }}
Nutzung in Workflows:# .github/workflows/deploy.yml
name: Bereitstellen

on:
  push:
    branches: [main]

jobs:
  validate-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Pre-Deployment-Validierung
        uses: ./.github/actions/claude-skill
        with:
          skill-name: deploy-validation
          skill-args: '--env production'
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}

      - name: Bereitstellen
        if: success()
        run: ./deploy.sh production

      - name: Post-Deployment-Prüfung
        uses: ./.github/actions/claude-skill
        with:
          skill-name: health-check
          skill-args: '--url https://api.example.com'
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}
Methode 3: Matrix-TestsSkills über mehrere Umgebungen ausführen:# .github/workflows/test-matrix.yml
name: Test-Matrix

on: [push, pull_request]

jobs:
  test:
    strategy:
      matrix:
        node-version: [16, 18, 20]
        os: [ubuntu-latest, macos-latest, windows-latest]

    runs-on: ${{ matrix.os }}

    steps:
      - uses: actions/checkout@v3

      - name: Node einrichten
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node-version }}

      - name: Test-Skill ausführen
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude /test-runner --node-version ${{ matrix.node-version }}
Git Hooks-IntegrationGit Hooks einrichtenGit Hooks lassen Skills automatisch bei Git-Ereignissen ausführen.Pre-Commit HookSchlechte Commits verhindern, bevor sie geschehen:# .git/hooks/pre-commit
#!/bin/bash

echo "Führe Pre-Commit-Sicherheitsüberprüfung aus..."

# Claude Code Sicherheitsüberprüfung ausführen
claude /security-review

if [ $? -ne 0 ]; then
    echo "FEHLGESCHLAGEN: Sicherheitsprobleme erkannt. Commit blockiert."
    echo "Beheben Sie die oben genannten Probleme oder verwenden Sie 'git commit --no-verify', um zu umgehen (nicht empfohlen)"
    exit 1
fi

echo "BESTANDEN: Sicherheitsprüfung erfolgreich"
exit 0
Ausführbar machen:chmod +x .git/hooks/pre-commit
Pre-Push HookValidieren vor dem Push an das Remote-Repository:# .git/hooks/pre-push
#!/bin/bash

echo "Führe Pre-Push-Validierung aus..."

# Den Branch abrufen, der gepusht wird
BRANCH=$(git rev-parse --abbrev-ref HEAD)

# Unterschiedliche Prüfungen je nach Branch ausführen
if [ "$BRANCH" = "main" ]; then
    echo "Push nach main - führe vollständige Validierung aus..."
    claude /deploy-validation --env production
elif [ "$BRANCH" = "develop" ]; then
    echo "Push nach develop - führe Staging-Validierung aus..."
    claude /deploy-validation --env staging
else
    echo "Feature-Branch - führe schnelle Validierung aus..."
    claude /quick-check
fi

if [ $? -ne 0 ]; then
    echo "FEHLGESCHLAGEN: Validierung fehlgeschlagen. Push blockiert."
    exit 1
fi

echo "BESTANDEN: Validierung erfolgreich"
exit 0
Post-Merge HookNach dem Mergen von Branches ausführen:# .git/hooks/post-merge
#!/bin/bash

echo "Post-Merge-Prüfungen..."

# Prüfen, ob Abhängigkeiten geändert wurden
if git diff-tree -r --name-only --no-commit-id HEAD@{1} HEAD | grep -q "package-lock.json"; then
    echo "Abhängigkeiten geändert - führe Sicherheits-Audit aus..."
    claude /dependency-audit
fi

# Prüfen, ob Datenbankmigrationen existieren
if git diff-tree -r --name-only --no-commit-id HEAD@{1} HEAD | grep -q "migrations/"; then
    echo "Migrationen erkannt - validiere..."
    claude /migration-validator
fi

exit 0
Husky-IntegrationFür Teams, die Husky zur Verwaltung von Git Hooks verwenden:// package.json
{
  "husky": {
    "hooks": {
      "pre-commit": "claude /security-review && claude /lint-check",
      "pre-push": "claude /test-runner --quick",
      "post-merge": "claude /dependency-audit"
    }
  }
}
Oder mit Husky v6+:# .husky/pre-commit
#!/bin/sh
. "$(dirname "$0")/_/husky.sh"

claude /security-review
claude /lint-check
FazitClaude Code Skills verwandeln CI/CD von anfälligen Skripten in intelligente, adaptive Workflows. Durch die Kombination von KI-Denkfähigkeiten mit traditioneller Automatisierung können Skills:Kontext verstehen und sich an verschiedene Szenarien anpassenVerbesserungen vorschlagen, anstatt nur Fehler zu meldenAus Mustern lernen in Ihrer CodebasisSich selbst dokumentieren durch Anweisungen in natürlicher SpracheWenn Ihre CI/CD-Pipeline API-Endpunkte enthält, bietet die Kombination von Claude Code Skills mit Apidog das Beste aus beiden Welten:FunktionVorteilVisuelles API-TestingTestfälle erstellen, ohne Code zu schreibenOpenAPI-ImportTests automatisch aus Ihren Spezifikationen generierenMock-ServerIntegrationen testen, bevor Backends bereit sindCI/CD CLIApidog-Tests in jeder Pipeline ausführenTeam-KollaborationTestsammlungen teamübergreifend teilenBereit, Ihren API-Workflow zu optimieren? Laden Sie Apidog kostenlos herunter und erstellen Sie Ihre erste API-Testsammlung in wenigen Minuten.Schaltfläche

Praktizieren Sie API Design-First in Apidog

Entdecken Sie eine einfachere Möglichkeit, APIs zu erstellen und zu nutzen

Kostenlos registrierenHerunterladen