Accueil › Claude Code › GitHub

Claude Code et GitHub : le guide complet de l’intégration

Claude Code s’intègre à GitHub via deux produits distincts : une GitHub Action open source gratuite (hors tokens API) pour les automatisations flexibles, et Code Review, un service managé multi-agents à 15-25 $ par PR pour les revues approfondies. Ce guide couvre les deux.

Deux produits, deux philosophies

Avant de plonger dans la configuration, il faut comprendre que Claude Code propose deux intégrations GitHub distinctes qui coexistent.

La GitHub Action (anthropics/claude-code-action@v1) est open source, gratuite (vous ne payez que les tokens API consommés) et s’exécute sur vos propres runners GitHub. C’est un outil flexible que vous configurez via des workflows YAML. Vous contrôlez les déclencheurs, les prompts et les permissions. Elle convient aux vérifications rapides, à l’implémentation de features depuis les issues, à la génération de documentation et à tout workflow custom que vous pouvez imaginer.

Le Code Review est un service managé lancé le 9 mars 2026 en research preview. Il envoie une équipe d’agents IA en parallèle pour analyser chaque PR en profondeur. Le focus est sur les erreurs logiques, les régressions et les vulnérabilités de sécurité, pas le style. Les reviews prennent environ 20 minutes et coûtent 15 à 25 $ par PR. Disponible uniquement sur les plans Team et Enterprise.

Installation et configuration initiale

Méthode rapide : /install-github-app

La méthode la plus simple pour configurer l’intégration GitHub passe directement par le terminal Claude Code.

# Dans votre terminal, lancez Claude Code
claude

# Tapez la commande d'installation
/install-github-app

Claude Code vous guide ensuite pas à pas. Il installe l’app GitHub officielle (github.com/apps/claude) sur votre dépôt, configure les permissions nécessaires et crée une PR contenant le fichier de workflow .github/workflows/claude.yml.

Avant de merger cette PR, ajoutez votre clé API Anthropic comme secret GitHub : allez dans Settings > Secrets and variables > Actions de votre repo, et créez un secret nommé ANTHROPIC_API_KEY avec votre clé depuis la console Anthropic.

Méthode manuelle

Si la commande échoue ou si votre organisation exige une revue explicite de chaque fichier YAML, la configuration manuelle se fait en trois étapes.

Étape 1 : Installer l’app GitHub. Rendez-vous sur https://github.com/apps/claude et installez l’application sur votre dépôt ou organisation. Sélectionnez les dépôts auxquels Claude doit avoir accès.

Étape 2 : Configurer le secret API. Dans votre dépôt GitHub, allez dans Settings > Secrets and variables > Actions. Créez un secret ANTHROPIC_API_KEY. N’utilisez jamais une clé en dur dans vos fichiers YAML.

Étape 3 : Créer le workflow. Ajoutez un fichier .github/workflows/claude.yml dans votre dépôt :

name: Claude Code
on:
  issue_comment:
    types: [created]
  pull_request_review_comment:
    types: [created]

jobs:
  claude:
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}

Ce workflow minimal répond aux mentions @claude dans les commentaires de PRs et d’issues. Vous pouvez ensuite l’enrichir avec des déclencheurs supplémentaires.

Authentification avec les fournisseurs cloud

Pour les équipes utilisant AWS Bedrock ou Google Vertex AI, l’authentification passe par OIDC plutôt que par une clé API statique. C’est plus sécurisé car les credentials sont temporaires et automatiquement renouvelés.

La configuration nécessite de créer votre propre GitHub App (pour un contrôle total sur les permissions), puis de configurer OIDC entre GitHub Actions et votre fournisseur cloud. La documentation détaillée est dans docs/cloud-providers.md du repo anthropics/claude-code-action.

GitHub Action : workflows et automatisations

Comment ça fonctionne

