Cours Vibe coding avec Claude Code · Module 2: Un projet Next.js avec Claude Code

Git et GitHub avec Claude Code : le journal de bord du projet

12 min de lecture ·
Dans cette leçon13

Ohé ! Kraken's Call a une section hero et une page de l'équipage, et le journal de bord ses premières entrées. Aujourd'hui, tu vas le tenir comme dans un vrai projet : tu liras les changements avant de les enregistrer, tu ouvriras une branche à part pour une nouvelle fonctionnalité et tu enverras le projet sur GitHub, où ton mentor pourra le voir.

Problème : dix fichiers en une minute

Claude peut modifier dix fichiers en une minute. Si tu n'enregistres pas les états qui fonctionnaient, après un changement raté tu ne sais pas ce qu'il y avait avant, et tu n'as nulle part où revenir. Il y a aussi un second souci : tout l'historique n'est que sur ton disque. Quand le disque lâche, le projet disparaît, et ton mentor n'a aucun moyen de le voir.

Ce que tu sais déjà, et ce qui s'ajoute

Dans la leçon 0_6, tu as découvert le dépôt, le commit, la boucle de travail avec point de contrôle, Source Control dans Cursor et le fichier .gitignore. Aujourd'hui s'ajoutent : la revue des changements avant le commit, une description qui te dira encore quelque chose dans une semaine, les branches et GitHub. Les commandes, c'est toujours Claude qui les lance, et toi, tu les lis et tu les approuves : la documentation de Claude Code dit que Git devient une conversation.

Deux mots faciles à confondre. Git est un programme sur ton ordinateur qui tient l'historique du projet. GitHub est un service sur internet qui garde une copie de cet historique et permet de le montrer aux autres. Git fonctionne sans GitHub, et GitHub ne reçoit que ce que tu lui envoies depuis Git.

Demande : la revue avant l'enregistrement

La page de l'équipage de la leçon précédente attend d'être enregistrée. Avant qu'elle n'entre dans l'historique, demande une revue à Claude :

Demande pour Claude Code :

Montre quels fichiers ont changé depuis le dernier commit et propose
une description de commit : la première ligne, de 50 caractères au
maximum, dit quoi, la deuxième dit pourquoi. Ne fais pas le commit
tant que je n'ai pas approuvé la description.

La demande sépare deux étapes : d'abord la revue et la proposition, ensuite l'enregistrement avec ton accord. Sans la dernière phrase, Claude pourrait faire le commit tout de suite, avant que tu n'aies lu les changements.

Ce que Claude a écrit

Avant d'écrire quoi que ce soit, Claude vérifie l'état du projet. Il lance git status, une commande qui ne fait que lire l'état du dépôt et ne change rien. Le résultat ressemble à ceci :

On branch main
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        app/crew/

nothing added to commit but untracked files present (use "git add" to track)

« On branch main » est la branche sur laquelle tu te trouves. « Untracked files » sont les fichiers que Git ne suit pas encore, ici le nouveau dossier app/crew/. Un fichier que Git connaît déjà et qui a changé figurerait sous l'intitulé « Changes not staged for commit », et ses lignes modifiées, Claude les montrerait avec la commande git diff. Aucune de ces commandes n'enregistre quoi que ce soit dans l'historique.

Ensuite arrive la proposition de description, par exemple celle-ci :

Page de l'équipage avec les types CrewMember et CrewCard

Données de l'équipage décrites par une interface pour que le build attrape les champs erronés.

Avant de l'approuver, ouvre Source Control dans Cursor et clique sur chaque fichier de la liste, comme dans la leçon 0_6. Le nouveau fichier s'affichera en entier comme ajouté. Tu vérifies deux choses : que la liste ne contient que les fichiers que tu as demandés, et que leur contenu n'a rien d'étranger.

Une bonne description de commit

La documentation de Git conseille de commencer la description par une seule ligne courte, de 50 caractères au maximum, qui résume le changement, puis de laisser une ligne vide et d'ajouter une explication plus longue. La première ligne devient le titre du commit, que tu verras dans chaque vue de l'historique. Compare deux titres pour le même changement :

