Blog

Comment utiliser Claude Code Skills pour CI/CD

Ashley Innocent

Ashley Innocent

22 January 2026

Comment utiliser Claude Code Skills pour CI/CD

Si vous cherchiez un moyen d'injecter de l'intelligence dans votre pipeline CI/CD sans vous débattre avec des scripts d'automatisation complexes, Claude Code Skills pourrait être exactement ce dont vous avez besoin. Ces flux de travail personnalisés, alimentés par l'IA, automatisent tout, des vérifications de sécurité avant le commit à la validation du déploiement. Vous les définissez à l'aide d'instructions en langage naturel au lieu de scripts shell fragiles.

Ce qui rend Claude Code Skills puissant pour le CI/CD :

💡
Vous construisez des pipelines centrés sur les API ? Combinez Claude Code Skills avec Apidog pour une automatisation API de bout en bout. Apidog offre des tests API visuels, la génération automatisée de tests à partir de spécifications OpenAPI et des outils CLI prêts pour le CI/CD qui s'intègrent parfaitement à vos compétences. Essayez Apidog gratuitement pour optimiser vos flux de travail API.
bouton

Dans ce guide, nous explorerons ce que sont les Claude Code Skills, comment construire des flux de travail CI/CD personnalisés et des exemples concrets que vous pouvez mettre en œuvre dès aujourd'hui.

Comprendre les Claude Code Skills

Qu'est-ce que les "Skills" ?

Les Claude Code Skills sont des flux de travail IA personnalisés et réutilisables qui étendent les capacités de Claude Code. Considérez-les comme des scripts intelligents qui peuvent :

Contrairement aux scripts traditionnels qui suivent une logique rigide, les "skills" exploitent les capacités de raisonnement de Claude pour gérer les cas limites, suggérer des améliorations et s'adapter aux conditions changeantes.

Comment fonctionnent les "Skills"

Les "skills" opèrent via plusieurs mécanismes clés :

1. Commandes invocables par l'utilisateur

# Exécuter une compétence avec une commande slash
/deploy-validation --env production
/security-review
/ci-pipeline-monitor --branch main

2. Outils autorisés

Les "skills" spécifient les outils qu'elles peuvent utiliser :

3. Hooks de cycle de vie

Les "skills" peuvent déclencher des actions à des points spécifiques :

4. Fichiers de planification

Les "skills" peuvent maintenir leur état en utilisant des fichiers Markdown pour suivre les progrès, stocker les découvertes et permettre des flux de travail pouvant être repris.

Pourquoi les "Skills" excellent en CI/CD

Les scripts CI/CD traditionnels échouent facilement face à des conditions inattendues. Les "skills" apportent de l'intelligence à l'automatisation :

Anatomie d'une "Skill" : Composants et Structure

Structure des répertoires

Les "skills" résident dans .claude/skills/ avec cette disposition :

.claude/
├── skills/
│   ├── deploy-validation/
│   │   ├── SKILL.md              # Manifeste de la compétence et instructions
│   │   ├── planning.md           # Suivi d'état (facultatif)
│   │   └── scripts/              # Scripts d'aide (facultatif)
│   ├── security-review/
│   │   └── SKILL.md
│   └── ci-monitor/
│       └── SKILL.md
└── skills.md                     # Index de toutes les compétences

Le manifeste SKILL.md

Chaque "skill" commence par un frontmatter YAML suivi d'instructions Markdown :

---
name: deploy-validation
version: "1.0.0"
description: Valide la préparation au déploiement avec des vérifications complètes
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Edit
  - Grep
  - Glob
hooks:
  SessionStart:
    - matcher: command
      command: "echo '[Validateur de Déploiement] Démarrage des vérifications avant déploiement...'"
  Stop:
    - matcher: command
      command: "echo '[Validateur de Déploiement] Vérifications terminées. Consultez la sortie ci-dessus.'"
---

# Compétence de validation de déploiement

Validation complète avant déploiement pour les versions de production.