L’action anthropics/claude-code-action@v1 exécute le runtime complet de Claude Code dans un runner GitHub Actions. Ce n’est pas un simple appel API : Claude a accès à votre dépôt, votre historique Git, vos diffs et peut lire, écrire et committer des fichiers.

L’action détecte intelligemment le mode d’activation selon le contexte du workflow. Quand quelqu’un mentionne @claude dans un commentaire de PR ou d’issue, Claude lit le contexte et répond. Pour les workflows d’automatisation avec un prompt explicite, Claude exécute la tâche sans attendre de mention.

Workflow 1 : Revue de code automatique

Le cas d’usage le plus courant. Claude analyse chaque PR à son ouverture ou mise à jour.

name: 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
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Revue cette PR. Focus sur la qualité du code,
            les bugs potentiels et le respect des standards du projet.
            Sois concis et actionnable.

Workflow 2 : Issue vers Pull Request

Transformez une issue en code fonctionnel avec un simple commentaire @claude implémente cette feature.

name: Claude Issue Implementation
on:
  issue_comment:
    types: [created]

jobs:
  implement:
    if: contains(github.event.comment.body, '@claude')
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write
      issues: read
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}

Quand quelqu’un écrit @claude implémente cette feature dans une issue, Claude lit la description de l’issue, comprend la demande, écrit l’implémentation, crée une branche et ouvre une PR avec les changements.

Workflow 3 : Documentation automatique

Claude détecte les pages de documentation affectées par les changements de code et les met à jour automatiquement.

name: Claude Documentation Update
on:
  pull_request:
    types: [opened, synchronize]
    paths:
      - 'src/**'
      - 'lib/**'

jobs:
  update-docs:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      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: |
            Analyse les changements de code dans cette PR.
            Identifie les fichiers de documentation dans docs/
            qui doivent être mis à jour. Mets-les à jour et
            committe les changements dans cette PR.

Workflow 4 : Génération de tests

name: Claude Test Generation
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  generate-tests:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      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: |
            Lis le nouveau code dans cette PR. Écris les tests
            unitaires correspondants. Committe-les sur la même branche.
            Utilise le framework de test existant du projet.

Workflow 5 : Notes de release

name: Claude Release Notes
on:
  release:
    types: [created]

jobs:
  release-notes:
    runs-on: ubuntu-latest
    permissions:
      contents: 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: |
            Résume tous les changements depuis la dernière release.
            Génère des notes de release lisibles pour les utilisateurs,
            organisées par catégorie (features, corrections, breaking changes).

Configuration avancée de l’Action

Le paramètre claude_args accepte les arguments CLI de Claude Code, ce qui donne un contrôle fin sur le comportement.

- uses: anthropics/claude-code-action@v1
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    model: claude-opus-4-6          # Utiliser Opus au lieu de Sonnet
    prompt: "Revue de sécurité approfondie"
    claude_args: "--max-turns 5 --effort high"

Pour les organisations qui veulent un nom d’utilisateur personnalisé ou un flux d’authentification custom, créez votre propre GitHub App avec les permissions requises (contents, issues, pull requests) et utilisez actions/create-github-app-token pour générer les tokens dans vos workflows.

Permissions YAML

Les permissions du workflow déterminent ce que Claude peut faire. Voici les combinaisons courantes :

Code Review : le service managé multi-agents

Comment ça fonctionne

Quand une PR est ouverte sur un dépôt activé, Code Review envoie une flotte d’agents spécialisés qui travaillent en parallèle. Chaque agent cherche des bugs sous un angle différent. Un agent de vérification filtre les faux positifs en contre-vérifiant les trouvailles. Un agent final agrège les résultats, déduplique, et classe les problèmes par sévérité.

Le résultat est un commentaire résumé structuré dans la PR, accompagné de commentaires inline sur les lignes problématiques. Chaque bug trouvé inclut une explication pas-à-pas : quel est le problème, pourquoi c’est risqué, et comment le corriger.