update files
Page de l'équipage avec les types CrewMember et CrewCard

Du premier, tu ne tireras rien dans une semaine : ni quels fichiers, ni pourquoi. Le second dit ce qui est né, et la deuxième ligne de la proposition de Claude précise pourquoi. Conseil du capitaine : le titre dit quoi, la suite dit pourquoi, et le « comment » se voit dans le diff, donc inutile de le décrire.

L'entrée dans le journal

Quand tu auras approuvé la description, Claude demandera l'autorisation de lancer deux commandes :

git add app/crew/page.tsx
git commit -m "Page de l'équipage avec les types CrewMember et CrewCard" -m "Données de l'équipage décrites par une interface pour que le build attrape les champs erronés."

git add avec un nom de fichier ajoute à l'enregistrement exactement ce fichier et rien d'autre. git commit -m enregistre l'état comme un point de contrôle avec une description, et le second -m ajoute un deuxième paragraphe. Le commit reste sur ton ordinateur : rien n'est encore parti sur internet. Quand tu écriras ensuite « montre les derniers commits », Claude lancera git log --oneline et montrera à peu près cette liste :

0b63fee Page de l'équipage avec les types CrewMember et CrewCard
1171d45 Section hero de Kraken's Call avec Tailwind
4e2a9c1 En-tête de la page d'accueil : Ohé, Pirates !
edfa513 Initial commit from Create Next App

Chaque ligne est une entrée : l'abrégé du commit et son titre, le plus récent en haut. Les abrégés et les descriptions seront différents chez toi, mais l'ordre devrait correspondre aux leçons que tu as suivies.

Ce qui n'entre pas dans le dépôt

Avant d'envoyer quoi que ce soit sur internet, vérifie ce que Git n'enregistrera pas. L'assistant de la leçon 1_2 a créé un fichier .gitignore avec une liste toute prête. Ouvre-le dans Cursor ; les lignes les plus importantes sont :

/node_modules
/.next/
.env*
*.pem
next-env.d.ts

/node_modules est la cale de la leçon 1_1, et /.next/ le résultat du build : tu rétabliras les deux avec une seule commande. L'astérisque dans .env* veut dire n'importe quelle fin, donc Git ignore à la fois .env et .env.local, avec les clés d'API. *.pem sont des fichiers de clés, et next-env.d.ts est généré par Next.js lui-même. Si tu vois malgré tout l'un de ces fichiers dans Source Control, arrête Claude avant qu'il ne l'enregistre.

GitHub : le port de ton projet

Le compte sur github.com, tu le crées toi-même. À l'envoi, Git doit aussi prouver que c'est bien toi, et la documentation de GitHub recommande pour cela GitHub CLI, c'est-à-dire le programme gh, ou Git Credential Manager. Nous choisissons gh, car il créera aussi le dépôt avec une seule commande, et les bonnes pratiques de Claude Code conseillent de donner à l'agent des outils en ligne de commande. Installe-le d'après la page cli.github.com et, dans un deuxième terminal de Cursor, hors de la session Claude, connecte-toi toi-même :

gh auth login

À la question sur le protocole, choisis HTTPS, et à la question de savoir s'il faut authentifier Git avec les identifiants de GitHub, réponds Y. La connexion, c'est toi qui la fais, pas Claude : ce sont les clés de ton compte.

Le dépôt sera public, car à la fin du lieu tu montreras le lien à ton mentor, et c'est pour cela que .gitignore était si important. Reviens dans la session Claude :

Demande pour Claude Code :

Crée avec gh un dépôt public krakens-call sur mon compte GitHub,
définis-le comme origin et envoie la branche main. Montre la commande
avant de la lancer, et à la fin le résultat de git remote -v.

Claude montrera la commande et demandera l'autorisation de la lancer :

gh repo create krakens-call --public --source=. --remote=origin --push

