Intégration Git - Aide-memoire

Cet aide-mémoire couvre toutes les commandes Git intégrées à Claude Code : commits intelligents, gestion des branches et pull requests, résolution de conflits, checkpoints et navigation dans l'historique. Gardez cette fiche pratique sous la main pour automatiser vos workflows Git directement depuis votre terminal conversationnel.

L'intégration Git dans Claude Code est un ensemble de fonctionnalités qui permet de piloter l'intégralité du cycle Git (du commit à la pull request) par des instructions en langage naturel. Claude Code gère nativement les commits, branches, merges, checkpoints et l'analyse d'historique sans quitter votre éditeur.

L'intégration Git vise à réduire le temps passé sur les opérations Git quotidiennes en les pilotant directement depuis votre terminal conversationnel.

Quelles sont les commandes Git les plus fréquentes dans Claude Code ?

Voici le tableau de référence rapide des commandes que vous utiliserez le plus souvent. Chaque ligne est autonome et peut être copiée telle quelle dans votre terminal.

Commande / Instruction	Description	Exemple concret
Langage naturel	"Commite mes changements" pour un commit conventionnel	`claude "commite"`
`/diff`	Ouvre un visualiseur interactif des modifications	`/diff`
`/security-review`	Analyse les changements pour détecter des vulnérabilités	`/security-review`
`créer une branche`	Crée et bascule sur une nouvelle branche	`crée une branche feat/auth`
`ouvrir une PR`	Crée une pull request via `gh pr create`	`ouvre une PR vers main`
`résoudre les conflits`	Analyse et résout les merge conflicts	`résous les conflits de merge`
Esc + Esc	Ouvre le menu de restauration (rewind) lorsque la saisie est vide	Double-tap Échap, champ de saisie vide
`git log`	Parcourt l'historique des commits	`montre les 10 derniers commits`
`--worktree` / `-w`	Lance Claude Code dans un git worktree isolé	`claude -w`

Ce tableau constitue votre fiche pratique d'intégration Git, aide-mémoire que vous pouvez imprimer ou épingler. Pour une vue d'ensemble des autres raccourcis, consultez l'aide-mémoire des commandes slash essentielles.

À retenir : ces 8 commandes couvrent la grande majorité des interactions Git quotidiennes dans Claude Code.

Comment fonctionnent les commits conversationnels intelligents ?

Un commit conversationnel intelligent est une fonctionnalité de Claude Code qui analyse automatiquement votre git diff, identifie la nature des changements (feature, fix, refactor, docs) et génère un message de commit conforme à la convention Conventional Commits.

Syntaxe et options

Exécutez simplement une instruction en langage naturel. Claude Code se charge du reste.

# Commit basique - Claude analyse le diff et propose un message
$ claude "commit les changements"

# Commit avec scope spécifique
$ claude "commit les changements du module auth"

# Commit avec type forcé
$ claude "commit en tant que fix pour le bug de login"

Concrètement, Claude Code exécute git add sur les fichiers pertinents, puis git commit -m avec un message structuré. Vous gardez le contrôle : Claude demande votre validation avant d'exécuter le commit.

Tableau des formats de commit générés

Type	Préfixe	Exemple de message généré
Nouvelle fonctionnalité	`feat:`	`feat(auth): add OAuth2 login flow`
Correction de bug	`fix:`	`fix(api): resolve null pointer on empty response`
Refactoring	`refactor:`	`refactor(utils): extract date formatting helpers`
Documentation	`docs:`	`docs(readme): update installation instructions`
Tests	`test:`	`test(auth): add unit tests for token refresh`
Performance	`perf:`	`perf(query): optimize SQL join with index hint`

En pratique, le message généré reste concis et respecte la limite de 72 caractères pour la ligne de sujet, recommandée par les conventions Git. Pour comprendre comment Claude Code interprète vos instructions, référez-vous à l'aide-mémoire de vos premières conversations.

Si vous rencontrez des erreurs lors du commit, le guide des erreurs courantes d'intégration Git détaille les solutions pour chaque cas.

À retenir : vous décrivez l'intention en français, Claude Code produit un commit Conventional Commits structuré en anglais.

Comment automatiser la gestion des branches et pull requests ?

La gestion des branches dans Claude Code est un workflow qui transforme vos instructions en commandes git branch, git checkout et gh pr create sans intervention manuelle. Lancez vos opérations de branching en langage naturel.

# Créer une branche feature
$ claude "crée une branche feature/user-profile"

# Basculer sur une branche existante
$ claude "switch sur la branche develop"

# Créer une branche depuis un commit spécifique
$ claude "crée une branche hotfix/login depuis le tag v2.0.1"

