Aller au contenu
Formation gratuite et accessible à tous. Les cours évoluent grâce à tes retours.
Langue : FR

Git et versions

En testVérifiée le 24/10/2026

Cette leçon est encore en test : elle s'améliore avec les retours des apprenants. Si quelque chose n'est pas clair, c'est la leçon qu'il faut corriger, pas toi.

Suivre cette leçon avec Claude Code

Avec le compagnon de la formation installé, ouvre Claude Code dans ton dossier de travail et tape :

/formation-ia:suivre m12-l05

Il lit cette leçon à jour sur le site et t'accompagne étape par étape, sans rien modifier sans ton accord. Installer le compagnon. Claude Code n'est pas inclus dans l'offre gratuite : abonnement Claude éligible, ou compte Console facturé à l'usage pour le terminal.

À la fin de cette leçon, tu sauras

  • enregistrer une version de ton outil à chaque étape qui marche ;
  • écrire un .gitignore pour ce qui ne doit jamais être enregistré ;
  • voir ce qui a changé depuis la dernière version ;
  • revenir à la dernière version d’un fichier, en sachant ce que tu perds.

Pourquoi ça t’intéresse

Un agent modifie vite, parfois trop. Avec des versions enregistrées, aucune modification n’est grave : tu sais ce qui a changé, et tu peux revenir. Au module 5, tu as découvert Git pour ton dossier. Ici, tu en fais l’habitude du constructeur : une version après chaque étape qui marche, et un fichier qui dit ce que Git ne doit jamais garder.

Avant de commencer

Il te fautClaude Code (appli ou terminal), en mode Manuel, Git installé (module 5, leçon 6), et ton dossier de projet
CoûtGit est gratuit ; l’agent demande son abonnement (Claude Pro au minimum : 18 € par mois hors taxes en facturation mensuelle, ou 15 € par mois hors taxes avec l’abonnement annuel de 180 € payé d’avance ; prix affichés sur claude.com/pricing au 24/10/2026)
Durée60 minutes
RappelGit garde tout l’historique : un secret enregistré une fois y reste (leçon 6)

Comprendre en 3 minutes

Le rythme : essayer, vérifier, enregistrer. Une version (un commit) après chaque étape qui marche, avec un message qui dit ce qui a changé : « Ajout du bouton Exporter », pas « modifs ».

Le .gitignore liste ce que Git ne doit pas suivre : le fichier .env des secrets, les sauvegardes de données, les fichiers personnels. D’après la documentation de Git (24/10/2026), il n’agit pas sur les fichiers déjà suivis : il se met en place avant le premier enregistrement de ces fichiers.

Trois commandes à connaître (l’agent les lance pour toi ; d’après la documentation de Claude Code, les formes de git qui ne font que lire se lancent sans demande, mais celles qui modifient quelque chose, comme git restore, demandent ton accord) :

CommandeCe qu’elle fait
git statusD’après le livre de Git, c’est l’outil principal pour savoir dans quel état sont les fichiers
git diffMontre les modifications pas encore « préparées » pour la prochaine version (git diff HEAD montre tout ce qui a changé depuis la dernière version)
git restore <fichier>Remet le fichier dans l’état de la dernière version enregistrée

Attention à git restore. Le livre de Git prévient : c’est une commande dangereuse ; toute modification locale du fichier est perdue, Git le remplace par la version la plus récemment enregistrée. Ce qui n’a jamais été enregistré avec Git ne se récupère pas avec Git.

Faire ensemble

1Étape 1 : Le .gitignore, puis la première version

Avant tout : vérifie que Git est installé (git --version dans le terminal ; sinon, le module 5, leçon 6, explique comment l’installer). Puis règle le nom et l’adresse qui seront enregistrés dans chaque version : ils deviendront publics si tu publies un jour le projet (leçon 7).

D’après le livre officiel de Git, cela se fait une fois, avec git config --global user.name "Ton nom" et git config --global user.email ton.adresse@exemple.fr : choisis ce que tu acceptes de montrer.

Dans Claude Code, sur ton dossier de projet, en mode Manuel :

Mets ce dossier sous Git : crée d'abord un fichier .gitignore qui exclut le fichier .env et mes sauvegardes de données (seulement les fichiers de sauvegarde de l'outil, par exemple carnet-emprunts-*.json, pas tous les fichiers .json), puis enregistre une première version des autres fichiers, avec un message clair.
Montre-moi ensuite le résultat de git status et de git log --oneline.

Lis chaque demande d’autorisation avant d’accepter.

Lors de notre essai du 24/10/2026, avec une demande qui disait seulement « les fichiers de sauvegarde .json », l’agent a créé le .gitignore, enregistré la première version, puis prévenu que la règle *.json exclut tous les fichiers .json, pas seulement les sauvegardes : d’où la formulation ci-dessus, qui nomme les sauvegardes. Ensuite, un fichier .env et une sauvegarde .json ajoutés au dossier n’apparaissaient pas dans git status : ils étaient bien ignorés.

2Étape 2 : Voir ce qui a changé

Fais une petite modification de ton outil (leçon 2), puis :

Montre-moi ce qui a changé depuis la dernière version, en langage simple. Ne modifie rien.