--public rend le dépôt public (--private le rend privé), --source=. désigne le dossier courant, --remote=origin enregistre le dépôt sous le nom habituel origin, et --push envoie tout de suite les commits. git remote -v affichera l'adresse du dépôt à côté du nom origin ; ouvre-la dans le navigateur, et tu verras les fichiers du projet et les commits.

Tu préfères créer le dépôt dans le navigateur ? Sur github.com, clique sur le plus en haut à droite et choisis New repository, saisis le nom, choisis la visibilité et clique sur Create repository. N'ajoute ni README, ni fichier .gitignore, ni licence : la documentation de GitHub avertit que, pour envoyer un projet existant, cela mène à des erreurs. Donne l'adresse du dépôt à Claude dans la demande, et il proposera deux commandes :

git remote add origin https://github.com/TON-LOGIN/krakens-call.git
git push -u origin main

git remote add enregistre l'adresse sous le nom origin. git push envoie les commits de la branche main, et -u mémorise cette liaison, donc les envois suivants se raccourcissent en git push. Le résultat se termine par la ligne « branch 'main' set up to track 'origin/main'. ». Tu donnes toi-même l'adresse pour une bonne raison : le mode auto bloque l'ajout d'un dépôt distant que tu n'as pas nommé. Les identifiants de gh auth login fonctionnent ici aussi, car gh les a mémorisés également pour Git.

Quand accepter un git push

git push envoie l'historique hors de ton ordinateur, et /rewind ne l'annulera pas : dans la leçon 0_6, tu as vu que le checkpoint ne retient que les fichiers. En mode Manual, Claude demandera l'accord. En mode auto, l'envoi vers le dépôt dans lequel tu travailles passe sans question, et ce qui est bloqué, c'est entre autres le force push. Conseil du capitaine : reste en Manual tant que l'envoi vers GitHub ne t'est pas devenu une habitude. Avant de cliquer sur Yes, vérifie trois choses :

  • la branche : tu envoies celle que tu comptais envoyer, par exemple main ou une branche de fonctionnalité ;
  • la cible : origin pointe vers ton dépôt, ce que montre git remote -v ;
  • pas de force : la commande ne contient ni --force ni -f, car la documentation de Git avertit qu'un force push peut faire perdre des commits au dépôt distant.

Les branches : un cap d'essai à part

Une branche (branch) est une ligne d'historique à part. Sur la branche main reste la version qui fonctionne, et la nouvelle fonctionnalité naît à côté, sur sa propre branche. Quand elle réussit, tu la fusionnes dans main ; quand elle échoue, tu abandonnes la branche, et main ne s'en aperçoit même pas. La prochaine section de la page, « Comment jouer », est une bonne occasion. Écris à Claude :

Crée une branche feature/how-to-play et bascule dessus.

Claude demandera l'autorisation pour une commande :

git switch -c feature/how-to-play

git switch change de branche, et -c en crée d'abord une nouvelle ; le terminal répondra « Switched to a new branch 'feature/how-to-play' ». La nouvelle branche part de l'endroit où tu es, donc les fichiers sur le disque ne changent pas. Les anciens tutoriels écrivent la même chose avec git checkout -b. Quand le changement de branche détruirait des modifications non enregistrées, Git refusera, c'est pourquoi tu fais un commit avant de basculer.

Quand la section sera prête et vérifiée, Claude fusionnera la branche dans main avec la commande git merge. Dans les équipes, on ouvre plutôt sur GitHub une pull request, c'est-à-dire une demande de fusion de la branche, avec de la place pour la revue du code. Tu la découvriras dans les lieux suivants. Sur un autre ordinateur, tu récupéreras le projet avec la commande git clone et l'adresse du dépôt, et les nouveaux changements de GitHub avec la commande git pull.

Revenir en arrière : trois cordages

Pour revenir en arrière, tu as trois cordages, chacun pour un moment différent :

  • avant le commit : /rewind de la leçon 0_6 annule les changements que Claude a faits dans les fichiers ;
  • un seul fichier : git restore app/page.tsx rejette les changements de ce fichier que tu n'as pas encore ajoutés avec git add ;
  • un commit envoyé : git revert avec le numéro du commit enregistre un nouveau commit qui annule les effets de l'ancien, donc l'historique sur GitHub reste intact.