Chaque branche créée suit la convention de nommage type/description-courte. Claude Code détecte automatiquement le type (feature, fix, hotfix, chore) à partir de votre description.

Création de pull requests automatisées

Configurez au préalable le CLI GitHub (gh) pour que Claude Code puisse créer vos PR. L'outil utilise gh pr create en arrière-plan avec les paramètres que vous indiquez.

# PR simple vers main
$ claude "ouvre une PR vers main"

# PR avec titre et description personnalisés
$ claude "ouvre une PR 'Add user profile page' avec la description des changements"

# PR en draft
$ claude "ouvre une draft PR vers develop"

Action	Commande naturelle	Commande Git sous-jacente
Créer une branche	`crée une branche feat/x`	`git checkout -b feat/x`
Pousser la branche	`pousse la branche`	`git push -u origin feat/x`
Créer une PR	`ouvre une PR vers main`	`gh pr create --base main`
Créer une draft PR	`ouvre une draft PR`	`gh pr create --draft`
Lister les PR ouvertes	`montre les PR ouvertes`	`gh pr list`
Voir les checks CI	`montre le statut de la PR`	`gh pr checks`

L'automatisation des pull requests peut contribuer à raccourcir le cycle de review en réduisant les étapes manuelles. Pour approfondir les workflows de branches, consultez le guide d'intégration Git complet qui détaille chaque étape.

À retenir : Claude Code enchaîne automatiquement git add, git commit, git push et gh pr create. Vous décrivez le résultat souhaité, il exécute la séquence.

Comment résoudre les merge conflicts avec Claude Code ?

La résolution de merge conflicts est le processus par lequel Claude Code analyse les marqueurs de conflit (<<<<<<<, =======, >>>>>>>), comprend l'intention des deux branches et propose une résolution cohérente. Cette fonctionnalité réduit significativement le temps de résolution des conflits.

Workflow de résolution

Vérifiez d'abord l'état des conflits, puis demandez à Claude Code de les résoudre.

# Démarrer un merge et détecter les conflits
$ git merge feature/auth
# Si conflits détectés :
$ claude "résous les conflits de merge"

# Résolution sélective (un seul fichier)
$ claude "résous le conflit dans src/auth/login.ts"

# Rebase interactif avec résolution
$ claude "rebase ma branche sur main et résous les conflits"

En pratique, Claude Code lit le contexte des deux côtés du conflit, identifie les modifications intentionnelles et propose un merge qui préserve les deux ensembles de changements quand c'est possible.

Étapes de résolution détaillées

Exécutez git merge ou git rebase normalement
Claude Code détecte les fichiers en conflit via git status
Il affiche chaque conflit avec le contexte des deux branches
Il propose une résolution et vous demande validation
Après votre approbation, il marque les fichiers comme résolus (git add)
Il finalise avec un commit de merge ou continue le rebase

Scénario de conflit	Comportement de Claude Code	Action requise
Modifications sur des lignes différentes	Fusion automatique proposée	Validez la proposition
Modifications sur les mêmes lignes	Analyse du contexte sémantique	Choisissez la version à garder
Fichier supprimé d'un côté	Signale le conflit de suppression	Décidez : garder ou supprimer
Renommage conflictuel	Détecte les deux noms	Indiquez le nom final
Conflit binaire (images)	Signale l'impossibilité de merge	Sélectionnez manuellement

Si vous débutez avec cette fonctionnalité, le tutoriel d'intégration Git propose un exercice pas à pas sur la résolution de conflits. Consultez également les bonnes pratiques d'intégration Git pour prévenir les conflits en amont.

À retenir : Claude Code comprend le contexte sémantique de vos conflits : il ne se contente pas de comparer des lignes, il analyse l'intention du code.

Quels sont les raccourcis clavier pour les checkpoints et Esc+Esc ?

Un checkpoint est un instantané interne de l'état de votre code, créé automatiquement par Claude Code avant chaque édition de fichier. Ce n'est ni un commit ni un snapshot Git : il s'agit d'un mécanisme de restauration locale, complémentaire du contrôle de version Git et non un remplacement de celui-ci. Le raccourci Esc + Esc (double-tap sur la touche Échap) ouvre le menu de restauration (rewind) uniquement lorsque le champ de saisie est vide. Si la saisie contient du texte, ce double-tap efface le brouillon au lieu d'ouvrir le menu. Ce n'est donc pas un raccourci d'annulation instantanée pendant que Claude Code édite : pour interrompre Claude en cours d'édition, appuyez une seule fois sur Échap.

Fonctionnement des checkpoints

Claude Code crée automatiquement un point de restauration (checkpoint) avant ses modifications. Pour revenir en arrière, utilisez /rewind (ou Esc + Esc lorsque la saisie est vide) afin d'ouvrir le menu de restauration.