Si la modification marche (refais les essais), enregistre une nouvelle version : « Enregistre une version avec le message : [ce qui a changé]. »

3Étape 3 : Revenir en arrière

Pour t’entraîner, d’abord en sécurité : demande à l’agent « Lance git status et dis-moi s’il y a des modifications non enregistrées ». S’il y en a, enregistre d’abord une version (étape 2). Mieux encore, fais l’exercice sur une copie de ton dossier. Ensuite seulement, abîme volontairement ton outil (par exemple, demande « remplace tout le contenu de [nom].html par une seule ligne : oups »). Puis :

J'ai abîmé [nom].html par erreur. Reviens à la dernière version enregistrée de ce fichier seulement, sans toucher aux autres fichiers. Dis-moi ce que tu as fait.

Lors de notre essai, l’agent a d’abord regardé git status et git diff, puis lancé git restore -- prets.html (prets.html était le fichier de notre essai : chez toi, ce sera le nom de ton fichier) : le fichier est revenu identique à la version enregistrée. Il a prévenu que la version abîmée, jamais enregistrée, ne pouvait pas être récupérée.

Un cas particulier : si l’agent avait déjà « préparé » le fichier abîmé pour la prochaine version (commande git add), un simple git restore le laisserait abîmé, car par défaut il remet le fichier tel qu’il est dans cette préparation (d’après la documentation de Git). Demande alors de le restaurer depuis la dernière version enregistrée : la forme complète est git restore --source=HEAD --staged --worktree <fichier>.

Faire toi-même

  1. Mets ton projet sous Git, avec un .gitignore posé avant le premier enregistrement.
  2. Pendant une semaine, enregistre une version après chaque étape qui marche, avec un message clair.
  3. Entraîne-toi une fois à revenir en arrière sur un fichier.
  4. Note dans ton journal les messages de tes versions : c’est l’histoire de ton outil.

Vérifier

C’est réussi si :

  • git log --oneline montre plusieurs versions, avec des messages clairs ;
  • le .gitignore existe, et .env comme les sauvegardes n’apparaissent pas dans git status ;
  • tu sais demander ce qui a changé depuis la dernière version ;
  • tu as réussi un retour en arrière, et tu sais ce qu’il fait perdre.

Erreurs fréquentes :

  • enregistrer une version qui ne marche pas ;
  • poser le .gitignore après avoir enregistré .env ;
  • des messages comme « modifs » ou « test » ;
  • lancer git restore sans savoir que les modifications non enregistrées seront perdues.

Conserver et reprendre

  • Avant chaque modification demandée à l’agent : une version. Après, si ça marche : une autre.
  • Git ne remplace pas tes copies (module 5, leçon 6) : le dossier .git est dans ton dossier, sur le même disque.

Pour aller plus loin

facultatif
  • D’après la documentation de Git, pour qu’un fichier déjà suivi cesse de l’être, il faut le retirer de l’index avec git rm --cached, puis l’ajouter au .gitignore. Pour un secret, ça ne suffit pas : il reste dans les versions précédentes (leçon 6).

Mots nouveaux

4 mots expliqués
MotCe que ça veut dire
Version (commit)Un enregistrement de l’état de tes fichiers, avec un message
.gitignoreLa liste des fichiers que Git ne doit pas suivre
HistoriqueLa suite de toutes tes versions, avec leurs messages
Revenir en arrièreRemettre un fichier dans l’état d’une version enregistrée

Vérifie ta compréhension

3 questions, sans note. Une explication s'affiche après chaque réponse.

1Quand enregistres-tu une version (un commit) ?
2Tu ajoutes .env au .gitignore, mais .env avait déjà été enregistré dans une version. Est-il protégé ?
3Ton fichier est abîmé, et tu n'avais rien enregistré depuis le matin. Que récupère git restore ?

Et ensuite ?

Leçon 6 · Secrets et données personnelles : ce qui ne doit jamais entrer dans une page, dans l’historique de Git, ni dans une conversation.

Module 12 :

✏️ Faire les exercices

Mon espace : ta progression, tes exercices et ta dernière leçon.

Sources et vérifications

5 sources

Date, version, sources Rédigée le 24/10/2026. Vérifications du 24/10/2026 :

  • git status, outil principal pour connaître l’état des fichiers : git-scm.com, livre de Git, « Enregistrer des modifications dans le dépôt » ;
  • git restore, remplacement par la dernière version enregistrée, commande dangereuse : git-scm.com, « Annuler des actions » ;
  • .gitignore sans effet sur les fichiers déjà suivis, git rm --cached : git-scm.com/docs/gitignore ;
  • Git gratuit : git-scm.com ;
  • prix de Claude Pro : claude.com/pricing.

Les étapes 1 et 3 ont été jouées réellement avec Claude Code 2.1.310, commandes git seulement, dans un dossier d’essai isolé (rapport de tests, T56). La demande de l’étape 1 a été jouée avec sa formulation d’origine (« les fichiers de sauvegarde .json ») ; la formulation actuelle, plus précise, n’a pas été rejouée. Les séances d’essai avec Claude Code ont été jouées en mode non interactif (claude -p), une seule fois chacune : ce que tu verras peut différer (demandes d’autorisation, formulation, nombre de questions).

Sources vérifiées :