---
title: "Git pour vibe coders : ne plus jamais perdre une version qui marchait"
description: "Commits, GitHub, retour en arrière, branches, .gitignore : le minimum de Git pour vibe coder sans peur de casser ton app, prompts inclus."
url: "https://vibe-code.blog/blog/git-vibe-coding"
lang: "fr"
author: "Thierry Gustin"
published: "2026-11-20"
updated: "2026-11-21"
---

# Git pour vibe coders : ne plus jamais perdre une version qui marchait

> **L’essentiel** — Git enregistre une photo de ton projet à chaque commit, et te permet de revenir à n'importe laquelle en une commande. Pour un vibe coder, la règle tient en une phrase : un commit à chaque version qui marche, avant de demander quoi que ce soit de risqué à l'IA. Les checkpoints de Cursor ou de Claude Code dépannent pendant une session, mais leurs propres documentations recommandent Git pour l'historique durable.

Git pour vibe coders, c'est une assurance : chaque fois que ton app marche, tu enregistres une version, et quand l'IA casse tout trois prompts plus tard, tu y reviens en une commande. Tu n'as pas besoin de maîtriser Git. Six mots, cinq commandes et une routine suffisent. Voici lesquels, et comment les faire exécuter par ton agent si tu préfères ne pas toucher au terminal.

## Pourquoi Git plutôt que l'historique de ton outil ?

Parce que l'historique des outils de vibe coding est pensé pour annuler la dernière action, pas pour garder ton projet en sécurité dans la durée. Les éditeurs le disent eux-mêmes.