# Ouvrir le menu de restauration (saisie vide)
Esc + Esc # Double-tap quand le champ de saisie est vide

# Restaurer un checkpoint spécifique
$ claude "reviens au checkpoint d'il y a 3 modifications"

# Lister les checkpoints disponibles
$ claude "montre les checkpoints"

Concrètement, les checkpoints sont créés rapidement et automatiquement avant chaque modification, sans intervention de votre part.

Tableau des raccourcis clavier essentiels

Raccourci	Action	Contexte
Esc + Esc	Ouvrir le menu de restauration (rewind)	Quand la saisie est vide ; sinon, efface le brouillon
Esc (simple)	Annuler la génération en cours	Pendant la réponse de Claude Code
Ctrl + C	Interrompre la commande courante	Pendant l'exécution d'une commande
/rewind	Ouvrir le menu de restauration des checkpoints	À tout moment dans la session
Tab	Accepter la suggestion	Quand une proposition apparaît

Le mécanisme de checkpoint s'intègre avec l'aide-mémoire des permissions et sécurité : les checkpoints respectent les règles de permissions configurées. Pour mieux comprendre comment configurer votre environnement initial, l'aide-mémoire d'installation et premier lancement couvre la mise en place complète.

À retenir : Esc + Esc est votre filet de sécurité, utilisez-le sans hésitation. Les checkpoints sont créés automatiquement avant chaque modification.

Comment exploiter le git log et l'historique conversationnel ?

Le git log conversationnel est une fonctionnalité de Claude Code qui permet de parcourir, filtrer et analyser l'historique Git en posant des questions en langage naturel au lieu de mémoriser les options de git log.

Commandes d'exploration de l'historique

Ouvrez Claude Code et interrogez votre historique comme vous le feriez avec un collègue.

# Historique récent
$ claude "montre les 5 derniers commits"

# Recherche par auteur
$ claude "quels commits a fait Alice cette semaine ?"

# Recherche par fichier
$ claude "montre l'historique du fichier src/auth/login.ts"

# Recherche par contenu
$ claude "trouve le commit qui a ajouté la fonction validateToken"

# Comparaison entre branches
$ claude "quelles différences entre main et feature/auth ?"

Claude Code traduit ces requêtes en commandes git log avec les options appropriées (--author, --since, --follow, -S, --oneline), couvrant la plupart des cas d'usage courants du git log.

Tableau de correspondance langage naturel → git log

Question posée	Commande Git générée	Résultat
"derniers 10 commits"	`git log --oneline -10`	Liste concise
"commits de cette semaine"	`git log --since="1 week ago"`	Filtrage temporel
"qui a modifié ce fichier ?"	`git log --follow -- fichier`	Historique du fichier
"cherche le mot validateToken"	`git log -S "validateToken"`	Recherche dans le code
"diff entre main et develop"	`git diff main...develop`	Comparaison de branches
"statistiques des commits"	`git shortlog -sn`	Classement par auteur

L'historique conversationnel de Claude Code conserve le contexte de vos questions précédentes pendant toute la session. Si vous demandez « montre les commits de la semaine » puis « filtre par Alice », Claude Code combine les deux filtres. Pour optimiser la gestion de ce contexte, consultez l'aide-mémoire de gestion du contexte.

À retenir : posez vos questions d'historique en français, Claude Code génère la commande git log optimale et interprète les résultats pour vous.

Peut-on combiner plusieurs opérations Git en une seule instruction ?

Le chaînage d'opérations Git est une capacité de Claude Code qui permet d'enchaîner plusieurs commandes Git dans une seule instruction conversationnelle. Vous décrivez le workflow complet, Claude Code planifie et exécute chaque étape dans l'ordre.

Exemples de workflows chaînés

# Workflow complet : commit + push + PR
$ claude "commit les changements, pousse et ouvre une PR vers main"

# Workflow de mise à jour : fetch + rebase + push
$ claude "mets à jour ma branche depuis main et pousse"

# Workflow de release : tag + push + changelog
$ claude "crée le tag v2.1.0 et pousse-le"

Le checkpoint automatique de Claude Code ne couvre que les éditions de fichiers réalisées via ses outils d'édition : les modifications effectuées par des commandes bash, dont les opérations Git, ne sont pas suivies par les checkpoints. Pour revenir en arrière sur des opérations Git, appuyez-vous sur Git lui-même (reset, revert, reflog). Si une étape échoue, Claude Code s'arrête et vous explique le problème sans poursuivre les étapes suivantes.