Deux commandes effacent le travail sans retour : git reset --hard, qui jette les changements non enregistrés dans un commit, et git push --force. Le mode auto bloque les deux. Si tu vois l'une d'elles dans une demande d'autorisation, réponds No et demande à Claude un chemin plus doux.

La revue du capitaine

Avant chaque commit et chaque push, vérifie :

  1. Les secrets : dans le diff, il n'y a ni fichier .env, ni clés d'API, ni fichiers .pem.
  2. Le lest : dans la liste des changements, il n'y a ni node_modules ni .next.
  3. La description : le titre dit quoi, la deuxième ligne dit pourquoi, et ce n'est pas « update files ».
  4. La branche et la cible : le commit et le push vont sur la branche et vers le dépôt que tu avais prévus.

L'erreur typique de l'agent : git add . ou git add -A, qui ajoutent tout d'un coup, y compris un fichier qui traînait par hasard dans le dossier, ou un commit directement sur main alors que tu avais demandé de travailler sur une branche. Tu attraperas les deux dans la demande d'autorisation : lis ce qui se trouve après git add, et vérifie dans git status sur quelle branche tu es.

Étape suivante

Désormais, tu mènes chaque fonctionnalité avec la boucle de la leçon 0_6, avec deux ajouts : la revue des changements et de la description avant le commit, et l'envoi sur GitHub après une étape terminée. Avant de fermer ce lieu, tu enverras à ton mentor le lien du dépôt. Dans l'éditeur ci-dessous t'attend un aide-mémoire à accrocher au-dessus de ta couchette : la boucle des commits avec les commandes que Claude lance, et un extrait du .gitignore du projet.

Retiens : le journal de bord est tenu par l'équipage, mais c'est le capitaine qui le signe.

Code de cette leçon : journal-git.md
# Journal de bord de Kraken's Call

## La boucle d'un changement

1. Liste vide dans Source Control : le dernier bon état est enregistré.
2. Demande pour Claude Code : objectif, endroit, contraintes, contrôle.
3. Revue : le diff dans Source Control, npm run build, la page dans le navigateur.
4. "Montre les changements et propose une description de commit. Ne fais pas le commit sans mon accord."
5. Commit : le titre dit quoi (50 caractères au maximum), la deuxième ligne dit pourquoi.
6. Étape terminée ? git push, quand la branche et la cible concordent.

## Les commandes que Claude lance

- git status : ce qui a changé (lit seulement)
- git diff : quelles lignes ont changé (lit seulement)
- git log --oneline : la liste des commits (lit seulement)
- git add app/crew/page.tsx : ajoute à l'enregistrement un seul fichier désigné
- git commit -m "quoi" -m "pourquoi" : enregistre un point de contrôle avec une description
- git switch -c feature/how-to-play : nouvelle branche et passage dessus
- git push -u origin main : premier envoi de la branche main sur GitHub

## Je réponds No quand je vois

- git add . ou git add -A avec des fichiers que je n'ai pas demandés
- git push --force ou git push -f
- git reset --hard
- .env, *.pem, node_modules ou .next dans la liste des changements

Tu as repéré une erreur dans cette leçon ?

Teste tes connaissances

Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.

  1. 1. Que fait la commande 'git commit -m "..."' ?

  2. 2. Quelle est la différence entre Git et GitHub ?

Tâches pratiques dans le jeu

  • Tri vertical

    Ordonne les étapes, de la revue des changements à l'envoi sur GitHub :

  • Tri horizontal

    Ordonne la commande qui sauvegarde les changements avec un message :

  1. QuestionQuiz : la commande git commit
  2. Remets dans l'ordreOrdre : de la revue des changements à GitHub
  3. QuestionQuiz : Git vs GitHub
  4. Remets dans l'ordreOrdre : la commande commit avec un message

Articles utiles