| Outil | Ce qu'il garde | Ce qu'il ne garde pas | Ce que dit la doc |
| --- | --- | --- | --- |
| Checkpoints de [Cursor](https://cursor.com/) | Les fichiers modifiés par l'agent pendant une session | L'historique durable, séparé de Git | « use Git for permanent version control » |
| Checkpoints de [Claude Code](https://www.anthropic.com/claude-code) | Les modifications faites par les outils d'édition de Claude, 100 derniers checkpoints | Les fichiers modifiés uniquement par des commandes Bash, la plupart des modifications des sous-agents, tes modifications manuelles hors session | « Not a replacement for version control » |
| Git + GitHub | Toutes les versions que tu enregistres, sans limite de durée | Ce que tu n'as pas commité | — |

Dans Claude Code, `/rewind` (ou deux fois Échap) ouvre le menu de retour en arrière, et les instantanés sont supprimés par défaut environ 30 jours après la dernière sauvegarde de la session. Pratique pour annuler une bêtise de l'après-midi. Pas pour retrouver la version de la démo client d'il y a deux mois.

Si tu te demandes pourquoi ça compte autant, relis [les 12 erreurs qui font échouer un projet en vibe coding](https://vibe-code.blog/blog/erreurs-vibe-coding) : plusieurs reviennent à « on avait une version qui marchait et on l'a perdue ».

## Les six mots de Git à connaître

Tu n'as besoin que de ces six notions pour vibe coder sereinement.

| Mot | Ce que c'est | Analogie |
| --- | --- | --- |
| Dépôt (repository) | Le dossier de ton projet, suivi par Git | Le classeur |
| Commit | Une photo de tous tes fichiers à un instant, avec un message | Une page datée et signée |
| Push | L'envoi de tes commits vers GitHub | La photocopie mise au coffre |
| Branche | Une ligne de travail parallèle | Un brouillon à côté de la copie propre |
| Revert | Un nouveau commit qui annule un commit précédent | Une page « j'annule la page 12 » |
| .gitignore | La liste des fichiers que Git ne doit jamais enregistrer | Le tiroir qui ne va pas au coffre |

[GitHub](https://github.com/) héberge tes dépôts en ligne. L'offre gratuite inclut des dépôts publics et privés illimités : mets ton projet en privé.

## Brancher Lovable sur GitHub

Si tu travailles sur Lovable, la synchronisation GitHub te donne Git sans taper une commande. Elle fonctionne dans les deux sens : ce que tu fais dans Lovable part sur GitHub, et ce qui est poussé sur GitHub revient dans Lovable.

Trois points de la documentation à connaître avant de l'activer :

- Lovable ne synchronise qu'**une branche à la fois**, par défaut la branche principale du dépôt (en général `main`). Un commit poussé sur une autre branche n'apparaît pas dans Lovable tant qu'il n'est pas fusionné ou que tu ne changes pas de branche dans le sélecteur.
- La synchronisation **crée toujours un nouveau dépôt** : tu ne peux pas brancher un dépôt existant. Une reconnexion après déconnexion crée aussi un nouveau dépôt.
- Si tu supprimes le dépôt sur GitHub, la synchronisation s'arrête.

L'avantage dépasse la sauvegarde : ton code existe hors de [Lovable](https://lovable.dev/). Le jour où tu veux le reprendre dans Cursor ou Claude Code, il est déjà sur GitHub.

## Démarrer Git sur un projet avec un agent de code

Avec un agent de code, tu peux soit taper ces commandes, soit demander à l'agent de le faire. Voici ce qu'il doit exécuter pour un nouveau projet :

```bash
git init
git add .
git commit -m "Version de départ : page d'accueil et inscription OK"
```

Puis, pour envoyer le projet sur GitHub après avoir créé un dépôt privé vide sur le site :

```bash
git remote add origin https://github.com/ton-compte/ton-projet.git
git push -u origin main
```

Avant le premier commit, vérifie le fichier `.gitignore` (voir plus bas). C'est l'étape que tout le monde saute et que tout le monde regrette.

## La routine : un commit à chaque version qui marche

La règle d'or du vibe coder tient en une phrase : tu commites dès que quelque chose marche, et toujours avant un prompt risqué.

1. Tu testes la fonctionnalité que l'IA vient de construire (la méthode est dans [tester le code généré sans être développeur](https://vibe-code.blog/blog/tester-code-ia)).
2. Ça marche : commit avec un message qui dit ce qui marche, par exemple `Réservation d'un créneau OK`.
3. Tu demandes la fonctionnalité suivante.
4. Ça casse et l'IA tourne en rond : tu reviens au dernier commit au lieu de lui demander une quatrième correction.

Un message de commit utile décrit l'état, pas l'effort. « Paiement Stripe en mode test OK » te servira dans trois semaines. « Corrections » ne te servira jamais.

## Revenir à une version qui marchait : les trois situations

Le bon geste dépend de ce que tu as déjà enregistré ou non.

| Situation | Commande | Ce qui se passe |
| --- | --- | --- |
| L'IA a tout cassé, rien n'est commité depuis la dernière bonne version | `git restore .` | Les fichiers suivis reviennent à leur état enregistré. Les modifications non commitées sont perdues |
| Le dernier commit est mauvais et il est déjà sur GitHub | `git revert HEAD` | Git crée un nouveau commit qui annule le précédent. L'historique est conservé |
| Tu veux juste regarder ou tester une ancienne version | `git switch -c test-ancienne <identifiant-du-commit>` | Une branche est créée à partir de cette version, sans toucher à `main` |

`git log --oneline` affiche la liste de tes commits avec leur identifiant court. La documentation de Git est claire sur un point : `git reset --hard` jette toutes les modifications non commitées et ne remplace pas `git revert` pour annuler un commit déjà partagé. Si l'agent te propose un `reset --hard`, demande-lui pourquoi avant d'accepter.

> **Ne laisse pas l'agent réécrire l'historique sans toi** — Interdis à ton agent les commandes `git reset --hard`, `git push --force` et la suppression de branches sans ta validation explicite. Ce sont les trois façons de perdre pour de bon une version qui marchait.

## Les branches : expérimenter sans risquer la version en ligne

Une branche te permet de tester une grosse modification à côté de la version qui marche. Si l'expérience échoue, tu abandonnes la branche, et `main` n'a jamais bougé.

```bash
git switch -c refonte-tableau-de-bord
# ... tu travailles avec l'IA, tu commites ...
git switch main
git merge refonte-tableau-de-bord
```

Sur [Vercel](https://vercel.com/), chaque commit poussé sur une branche autre que la branche de production crée par défaut un déploiement de prévisualisation avec sa propre adresse : tu testes la refonte à part avant de fusionner. L'article sur [le déploiement Vercel, Netlify ou mutualisé](https://vibe-code.blog/blog/deployer-app-vibe-coding) détaille ce fonctionnement.

## Le .gitignore : ce qui ne doit jamais partir sur GitHub

Le fichier `.gitignore` liste ce que Git doit ignorer. Pour une app vibe codée, il doit contenir au minimum :

```text
.env
.env.local
node_modules/
dist/
.DS_Store
```

Le plus important est `.env`, le fichier qui contient tes clés API. Une clé poussée sur GitHub, même dans un dépôt privé, doit être considérée comme compromise : c'est l'un des points de la [checklist sécurité avant la mise en ligne](https://vibe-code.blog/blog/securite-vibe-coding).

Si le fichier est déjà suivi par Git, l'ajouter au `.gitignore` ne suffit pas. La documentation de GitHub indique qu'il faut d'abord arrêter de le suivre avec `git rm --cached .env`, puis ajouter la règle. Et si la clé est déjà partie sur GitHub : révoque-la et crée-en une nouvelle. L'article sur [les clés API dans le front](https://vibe-code.blog/blog/cles-api-securite) explique pourquoi.

## Le prompt pour que ton agent gère Git à ta place

Si le terminal te fait peur, donne ces règles à ton agent une fois pour toutes. Le mieux est de les placer dans son fichier d'instructions permanent, comme l'explique le guide CLAUDE.md, AGENTS.md et rules.

```text
Règles Git pour ce projet :
- Avant chaque modification importante, vérifie que tout est commité.
  Sinon, propose-moi un commit avec un message qui décrit ce qui marche.
- Après chaque fonctionnalité que j'ai validée, propose un commit.
- Ne fais jamais git reset --hard, git push --force ni suppression
  de branche sans me demander et m'expliquer ce qui serait perdu.
- Ne commite jamais de fichier .env ni de clé API.
  Vérifie le .gitignore avant le premier commit.
- Pour annuler un commit déjà poussé, utilise git revert.
```

## Et si tu ne veux vraiment pas de terminal ?

GitHub Desktop est une application gratuite et open source, pour Windows et macOS, qui fait les commits, les push et les branches avec des boutons. Tu ouvres le dossier de ton projet, tu vois la liste des fichiers modifiés, tu écris ton message, tu cliques sur « Commit ». C'est un bon point de départ avant de laisser un agent manipuler Git.

## Questions fréquentes

## Questions fréquentes

### Faut-il apprendre Git pour faire du vibe coding ?

Il faut connaître six notions : dépôt, commit, push, branche, revert et .gitignore. Tu n'as pas besoin de retenir les commandes, ton agent peut les exécuter, ou GitHub Desktop les remplace par des boutons. Ce qui compte, c'est la routine : un commit à chaque version qui marche et avant chaque demande risquée à l'IA. C'est ce qui te permet de revenir en arrière sans rien perdre.

### Les checkpoints de Cursor ou Claude Code remplacent-ils Git ?

Non, et leurs documentations le disent. Les checkpoints de Cursor sont stockés localement, séparés de Git, et servent à annuler les changements de l'agent. Ceux de Claude Code ne suivent pas les fichiers modifiés uniquement par des commandes Bash et sont supprimés par défaut environ 30 jours après la session. Utilise-les pour annuler vite, et Git pour garder l'historique.

### Comment revenir à une version précédente avec Git ?

Si rien n'est commité depuis la dernière bonne version, `git restore .` remet les fichiers suivis dans leur dernier état enregistré. Si le mauvais commit est déjà sur GitHub, `git revert HEAD` crée un commit qui l'annule en gardant l'historique. Pour simplement explorer une ancienne version, crée une branche à partir de son identifiant avec `git switch -c`.

### Lovable sauvegarde-t-il mon code sur GitHub ?

Oui, si tu actives la synchronisation GitHub. Elle fonctionne dans les deux sens mais ne suit qu'une branche à la fois, par défaut la branche principale. Elle crée toujours un nouveau dépôt, tu ne peux pas en connecter un existant. L'intérêt : ton code existe hors de Lovable et tu peux le reprendre dans un autre outil.

### J'ai poussé ma clé API sur GitHub, que faire ?

Révoque la clé immédiatement dans le service concerné et crée-en une nouvelle : supprimer le fichier ne suffit pas, car il reste dans l'historique Git. Ensuite, arrête de suivre le fichier avec `git rm --cached .env`, ajoute `.env` au `.gitignore` et commite. Vérifie enfin ta facture et tes journaux d'utilisation pour repérer un usage anormal.

## Sources

- [Checkpoints — Cursor Docs](https://cursor.com/docs/agent/chat/checkpoints)
- [Checkpointing — Claude Code Docs](https://code.claude.com/docs/en/checkpointing)
- [GitHub integration — Lovable Documentation](https://docs.lovable.dev/integrations/github)
- [git-revert — Git Documentation](https://git-scm.com/docs/git-revert)
- [git-restore — Git Documentation](https://git-scm.com/docs/git-restore)
- [git-switch — Git Documentation](https://git-scm.com/docs/git-switch)
- [Ignoring files — GitHub Docs](https://docs.github.com/en/get-started/git-basics/ignoring-files)
- [About GitHub Desktop — GitHub Docs](https://docs.github.com/en/desktop/overview/about-github-desktop)
- [Pricing — GitHub](https://github.com/pricing)
- [Environments — Vercel Docs](https://vercel.com/docs/deployments/environments)

— Thierry Gustin, Formateur en intelligence artificielle (GustinAI) · 21 novembre 2026
