Version stable : revenir à ce qui marchait quand l’IA casse votre app
Une modification a cassé votre app vibe codée ? Notez vos versions stables, revenez à la bonne par l’historique ou Git, et testez-la avant de reprendre.
Quand une modification casse votre app vibe codée, revenez à la dernière version stable plutôt que de demander à l’outil de réparer. Une version stable est une version dont vous avez testé les parcours principaux, notée avec ce qui a été vérifié et le moyen d’y revenir : un point de l’historique de l’outil ou un commit Git.
Le scénario est presque toujours le même. Tout marchait. Vous demandez une petite chose à votre outil, une couleur, un champ de plus. Il modifie trois fichiers au lieu d’un, et le parcours d’inscription ne fonctionne plus. Vous lui demandez de corriger, il corrige autre chose, et au bout de quatre messages vous ne savez plus quelle version marchait.
Ce guide fait partie du guide pour organiser ses projets de vibe coding dans Notion. Il montre comment noter vos versions stables pour savoir, à tout moment, à quoi revenir.
Pourquoi une modification casse-t-elle ce qui marchait ?
Un outil de vibe coding répond à votre demande, pas à votre projet. Quand vous lui demandez d’ajouter un champ, il peut réécrire au passage une fonction partagée, renommer une variable, réorganiser un composant. Il ne voit pas toujours que trois autres écrans dépendent de ce qu’il touche.
Trois situations reviennent souvent :
- La demande trop large. « Améliore la page de paiement » laisse l’outil décider de ce qu’il modifie.
- Le contexte perdu. Après une longue conversation ou une nouvelle session, l’outil ne se souvient plus d’une règle que vous lui aviez donnée.
- L’absence de vérification. La modification précédente avait déjà cassé quelque chose, et personne n’a testé avant d’en demander une autre.
Le réflexe naturel est de demander une réparation. C’est souvent le mauvais : chaque correction s’ajoute sur une base déjà abîmée, et l’écart avec la version qui marchait grandit.
Qu’est-ce qu’une version stable ?
Une version stable n’est pas « la dernière version qui avait l’air de marcher ». C’est une version que vous avez vérifiée, et que vous avez notée comme telle. Trois conditions, toutes nécessaires :
- Les parcours principaux ont été testés à la main, dans le navigateur, pas seulement dans l’aperçu de l’outil.
- Ce qui a été testé est écrit, pour savoir plus tard ce que cette version garantit.
- Le moyen d’y revenir est noté : la date du point de restauration dans l’outil, ou l’identifiant du commit.
Sans le deuxième point, vous revenez à une version sans savoir ce qu’elle vaut. Sans le troisième, vous savez qu’elle existait sans pouvoir la retrouver. Quand j’ai conçu VibecodingOS, j’ai rangé ces versions dans le journal de build : chaque session dit si elle a atteint une nouvelle version stable.
Comment revenir à la version qui marchait ?

Quand tout casse, suivez ces quatre étapes dans l’ordre, sans demander de réparation à l’outil entre deux.
- Retrouvez la dernière version stable dans votre journal : sa date, ce qu’elle garantit, comment y revenir.
- Revenez-y. Selon votre façon de travailler, par l’historique de versions de votre outil ou par Git.
- Rejouez les tests notés pour cette version. Si un test échoue, la version n’était pas aussi stable que prévu : remontez à la précédente.
- Refaites la modification en plus petit, en disant précisément à l’outil ce qu’il a le droit de toucher.
Pour l’étape 2, les outils n’offrent pas tous les mêmes moyens. La plupart des outils de vibe coding gardent un historique des versions ou des points de restauration, et certains, comme Lovable, peuvent synchroniser le projet avec un dépôt GitHub. Vérifiez dans le vôtre où se trouve cet historique avant d’en avoir besoin, pas le soir où tout casse.
Si vous travaillez dans un éditeur de code avec Git, chaque version stable mérite un commit avec un message clair, par exemple « Stable : acceptation de devis testée sur ordinateur et mobile ». Ce message est votre journal côté code.
Que vérifier avant de déclarer une version stable ?