## Utilisation

```bash
/deploy-validation --env production
/deploy-validation --env staging --dry-run
/deploy-validation --skip-tests  # À utiliser avec prudence

Ce que fait cette compétence

Vérification de l'environnement

Vérifications de la qualité du code

Tests

Validation de la construction (Build)

Analyse de sécurité

Vérification de la documentation

Rapport de déploiement

Instructions pour Claude

Lors de son invocation, suivre ce processus :

  1. Analyser les arguments de la ligne de commande pour déterminer l'environnement et les options
  2. Vérifier la branche git actuelle et le SHA du commit
  3. Exécuter chaque étape de validation en séquence
  4. Pour chaque échec, consigner le problème et continuer (collecter toutes les erreurs)
  5. Après toutes les vérifications, générer un rapport récapitulatif
  6. Si des vérifications critiques ont échoué, quitter avec le code d'erreur 1
  7. Si toutes les vérifications ont réussi, quitter avec le code 0 et afficher un message de succès

---

## Cas d'utilisation de Skills en CI/CD

### 1. Validation pré-commit

**Skill : `/pre-commit-guard`**

Valide automatiquement les changements avant les commits :
- Linting et formatage
- Analyse de sécurité pour les secrets
- Exécution de tests unitaires
- Vérifications de la taille des fichiers
- Détection des changements cassants

**Avantage** : Détecter les problèmes avant qu'ils n'entrent dans le code.

### 2. Analyse de Pull Request

**Skill : `/pr-review`**

Revue de PR intelligente qui :
- Analyse les modifications de code pour les problèmes de qualité
- Vérifie les vulnérabilités de sécurité
- Vérifie la couverture de test
- Suggère des améliorations
- Génère des commentaires de revue

**Avantage** : Revue de code cohérente et approfondie sans goulots d'étranglement humains.

### 3. Flux de travail de tests automatisés

**Skill : `/test-runner`**

Exécution de tests intelligente qui :
- Détecte les tests pertinents aux changements
- Exécute les tests dans l'ordre optimal
- Analyse les échecs et suggère des correctifs
- Génère des rapports de couverture
- Suivi des tendances de performance des tests

**Avantage** : Rétroaction plus rapide avec une sélection intelligente des tests.

### 4. Validation de déploiement

**Skill : `/deploy-validator`**

Vérifications avant déploiement incluant :
- Validation de la configuration de l'environnement
- Vérification des dépendances
- Vérifications de migration de base de données
- Tests de compatibilité API
- Détection de régression de performance

**Avantage** : Prévenir les échecs de déploiement avant qu'ils ne surviennent.

### 5. Surveillance de pipeline CI

**Skill : `/ci-monitor`**

Surveille la santé du pipeline :
- Suivi des taux de réussite de construction
- Identification des tests instables
- Analyse des tendances de performance
- Alertes en cas de dégradation
- Suggestions d'optimisations

**Avantage** : Maintenance et optimisation proactive du pipeline.

### 6. Automatisation des versions

**Skill : `/release-manager`**

Orchestre le processus de version :
- Augmentation de version (version bumping)
- Génération de Changelog
- Création de tags
- Vérification des artefacts de construction
- Rédaction des notes de version

**Avantage** : Versions cohérentes et sans erreur.

### 7. Automatisation des tests API

**Skill : `/api-test-runner`**

Pour les équipes développant des API, combinez Claude Code Skills avec [Apidog](https://apidog.com) pour une validation API complète :

- **Générer des cas de test** : Créer des tests API à partir de spécifications OpenAPI/Swagger
- **Exécuter des tests automatisés** : Exécuter des collections de tests Apidog dans votre pipeline
- **Valider les réponses** : Vérifier les codes d'état, les schémas et les temps de réponse
- **Simuler les dépendances** : Mettre en place des serveurs mock pour des tests isolés
- **Suivi de la couverture** : Surveiller la couverture de test des points d'accès API

**Exemple d'intégration de skill :**
```bash
/api-test-runner --collection ./tests/api-collection.json --env production

