Comprendre le vibe coding

Les 12 erreurs qui font échouer un projet en vibe coding

Publié le Mis à jour le 8 min de lecture

Lire en : English

Sommaire
  1. Pourquoi les projets vibe codés échouent
  2. Les erreurs de méthode (1 à 3)
  3. 1. Démarrer sans savoir ce que tu construis
  4. 2. Demander tout d'un coup
  5. 3. Ne rien sauvegarder
  6. Les erreurs qui détruisent des données (4 à 6)
  7. 4. Laisser l'agent travailler sur la production
  8. 5. Laisser la base de données ouverte
  9. 6. Mettre des clés secrètes dans le code
  10. Les erreurs de vérification (7 à 9)
  11. 7. Croire l'IA sur parole
  12. 8. Tester seulement le cas où tout va bien
  13. 9. Laisser l'IA tourner en rond
  14. Les erreurs de pilotage (10 à 12)
  15. 10. Ne pas surveiller les coûts
  16. 11. Ne pas donner de mémoire au projet
  17. 12. Publier parce que « ça marche à l'écran »
  18. La checklist anti-échec à coller dans ton projet
  19. Questions fréquentes
  20. Questions fréquentes
  21. Sources

Les erreurs en vibe coding qui coûtent cher ne sont presque jamais techniques. Ce sont des erreurs de méthode : démarrer sans savoir ce qu'on veut, laisser l'IA tout modifier d'un coup, ne rien sauvegarder, croire l'agent sur parole. Voici les 12 plus fréquentes, avec des cas réels documentés et le correctif de chacune.

Pourquoi les projets vibe codés échouent

Un projet en vibe coding échoue rarement le premier jour. Il échoue la troisième semaine, quand l'app a grossi, que l'IA ne se souvient plus des décisions prises et que chaque correction casse autre chose. Le guide complet du vibe coding explique le principe ; cet article recense ce qui le fait dérailler.

Le tableau résume les douze erreurs. Le détail suit.

#ErreurSymptômeCorrectif
1Pas de cahier des chargesL'app change de direction à chaque promptÉcrire 1 page avant de commencer
2Des prompts trop largesDes changements sur 15 fichiersUne fonctionnalité par prompt
3Aucune sauvegardeImpossible de revenir en arrièreGit, un commit par étape qui marche
4L'agent touche la productionDonnées réelles effacéesSéparer développement et production
5Base de données ouverteDonnées lisibles par tousActiver le RLS, tester avec 2 comptes
6Clés dans le codeFacture d'API imprévueSecrets côté serveur uniquement
7Croire l'IA sur parole« Tout est corrigé », mais nonVérifier soi-même
8Tester seulement le cas idéalBug au premier vrai utilisateurListe de tests écrite
9Laisser l'IA tourner en rond10 tentatives pour le même bugRevenir en arrière, reformuler
10Ne pas surveiller les coûtsCrédits épuisés en quelques joursPlafonds et suivi hebdomadaire
11Pas de mémoire du projetL'IA réinvente les règlesFichier de contexte
12Publier sans checklistFaille découverte par un tiersChecklist sécurité avant lancement

Les erreurs de méthode (1 à 3)

1. Démarrer sans savoir ce que tu construis

Sans cahier des charges, chaque prompt redéfinit le projet. L'IA comble les trous avec des choix par défaut, et tu découvres au dixième prompt que la « réservation » n'a pas de notion de créneau. Le correctif tient en une page : qui utilise l'app, pour faire quoi, avec quelles règles et ce qui est hors périmètre. La méthode est dans rédiger un PRD que l'IA comprend.

2. Demander tout d'un coup

« Crée-moi un SaaS de facturation avec comptes, paiements et tableau de bord » produit beaucoup de code et peu de contrôle. Plus le changement est gros, moins tu peux le vérifier. Une fonctionnalité par prompt, avec un critère de réussite clair : c'est le cœur de la méthode de prompt en 5 étapes.

3. Ne rien sauvegarder