Voici la checklist que j’applique avant d’écrire « Version stable : oui » dans le journal. Elle tient en cinq minutes pour une petite app.
- Les trois parcours qui comptent : souvent l’inscription, l’action principale de l’app, et le paiement s’il existe. Faites-les en entier, comme un utilisateur.
- Un cas qui doit échouer : un mot de passe faux, un champ vide, un accès interdit. Une app stable refuse proprement ce qu’elle doit refuser.
- Un autre compte : connectez-vous avec un second utilisateur et vérifiez qu’il ne voit pas les données du premier.
- Un téléphone : ouvrez au moins une fois l’app sur mobile, pas dans l’aperçu.
- Une page rechargée : rechargez au milieu d’un parcours. Ce qui disparaît au rechargement n’était pas enregistré.
Notez chaque vérification comme un scénario de recette : ce que vous avez fait, le résultat attendu, le résultat obtenu, OK ou KO. La prochaine fois, vous rejouerez la même liste au lieu de la réinventer.
| Ce que la version garantit | Où le noter |
|---|---|
| Les parcours testés et leur résultat | Les scénarios de recette, reliés à la version |
| Le moyen d’y revenir | L’entrée du journal de build : point de restauration ou commit |
| Ce qui reste fragile | La rubrique « En cours » de la même entrée |
Comment éviter que ça recasse ?
On ne supprime pas le risque, on le rend petit et réversible. Quatre habitudes y suffisent dans la plupart des projets.
- Une modification par demande. Une demande qui contient trois changements donne trois occasions de casser, et un seul point de retour.
- Dire ce qui ne doit pas bouger. « Ajoute le champ téléphone au formulaire de contact, ne modifie aucun autre fichier » cadre l’outil bien mieux que « ajoute un téléphone ».
- Tester juste après. Le meilleur moment pour voir qu’une modification a cassé quelque chose, c’est avant la suivante.
- Marquer la stabilité souvent. Une version stable par session suffit. Plus elles sont rapprochées, moins un retour en arrière coûte de travail.
Ces habitudes vivent mieux dans un endroit qui les rappelle. Le journal de build en est le pivot : l’article sur le journal de build en vibe coding montre comment le tenir en trois minutes par session. Et si votre projet est un projet du soir, le guide du side project dans Notion aide à garder des sessions courtes, chacune avec une étape finie.
Partir d’un template
VibecodingOS est le template Notion que j’ai construit pour garder la main sur des apps vibe codées. Le journal de build y note chaque session et ses versions stables, la base Recette garde un scénario de test par critère d’acceptation, et un scénario KO devient une anomalie suivie jusqu’à sa correction. Quand une modification casse tout, vous savez à quoi revenir et ce qu’il faut retester.
Questions fréquentes
Comment revenir à une version précédente de mon app vibe codée ?
Retrouvez d’abord la dernière version que vous aviez vérifiée, puis revenez-y par l’historique de versions de votre outil ou par Git si le projet est relié à un dépôt. Rejouez ensuite les tests notés pour cette version avant de refaire la modification, en plus petit.
Faut-il demander à l’IA de réparer ce qu’elle a cassé ?
Pour une erreur évidente et isolée, oui. Quand plusieurs choses ont cassé ou que la première correction n’a pas suffi, revenez plutôt à la dernière version stable. Chaque réparation empilée sur une version abîmée éloigne un peu plus de celle qui marchait.
Qu’est-ce qu’une version stable en vibe coding ?
Une version dont vous avez testé à la main les parcours principaux, avec la liste de ce qui a été vérifié et le moyen d’y revenir : un point de restauration dans l’outil ou un commit Git. Une version qui a seulement l’air de marcher n’en est pas une.
Faut-il apprendre Git pour faire du vibe coding ?
Pas pour commencer, si votre outil garde un historique des versions. Git devient utile quand le projet grossit, quand vous changez d’outil ou quand vous travaillez à plusieurs : il garde le code hors de l’outil, et chaque version stable y reçoit un commit clairement nommé.
À quelle fréquence marquer une version stable ?
Au moins une fois par session, dès qu’une fonctionnalité est terminée et testée. Plus les versions stables sont rapprochées, moins un retour en arrière coûte de travail perdu.