Avantage : Détecter les régressions API avant le déploiement grâce au débogage visuel et aux rapports détaillés. L'intégration CI/CD d'Apidog facilite l'ajout de tests API à n'importe quel pipeline.

Créer votre première "Skill" CI/CD

Construisons une "skill" pratique : un outil de revue de sécurité qui vérifie le code avant les commits.

Étape 1 : Créer le répertoire de la "Skill"

mkdir -p .claude/skills/security-review

Étape 2 : Écrire le manifeste de la "Skill"

Créer .claude/skills/security-review/SKILL.md :

---
name: security-review
version: "1.0.0"
description: Analyse de sécurité pour les vulnérabilités courantes et les secrets
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Grep
  - Glob
  - Write
hooks:
  SessionStart:
    - matcher: command
      command: "echo '[Revue de sécurité] Démarrage de l'analyse de sécurité...'"
  Stop:
    - matcher: command
      command: "echo '[Revue de sécurité] Analyse terminée'"
---

# Skill de revue de sécurité

Analyse le code pour les problèmes de sécurité avant les commits.

## Utilisation

```bash
/security-review                    # Analyser tous les fichiers modifiés
/security-review --all              # Analyser l'intégralité de la base de code
/security-review --file src/auth.js # Analyser un fichier spécifique

Modèles de détection

Cette "skill" vérifie les éléments suivants :

Secrets codés en dur

Vulnérabilités courantes

Configurations non sécurisées

Problèmes de dépendance

Instructions

Lorsqu'invoqué :

Déterminer la portée de l'analyse

Rechercher les secrets

Vérifier les modèles de vulnérabilité

Analyser les dépendances

Générer un rapport

Statut de sortie


### Étape 3 : Enregistrer la "Skill"

Ajouter à `.claude/skills.md` :

```markdown
# Skills disponibles

## Sécurité & Qualité

### /security-review
Analyse de sécurité pour les vulnérabilités et les secrets.
- **Version** : 1.0.0
- **Utilisation** : `/security-review [--all] [--file PATH]`
- **Quand l'utiliser** : Avant les commits, pendant la revue de PR

Étape 4 : Tester la "Skill"

# Dans Claude Code
/security-review

Claude exécutera maintenant le flux de travail de revue de sécurité, vérifiant votre code pour les problèmes.

Modèles de "Skills" avancés

Modèle 1 : Flux de travail avec état via des fichiers de planification

Pour les processus en plusieurs étapes, utilisez des fichiers de planification pour suivre la progression :

---
name: release-manager
version: "1.0.0"
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Write
  - Edit
---

# Gestionnaire de versions

Gère l'ensemble du processus de publication.

## Gestion de l'état

Cette compétence utilise `planning.md` pour suivre la progression de la version :

```markdown
# Progression de la version v2.5.0

## Phase 1 : Validation pré-version [TERMINÉE]
- [x] Exécuter la suite de tests complète
- [x] Vérifier la couverture de code > 80%
- [x] Analyser les problèmes de sécurité

## Phase 2 : Augmentation de version [EN COURS]
- [x] Mettre à jour package.json
- [ ] Mettre à jour CHANGELOG.md
- [ ] Mettre à jour la documentation

## Phase 3 : Build & Tag [EN ATTENTE]
- [ ] Créer la version de production (build)
- [ ] Exécuter les tests de fumée (smoke tests)
- [ ] Créer le tag git
- [ ] Pousser vers le registre

## Phase 4 : Post-version [EN ATTENTE]
- [ ] Créer la version GitHub
- [ ] Mettre à jour les notes de version
- [ ] Notifier l'équipe

Instructions

Vérifier si planning.md existe

Exécuter chaque phase :

Pour chaque tâche :


### Modèle 2 : Flux de travail conditionnels

Les "skills" peuvent s'adapter en fonction du type de projet :

```markdown
## Instructions