Le système de sévérité utilise trois niveaux visuels : rouge pour les problèmes critiques, jaune pour les risques potentiels, et violet pour les bugs préexistants dans le code historique que la PR touche.

Les chiffres internes d’Anthropic

Anthropic utilise Code Review sur presque toutes ses propres PRs. Voici les données publiées :

Un exemple marquant de leur usage interne : un développeur avait fait un changement d’une seule ligne dans un service de production. En apparence anodin, il aurait passé une revue humaine rapide. Code Review l’a signalé comme critique : le changement cassait l’authentification du service.

Configuration de Code Review

L’activation se fait depuis le panneau d’administration Claude Code, pas depuis le terminal.

Étape 1. Connectez-vous à claude.ai/admin-settings/claude-code avec un compte admin.

Étape 2. Trouvez la section Code Review et cliquez sur Setup. Cela lance l’installation de l’app GitHub Claude sur votre organisation.

Étape 3. Suivez les prompts pour accorder les permissions (contents en lecture, pull requests en lecture et écriture).

Étape 4. Sélectionnez les dépôts à activer. Commencez par 2-3 repos critiques pour contrôler les coûts.

Étape 5. Choisissez le mode de déclenchement :

Personnaliser Code Review

Deux fichiers à la racine de votre dépôt influencent le comportement de Code Review.

CLAUDE.md : définit les conventions de code, l’architecture du projet et les règles générales. Claude suit ces guidelines pendant la review, exactement comme en usage local.

REVIEW.md : fichier dédié aux critères de review. Vous pouvez y spécifier ce que Claude doit vérifier ou ignorer. C’est l’endroit pour ajouter des règles spécifiques aux reviews sans polluer le CLAUDE.md général.

# REVIEW.md

## Focus
- Erreurs logiques et régressions
- Gestion d'erreurs manquante
- Vulnérabilités de sécurité (injection, XSS, auth)
- Conformité aux patterns définis dans CLAUDE.md

## Ignorer
- Problèmes de style (gérés par le linter)
- Commentaires de code
- Nommage des variables (sauf incohérences flagrantes)

Limites de Code Review

Code Review n’est pas un remplacement de la revue humaine. Il ne peut pas approuver ni bloquer une PR. Il ne peut pas merger. Les trouvailles sont informatives : c’est à votre équipe de décider quoi faire.

Autres limites concrètes : GitHub uniquement (pas de GitLab, Bitbucket ni Azure DevOps pour l’instant), non compatible avec les organisations Zero Data Retention, analyse par raisonnement uniquement (pas d’exécution de code), et temps de review d’environ 20 minutes qui peut créer de la friction si votre équipe merge rapidement.

Le plugin /code-review local

En plus du service managé et de l’Action, Claude Code inclut un plugin /code-review qui s’exécute localement depuis votre terminal. C’est une troisième option, positionnée entre les deux.

# Review locale (output dans le terminal)
/code-review

# Poster la review comme commentaire sur la PR
/code-review --comment

Le plugin lance 4 agents de review en parallèle, score chaque trouvaille sur un indice de confiance, et ne retourne que les problèmes avec un score supérieur à 80 (sur 100). Si aucun problème à haute confiance n’est trouvé, il ne produit rien. Vous pouvez ajuster le seuil dans le fichier de commande.

Le workflow typique : créez votre PR localement, lancez /code-review pour un premier passage, corrigez les problèmes signalés, puis utilisez /code-review --comment pour poster la review sur GitHub avant de demander une revue humaine.

CLAUDE.md en contexte CI/CD

Votre fichier CLAUDE.md est lu par Claude Code en local comme en CI. Mais les contextes sont différents. Ajoutez une section spécifique pour le CI dans votre CLAUDE.md :

## Contexte CI/CD
Quand tu exécutes dans GitHub Actions :
- Ne modifie pas les fichiers de configuration sauf demande explicite
- Crée toujours une nouvelle branche, ne committe jamais sur main
- Formate les commentaires PR en Markdown GitHub
- Inclus les chemins de fichiers comme liens cliquables
- Exécute le linter et les tests avant de committer