L'IA cassera une version qui marchait. Sans historique, tu n'as que deux options : demander à l'IA de « remettre comme avant » (elle ne sait pas) ou tout recommencer. Avec Git, un retour en arrière prend une commande. Le minimum vital est dans Git pour vibe coders.

Les erreurs qui détruisent des données (4 à 6)

4. Laisser l'agent travailler sur la production

C'est l'incident le plus cité de 2025. En juillet, Jason Lemkin, fondateur de SaaStr, a rapporté que l'agent de Replit avait supprimé sa base de données de production pendant un gel du code, alors qu'il lui avait demandé de ne rien modifier sans permission. Selon The Register, l'agent a ensuite affirmé que la restauration était impossible, avant que Lemkin ne découvre que le retour en arrière fonctionnait. Lemkin écrivait aussi : « Il n'y a aucun moyen d'imposer un gel du code dans les apps de vibe coding comme Replit. »

Replit a réagi en annonçant une séparation entre base de développement et base de production. La leçon vaut pour tous les outils : l'agent ne doit jamais avoir les clés de la base réelle pendant que tu expérimentes.

5. Laisser la base de données ouverte

Avec Supabase, une table exposée sans RLS (Row Level Security) est lisible et modifiable par quiconque a les droits sur elle, selon la documentation officielle. En 2025, le chercheur Matt Palmer a scanné 1 645 sites créés avec Lovable : 170 laissaient lire ou écrire des données sans authentification (CVE-2025-48757). Le test qui détecte le problème est simple : crée deux comptes, et vérifie que l'un ne voit jamais les données de l'autre. Le pas-à-pas complet est dans Supabase et RLS.

6. Mettre des clés secrètes dans le code

Le rapport 2026 de GitGuardian a compté environ 28,65 millions de nouveaux secrets (clés, mots de passe, jetons) exposés dans des commits publics sur GitHub en 2025, soit 34 % de plus qu'en 2024. Le même rapport relève que les commits co-écrits avec Claude Code fuitaient des secrets à un taux de 3,2 %, contre 1,5 % pour l'ensemble de GitHub public. GitGuardian précise que l'écart reflète surtout des décisions humaines prises dans l'urgence, pas un défaut d'un outil en particulier. La règle : aucune clé secrète dans le code envoyé au navigateur ni dans un dépôt. Explications dans pourquoi les clés API ne doivent jamais être dans le front.

Les erreurs de vérification (7 à 9)

7. Croire l'IA sur parole

« J'ai corrigé le bug et tous les tests passent. » Peut-être. Dans le cas Replit, Lemkin a rapporté que l'agent avait masqué des bugs en générant de fausses données et de faux rapports, et présenté de façon trompeuse les résultats des tests. Sans aller jusque-là, une IA affirme souvent avoir fait ce qu'elle n'a fait qu'à moitié. Vérifie toi-même, dans l'app, à chaque fois.

8. Tester seulement le cas où tout va bien

Tu testes avec ton compte, des données propres et une connexion rapide. Ton premier utilisateur arrive avec un nom accentué, un champ vide et un double-clic sur « payer ». Écris une liste de tests qui inclut les cas qui trichent ou qui échouent. La méthode : tester le code généré par l'IA sans être développeur.

9. Laisser l'IA tourner en rond

Au troisième « ça ne marche toujours pas », chaque nouvelle tentative empire souvent le code. Le correctif : revenir au dernier commit qui marchait, donner le message d'erreur complet, décrire ce que tu attendais, et demander une explication avant toute modification. La méthode détaillée est dans quand l'IA tourne en rond.

Les erreurs de pilotage (10 à 12)

10. Ne pas surveiller les coûts

Dans le même incident, Lemkin a rapporté 607,70 dollars de frais au-delà de son abonnement à 25 dollars par mois, en environ trois jours et demi. Les crédits de l'outil, les appels d'API d'IA et l'hébergement sont trois compteurs distincts. Regarde-les chaque semaine et fixe des plafonds quand le service le permet. Le détail est dans combien coûte vraiment une app vibe codée.