1. **Détecter le type de projet**
   - Rechercher `package.json` → Projet Node.js
   - Rechercher `requirements.txt` → Projet Python
   - Rechercher `Cargo.toml` → Projet Rust

2. **Exécuter les tests appropriés**
   - Node.js : `npm test`
   - Python : `pytest`
   - Rust : `cargo test`

3. **Générer des rapports de couverture**
   - Node.js : Utiliser Jest/Istanbul
   - Python : Utiliser pytest-cov
   - Rust : Utiliser tarpaulin

Modèle 3 : Exécution parallèle

Pour les tâches indépendantes, exécutez-les simultanément :

## Instructions

1. **Vérifications parallèles** (exécutées simultanément) :
   - Linting (ESLint, Prettier)
   - Vérification de type (TypeScript)
   - Analyse de sécurité (npm audit)
   - Construction de la documentation

2. **Collecter les résultats**
   - Attendre que toutes les tâches soient terminées
   - Agréger les résultats
   - Signaler tout échec

Modèle 4 : Prise de décision interactive

Les "skills" peuvent demander une entrée utilisateur :

## Instructions

1. **Analyser les risques de déploiement**
   - Vérifier les changements cassants
   - Examiner les scripts de migration
   - Évaluer la complexité du rollback

2. **Si un risque ÉLEVÉ est détecté**
   - Présenter les résultats à l'utilisateur
   - Demander : "Déployer quand même ? (oui/non/annuler)"
   - Si oui : procéder au déploiement
   - Si non : annuler et enregistrer la décision
   - Si annuler : quitter sans action

3. **Si risque FAIBLE**
   - Approuver automatiquement le déploiement
   - Enregistrer la décision pour l'audit

Intégration des "Skills" avec GitHub Actions

Méthode 1 : Invocation directe de "Skill"

Ajoutez Claude Code à votre workflow GitHub Actions :

# .github/workflows/security-scan.yml
name: Analyse de sécurité

on:
  pull_request:
    branches: [main, develop]

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

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

      - name: Exécuter la revue de sécurité
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude /security-review --all

      - name: Télécharger le rapport
        if: always()
        uses: actions/upload-artifact@v3
        with:
          name: security-report
          path: .claude/security-reports/

Méthode 2 : Action GitHub personnalisée

Créez une action réutilisable :

# .github/actions/claude-skill/action.yml
name: 'Exécuter une Skill Claude Code'
description: 'Exécute une skill Claude Code en CI'
inputs:
  skill-name:
    description: 'Nom de la skill à exécuter'
    required: true
  skill-args:
    description: 'Arguments à passer à la skill'
    required: false
    default: ''
  api-key:
    description: 'Clé API Anthropic'
    required: true

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

    - name: Exécuter la Skill
      shell: bash
      env:
        ANTHROPIC_API_KEY: ${{ inputs.api-key }}
      run: |
        claude /${{ inputs.skill-name }} ${{ inputs.skill-args }}

Utilisation dans les workflows :

# .github/workflows/deploy.yml
name: Déployer

on:
  push:
    branches: [main]

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

      - name: Validation avant déploiement
        uses: ./.github/actions/claude-skill
        with:
          skill-name: deploy-validation
          skill-args: '--env production'
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}

      - name: Déployer
        if: success()
        run: ./deploy.sh production

      - name: Vérification post-déploiement
        uses: ./.github/actions/claude-skill
        with:
          skill-name: health-check
          skill-args: '--url https://api.example.com'
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}

Méthode 3 : Test matriciel

Exécuter les "skills" sur plusieurs environnements :

# .github/workflows/test-matrix.yml
name: Matrice de tests

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: Configurer Node
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node-version }}

      - name: Exécuter la skill de test
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude /test-runner --node-version ${{ matrix.node-version }}

Intégration des Git Hooks

Mise en place des Git Hooks

Les Git Hooks permettent aux "skills" de s'exécuter automatiquement lors des événements Git.

Hook de pré-commit