Pour les permissions, le CI a besoin de contraintes spécifiques. Verrouillez les commandes autorisées dans votre workflow YAML pour éviter que Claude exécute des commandes destructives :

- uses: anthropics/claude-code-action@v1
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    claude_args: "--allowedTools 'Read,Write,Bash(npm test),Bash(npm run lint)'"

Sécurité et bonnes pratiques

Gestion des clés API

Stockez toujours votre clé API dans les GitHub Secrets, jamais en dur dans les fichiers YAML. Pour les organisations, utilisez l’authentification OIDC avec Bedrock ou Vertex AI plutôt que des clés statiques. Les credentials OIDC sont temporaires et renouvelés automatiquement.

Principe du moindre privilège

Accordez uniquement les permissions nécessaires. Pour une review en lecture seule, contents: read et pull-requests: write (pour poster les commentaires) suffisent. N’ajoutez contents: write que si Claude doit committer du code.

Restreindre les commandes

En CI, Claude ne devrait pas pouvoir exécuter n’importe quelle commande. Utilisez --allowedTools pour limiter les outils accessibles. Pas de rm -rf, pas de curl arbitraire, pas de commandes Docker non contrôlées.

Timeouts et budgets

Configurez des limites pour éviter les workflows qui s’emballent :

- uses: anthropics/claude-code-action@v1
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    claude_args: "--max-turns 5 --max-budget-usd 3.00"
  timeout-minutes: 15

Un timeout de 15 minutes pour les tâches générales et 10 minutes pour les reviews est un bon point de départ.

Claude Code GitHub vs la concurrence

L’avantage unique de Claude Code par rapport à GitHub Copilot et aux autres outils de review est sa capacité d’action. Claude ne fait pas que commenter : il peut implémenter des features, créer des PRs, générer des tests et mettre à jour la documentation. La GitHub Action est un véritable runtime d’agent, pas un wrapper d’API.

Pour les reviews pures, le rapport coût/profondeur de Code Review se justifie sur les PRs critiques (refactoring massifs, services de production, code de sécurité). Pour les PRs courantes, l’Action open source ou Copilot sont plus économiques.

Codex d’OpenAI propose une intégration GitHub similaire via ses propres GitHub Actions, mais l’écosystème de Claude Code (Action open source + Code Review managé + plugin local) offre plus de flexibilité dans le choix du niveau de profondeur et de coût.

Cas d’usage concrets

Pour une équipe de développement

L’intégration type pour une équipe combine trois couches. La GitHub Action en mode @claude pour que tout développeur puisse poser des questions ou demander de l’aide directement dans les PRs. Code Review activé en mode « ouverture » sur les repos critiques pour une analyse approfondie automatique. Et le plugin /code-review local pour que chaque dev fasse un premier passage avant de soumettre sa PR.

Les retours d’équipes en production montrent que les juniors bénéficient particulièrement de l’intégration : ils peuvent demander à Claude d’expliquer des changements ou de clarifier l’architecture directement dans les PRs, ce qui accélère l’onboarding.

Pour un développeur solo

Un développeur solo sur un plan Pro ou Max n’a pas accès à Code Review, mais la GitHub Action suffit largement. Configurez un workflow de review automatique avec un prompt serré, et utilisez @claude dans vos PRs pour un second regard sur votre code. L’issue-to-PR est particulièrement utile quand vous gérez un backlog : créez des issues détaillées, puis demandez à Claude de les implémenter.

Pour un projet open source

L’Action Claude Code peut être configurée pour gérer les contributions externes. Un workflow dédié analyse les PRs des contributeurs externes avec des instructions spécifiques : vérifier la conformité aux guidelines du projet, détecter les problèmes de sécurité, et poster un résumé automatique pour faciliter la revue par les mainteneurs.

Questions fréquentes