11. Ne pas donner de mémoire au projet

Chaque session repart presque de zéro. Si les règles (« les prix sont en centimes », « on n'utilise pas telle bibliothèque ») ne sont écrites nulle part, l'IA les réinvente. Un fichier de contexte à la racine du projet, relu à chaque session, règle le problème : voir CLAUDE.md, AGENTS.md et les fichiers de règles. Pour les gros projets, la méthode spec-driven development va plus loin.

12. Publier parce que « ça marche à l'écran »

Le rapport 2025 de Veracode a testé plus de 100 modèles sur 80 tâches de code : le code généré introduisait une faille de sécurité dans 45 % des cas. Ces failles ne se voient pas à l'écran. Avant d'ouvrir l'app au public, passe la checklist de sécurité avant la mise en ligne.

La checklist anti-échec à coller dans ton projet

Copie cette liste dans un fichier du projet et relis-la chaque semaine.

Avant de commencer
[ ] J'ai une page de cahier des charges (utilisateurs, règles, hors périmètre)
[ ] Le projet est dans Git

À chaque fonctionnalité
[ ] Un prompt = une fonctionnalité, avec un critère de réussite
[ ] J'ai vérifié moi-même dans l'app, pas seulement lu la réponse de l'IA
[ ] Commit dès que ça marche

Chaque semaine
[ ] Coûts relevés : crédits, API, hébergement
[ ] Fichier de contexte mis à jour avec les nouvelles décisions

Avant la mise en ligne
[ ] L'agent n'a pas accès à la base de production
[ ] RLS activé, testé avec 2 comptes
[ ] Aucune clé secrète dans le front ni dans le dépôt
[ ] Liste de tests passée, y compris les cas d'erreur

Commence par les deux premières cases aujourd'hui : un cahier des charges et un dépôt Git évitent à eux seuls la moitié des erreurs de cette liste.

Questions fréquentes

Questions fréquentes

Quelle est l'erreur la plus grave en vibe coding ?

Laisser l'agent accéder à la base de production. C'est la seule erreur qui peut détruire en quelques secondes des données impossibles à recréer, comme l'a montré l'incident Replit de juillet 2025. Les autres erreurs coûtent du temps ou de l'argent ; celle-ci peut coûter tes clients. Sépare toujours l'environnement de test des vraies données.

Pourquoi l'IA casse-t-elle ce qui marchait ?

Parce qu'elle ne garde pas en mémoire l'ensemble du projet et des décisions prises, et qu'un prompt trop large l'autorise à modifier beaucoup de fichiers. Elle « améliore » alors du code qui fonctionnait. Les correctifs : des prompts limités à une fonctionnalité, un fichier de contexte avec les règles du projet, et un commit Git à chaque étape qui marche.

Comment savoir si mon app vibe codée est sécurisée ?

Fais trois vérifications de base : crée deux comptes et vérifie que l'un ne voit pas les données de l'autre, cherche les clés secrètes dans le code envoyé au navigateur, et vérifie que les règles d'accès à la base (le RLS sur Supabase) sont activées sur chaque table. Pour une app avec paiements ou données sensibles, fais en plus relire le code par un développeur.

Faut-il abandonner un projet vibe codé qui devient ingérable ?

Pas forcément. Commence par figer une version qui marche dans Git, écris un fichier de contexte qui décrit l'app et ses règles, puis demande à l'IA un état des lieux avant toute nouvelle fonctionnalité. Si chaque correction en casse deux autres malgré cela, une reprise par un développeur ou une réécriture ciblée devient plus économique.

Combien de prompts avant de considérer que l'IA tourne en rond ?

Il n'y a pas de chiffre officiel, mais un repère pratique : si deux ou trois tentatives sur le même bug n'ont rien donné, arrête. Reviens au dernier état qui marchait, fournis le message d'erreur complet et demande une explication du problème sans modification. Continuer à demander « corrige » empire généralement le code.

Sources