Empêchez les mauvais commits avant qu'ils ne se produisent :

# .git/hooks/pre-commit
#!/bin/bash

echo "Exécution de la revue de sécurité pré-commit..."

# Exécuter la revue de sécurité Claude Code
claude /security-review

if [ $? -ne 0 ]; then
    echo "ÉCHEC : Problèmes de sécurité détectés. Commit bloqué."
    echo "Corrigez les problèmes ci-dessus ou utilisez 'git commit --no-verify' pour contourner (non recommandé)"
    exit 1
fi

echo "SUCCÈS : La vérification de sécurité a réussi"
exit 0

Le rendre exécutable :

chmod +x .git/hooks/pre-commit

Hook de pré-push

Valider avant de pousser vers le dépôt distant :

# .git/hooks/pre-push
#!/bin/bash

echo "Exécution de la validation pré-push..."

# Obtenir la branche en cours de poussée
BRANCH=$(git rev-parse --abbrev-ref HEAD)

# Exécuter différentes vérifications en fonction de la branche
if [ "$BRANCH" = "main" ]; then
    echo "Poussée vers main - exécution de la validation complète..."
    claude /deploy-validation --env production
elif [ "$BRANCH" = "develop" ]; then
    echo "Poussée vers develop - exécution de la validation de staging..."
    claude /deploy-validation --env staging
else
    echo "Branche de fonctionnalité - exécution de la validation rapide..."
    claude /quick-check
fi

if [ $? -ne 0 ]; then
    echo "ÉCHEC : La validation a échoué. Poussée bloquée."
    exit 1
fi

echo "SUCCÈS : La validation a réussi"
exit 0

Hook de post-fusion

Exécuter après la fusion des branches :

# .git/hooks/post-merge
#!/bin/bash

echo "Vérifications post-fusion..."

# Vérifier si les dépendances ont changé
if git diff-tree -r --name-only --no-commit-id HEAD@{1} HEAD | grep -q "package-lock.json"; then
    echo "Dépendances modifiées - exécution de l'audit de sécurité..."
    claude /dependency-audit
fi

# Vérifier si des migrations de base de données existent
if git diff-tree -r --name-only --no-commit-id HEAD@{1} HEAD | grep -q "migrations/"; then
    echo "Migrations détectées - validation..."
    claude /migration-validator
fi

exit 0

Intégration Husky

Pour les équipes utilisant Husky pour gérer les hooks Git :

// package.json
{
  "husky": {
    "hooks": {
      "pre-commit": "claude /security-review && claude /lint-check",
      "pre-push": "claude /test-runner --quick",
      "post-merge": "claude /dependency-audit"
    }
  }
}

Ou avec Husky v6+ :

# .husky/pre-commit
#!/bin/sh
. "$(dirname "$0")/_/husky.sh"

claude /security-review
claude /lint-check

Conclusion

Claude Code Skills transforme le CI/CD, passant de scripts fragiles à des flux de travail intelligents et adaptatifs. En combinant le raisonnement de l'IA avec l'automatisation traditionnelle, les "skills" peuvent :

Si votre pipeline CI/CD inclut des points d'accès API, la combinaison de Claude Code Skills avec Apidog vous offre le meilleur des deux mondes :

FonctionnalitéAvantage
Tests API VisuelsCréez des cas de test sans écrire de code
Import OpenAPIGénérez automatiquement des tests à partir de vos spécifications
Serveurs MockTestez les intégrations avant que les backends ne soient prêts
CLI CI/CDExécutez les tests Apidog dans n'importe quel pipeline
Collaboration d'équipePartagez des collections de tests avec votre équipe

Prêt à rationaliser votre flux de travail API ? Téléchargez Apidog gratuitement et créez votre première collection de tests API en quelques minutes.

bouton

Pratiquez le Design-first d'API dans Apidog

Découvrez une manière plus simple de créer et utiliser des API

S'inscrire gratuitementTélécharger
Comment utiliser Claude Code Skills pour CI/CD