Workflow	Étapes exécutées
Commit + Push	`git add` → `git commit` → `git push`
Branch + Commit + PR	`git checkout -b` → `git add` → `git commit` → `git push -u` → `gh pr create`
Rebase + Push force	`git fetch` → `git rebase origin/main` → `git push --force-with-lease`
Stash + Switch + Pop	`git stash` → `git checkout` → `git stash pop`

En pratique, le chaînage évite de saisir chaque commande à la main : vous décrivez le workflow et Claude Code l'exécute étape par étape. Le guide complet d'intégration Git détaille tous les workflows chaînés disponibles.

Pour maîtriser ces workflows avancés, SFEIR Institute propose la formation Développeur Augmenté par l'IA – Avancé sur une journée, avec des labs pratiques où vous enchaînez des workflows Git complexes supervisés par Claude Code.

À retenir : décrivez votre workflow Git complet en une phrase, Claude Code décompose, exécute et vérifie chaque étape, et s'arrête au moindre échec sans poursuivre la séquence.

Quels sont les pièges à éviter avec l'intégration Git ?

La prévention des erreurs Git est un aspect fondamental de l'utilisation de Claude Code en environnement de production. Voici les erreurs les plus fréquentes et comment les contourner.

Piège	Risque	Solution
`push --force` sans vérification	Perte de commits distants	Demandez explicitement `--force-with-lease` plutôt que `--force` pour éviter d'écraser des commits distants
Commit de fichiers sensibles (.env)	Fuite de secrets	Claude Code respecte par défaut votre `.gitignore` (paramètre `respectGitignore`), mais cela ne garantit pas l'exclusion d'un secret déjà suivi ; utilisez les règles de permission `deny` (ex. `Read(./.env)`) pour protéger les fichiers sensibles
Merge sur la mauvaise branche	Code instable en production	Vérifiez la branche cible avec `git branch --show-current`
Oublier de stash avant switch	Perte de modifications	Claude Code propose un stash automatique
Rebase sur une branche partagée	Historique réécrit pour tous	Claude Code avertit si la branche a des collaborateurs

Claude Code refuse automatiquement les commandes destructives comme git reset --hard ou git clean -fd sans confirmation explicite de l'utilisateur. Les commandes destructives déclenchent une demande de confirmation selon les règles de permission configurées.

Configurez vos règles de sécurité via le fichier CLAUDE.md à la racine de votre projet pour personnaliser les restrictions. L'aide-mémoire des permissions et sécurité explique comment ajuster ces paramètres.

Si vous souhaitez approfondir ces mécaniques Git avec Claude Code en conditions réelles, la formation Claude Code proposée par SFEIR Institute couvre en une journée l'intégration Git complète, du premier commit à la gestion de PR complexes, avec des exercices pratiques sur des dépôts réels. La formation Développeur Augmenté par l'IA sur deux jours étend ces compétences à l'ensemble des workflows de développement assisté par IA.

À retenir : Claude Code applique des garde-fous par défaut sur les commandes Git destructives : vous gardez le contrôle sans risquer de casser votre historique.

Faut-il configurer Git différemment pour Claude Code ?

La configuration Git pour Claude Code est un ensemble d'ajustements optionnels qui optimisent la compatibilité entre votre environnement Git local et les fonctionnalités conversationnelles de Claude Code.

Configuration recommandée

# Vérifier que Git est installé (utilisez une version récente)
$ git --version

# Configurer le CLI GitHub pour les PR automatisées
$ gh auth login

# Activer la coloration pour un meilleur parsing par Claude Code
$ git config --global color.ui auto

# Configurer le format de diff par défaut
$ git config --global diff.algorithm histogram

Claude Code nécessite simplement que Git soit installé, sans version minimale documentée. Le binaire natif n'utilise pas Node.js ; Node.js 18 ou supérieur n'est requis que pour l'installation via npm. En pratique, la quasi-totalité des fonctionnalités sont disponibles sans configuration supplémentaire.

Paramètre	Valeur recommandée	Impact
`git config core.autocrlf`	`input` (macOS/Linux)	Évite les faux diffs sur les fins de ligne
`git config pull.rebase`	`true`	Historique linéaire plus lisible
`git config diff.algorithm`	`histogram`	Diffs plus précis pour Claude Code
`git config merge.conflictstyle`	`diff3`	Contexte supplémentaire lors des conflits
`gh auth status`	Authentifié	Requis pour les opérations PR

Pour une configuration initiale complète de votre environnement, l'aide-mémoire d'installation et premier lancement vous guide étape par étape. Le tutoriel d'intégration Git détaille les cas d'usage avancés de configuration.

À retenir : Claude Code fonctionne sans configuration spéciale, mais activer diff3 et histogram améliore la qualité des résolutions de conflits et des diffs analysés.