La règle la plus importante du développement moderne est la suivante : ne tape jamais une commande que tu ne comprends pas.

Même si Claude Code te la propose avec insistance, tu dois toujours savoir ce qu'elle fera à ton projet. Voici l'explication simple des commandes que tu verras tous les jours.

1. Le point de départ : init et clone

Ces deux commandes servent à allumer le moteur de Git. Tu ne les utiliseras qu'une seule fois par projet.

git init

Rôle : Allume le système Git dans le dossier actuel.

Quand l'utiliser : Quand tu commences un tout nouveau projet sur ton ordinateur.

git clone

Rôle : Télécharge un projet existant depuis internet.

Quand l'utiliser : Quand tu veux travailler sur un projet qui existe déjà sur GitHub.

2. L'observation : status, log et diff

Ces commandes sont tes yeux. Elles ne modifient absolument rien à tes fichiers. Elles te donnent juste de l'information. Tu peux les taper 100 fois par jour sans aucun risque.

git status

Rôle : Te dit dans quel état est ton projet.

Quand l'utiliser : En permanence ! Pour savoir quels fichiers tu as modifiés depuis la dernière fois.

git diff

Rôle : Te montre exactement quelles lignes de texte ont été ajoutées ou effacées dans un fichier modifié.

git log

Rôle : Affiche l'historique complet (l'album photo). Tu y verras la liste de toutes les anciennes sauvegardes.

3. La sauvegarde : add et commit

C'est le cœur de Git. C'est l'action de créer une sauvegarde (prendre une photo de ton code pour la mettre dans l'album).

git add

Rôle : Indique à Git quels fichiers modifiés doivent être mis devant l'objectif de l'appareil photo.

Exemple courant : git add . (Le point veut dire "Prépare tous les fichiers modifiés d'un coup").

git commit

Rôle : Déclenche l'appareil photo et crée l'entrée dans l'historique de Git.

4. Le bouton Annuler : restore et reset

Ces commandes modifient ton code ! Elles servent à revenir en arrière en cas d'erreur. Lis toujours très attentivement quand Claude te les propose.

git restore

Rôle : Annule toutes tes modifications non sauvegardées sur un fichier spécifique. Le fichier redevient exactement tel qu'il était lors du dernier commit.

Quand l'utiliser : Tu viens de casser un fichier et tu veux tout annuler pour recommencer propre.

git reset

Rôle : C'est la commande nucléaire. Elle permet de remonter l'historique et d'effacer les commits précédents. Claude l'utilise parfois pour effacer ses traces quand il s'est trompé.

Attention

Attention à git reset --hard. Cette commande efface purement et simplement tout ce qui n'a pas été sauvegardé. Tu ne pourras jamais récupérer ce code.

5. Le Cloud : push et pull

Ces commandes servent à discuter avec ton coffre-fort sur internet (GitHub).

git push

Rôle : Envoie tes nouveaux commits (tes dernières photos) vers GitHub.

Quand l'utiliser : À la fin de ta journée de travail, pour mettre ton code à l'abri.

git pull

Rôle : Récupère les nouveautés depuis GitHub vers ton ordinateur.

Quand l'utiliser : Au début de ta journée, pour être sûr de travailler sur la dernière version (très utile si un collègue a modifié le projet pendant la nuit).

6. Checklist quotidienne du développeur

Bonnes pratiques

Voici la séquence parfaite d'un développeur qui travaille bien :

  1. Le matin : git pull (pour récupérer le travail des autres).
  2. Pendant le travail : git status (pour voir ce qu'on fait).
  3. À midi (fonctionnalité terminée) : git add . puis git commit -m "Message".
  4. Le soir : git push (pour envoyer le tout en sécurité).

7. FAQ

Non, pas du tout. Avec Claude Code, tu auras rarement besoin de les taper toi-même, car l'IA te proposera de les exécuter. Cependant, tu dois absolument comprendre ce qu'elles font avant de dire Oui.
'add' prépare la scène (tu dis à tout le monde de sourire devant l'appareil photo). 'commit' prend la photo réellement et l'enregistre dans l'album.
C'est l'abréviation de 'message'. Elle permet d'attacher un petit texte explicatif à ta photo pour t'en souvenir plus tard.

Maintenant que tu connais les mots magiques pour sauvegarder ton code, nous pouvons aborder le concept le plus puissant (et parfois le plus effrayant) de Git. Dans le chapitre suivant, nous allons découvrir les branches et comment créer des mondes parallèles.

Chapitre terminé