← Tous les articlesSites et performance

Du prototype vibe-codé à la production : ce qu'il manque

L'IA écrit vite l'écran qui marche. Ce qui manque, c'est tout ce qui sert le jour où quelque chose casse.

Julien Mauclair · ~10 min · intermédiaire
StackNext.jsSupabasePostgreSQLGitHub ActionsVercel

Pour passer un prototype vibe-codé en production, il lui manque presque toujours six briques : une authentification éprouvée, une restauration de base testée, des logs exploitables, des migrations versionnées, une CI qui exécute l'app et un retour arrière déjà répété. Chacune se vérifie par un test qui passe ou échoue.

Le piège le plus courant : croire que revenir à la version précédente du code remet aussi la base dans son état d'avant. Vercel le rappelle dans sa documentation du retour arrière : les bases de données et les API externes ne suivent pas.

01Ce que montre un prototype, et ce qu'il ne montre pas

Un prototype répond à une question : est-ce que quelqu'un veut ça ? La production en pose d'autres : que se passe-t-il quand un utilisateur supprime ses données par erreur, quand une migration casse une colonne, quand le déploiement de vendredi soir renvoie des erreurs ? L'IA est très bonne pour la première question, parce qu'un écran qui marche demande peu de contexte. Les autres demandent de savoir ce qui existe déjà, ce qui ne doit pas casser et comment revenir en arrière.

Un fil très suivi de r/ClaudeAI résume bien ce désaccord. D'un côté, des développeurs expérimentés expliquent que l'interface est la partie facile et que le coût réel est dans la maintenance, la sécurité et les cas limites. De l'autre, des participants rappellent que la plupart des apps n'ont jamais besoin de tenir une charge énorme, et qu'un outil interne ou une première version n'a pas à être construit comme un géant du web. Les deux ont raison : la question n'est pas l'échelle, c'est la capacité à réparer.

C'est pour cela que cet article ne parle pas de performance ni de montée en charge. Il liste ce qui sépare une démo d'un service sur lequel des clients comptent, et il renvoie vers les guides détaillés pour chaque brique. La sécurité a déjà sa propre liste dans la checklist sécurité d'une app vibe-codée : passe-la avant celle-ci, elle bloque la mise en ligne.

02Les six briques et leur test

Chaque brique se juge à un test concret, pas à l'impression que le code donne. Si tu ne peux pas lancer le test, considère que la brique manque.

BriqueTest qui prouve qu'elle existe
1. Authentification éprouvéeMot de passe oublié, déconnexion et suppression de compte marchent de bout en bout.
2. Restauration testéeTu as restauré une sauvegarde dans une base vide et relu des données.
3. Logs et alertesUne erreur provoquée en préproduction apparaît dans tes logs et déclenche une alerte.
4. Migrations versionnéesLe schéma de prod se reconstruit depuis le dépôt, sans retouche à la main.
5. CI qui exécute l'appUne pull request qui casse le build ou un test ne peut pas être fusionnée.
6. Retour arrière répétéTu as déjà remis la version précédente en ligne, et tu sais combien de temps ça prend.

1. Une authentification que tu n'as pas écrite toi-même

Un prototype a souvent une connexion qui marche, et rien autour : pas de mot de passe oublié, pas de vérification d'e-mail, pas de suppression de compte, des sessions qui n'expirent jamais. La recommandation est simple : utilise une solution d'authentification maintenue plutôt qu'un code généré, et teste les parcours que personne ne regarde en démo. Le choix entre les options et les pièges propres à Next.js sont détaillés dans l'authentification dans une app Next.js.

2. Une sauvegarde que tu as déjà restaurée

Une sauvegarde qu'on n'a jamais restaurée n'est qu'une supposition. Vérifie d'abord ce que ton hébergeur fait vraiment. Chez Supabase, par exemple, les sauvegardes quotidiennes automatiques concernent les plans Pro, Team et Enterprise, avec 7 jours d'historique en Pro, et la documentation conseille aux projets gratuits d'exporter eux-mêmes leurs données et de les garder ailleurs. La même page précise que la restauration rend le projet inaccessible pendant l'opération : mieux vaut le découvrir en préproduction.

Le test qui compte est une restauration complète dans une base vide. Avec PostgreSQL, pg_dump au format custom produit une archive que pg_restore relit, et l'option --no-owner évite les erreurs de rôles quand la base cible n'a pas les mêmes utilisateurs.

test-restauration.shBASHCopier
# 1. Sauvegarde au format custom
pg_dump "$DATABASE_URL" -Fc -f sauvegarde.dump
# 2. Restauration dans une base locale vide
createdb test_restauration
pg_restore --no-owner -d test_restauration sauvegarde.dump
# 3. Relecture : compare avec la prod
psql test_restauration -c "select count(*) from users;"
psql "$DATABASE_URL" -c "select count(*) from users;"

Remplace users par une table qui compte pour toi. Note le temps que prend l'opération : c'est ton délai de reprise réel, pas celui que tu imagines. La stratégie complète, avec la rotation et le stockage hors site, est dans des backups qui marchent vraiment.

3. Des logs que quelqu'un lit

Sans logs, le premier signe d'une panne est un message d'utilisateur. Le principe des Twelve-Factor Apps reste le bon point de départ : l'app écrit ses événements sur la sortie standard, et l'environnement d'exécution les collecte et les envoie vers un outil où on peut chercher et créer des alertes. Ajoute deux choses que le code généré oublie souvent : un identifiant de requête dans chaque ligne, et aucune donnée personnelle ni secret dans les messages.

Le test : provoque une erreur en préproduction, retrouve-la dans les logs en moins d'une minute, et vérifie qu'une alerte part. Les outils et les seuils sont détaillés dans monitoring : logs, alertes, uptime.

4. Des migrations dans le dépôt, jamais à la main

Le symptôme classique d'un prototype : le schéma de la base a été modifié dans l'interface de l'hébergeur, ou par l'agent directement sur la prod. Personne ne peut alors reconstruire la base, ni savoir ce qui a changé. Chaque modification de schéma doit être un fichier de migration versionné, relu, appliqué par la CI et jamais retouché après coup.

Relis surtout les migrations destructrices. La documentation de Prisma le dit sans détour : sa commande d'application exécute les opérations destructrices sans demander de confirmation, le bon moment pour les repérer est donc la revue. Pour renommer ou supprimer une colonne sans casser la version en ligne, découpe le changement en trois temps, ce que Martin Fowler appelle expand and contract : ajouter le nouveau, faire migrer le code et les données, puis retirer l'ancien.

migration-en-trois-temps.sqlSQLCopier
-- Déploiement 1 : on ajoute, rien ne casse
alter table users add column display_name text;
update users set display_name = full_name where display_name is null;
-- Déploiement 2 : le code lit et écrit display_name
-- Déploiement 3, une fois le retour arrière devenu inutile :
alter table users drop column full_name;

Cette découpe est ce qui rend le retour arrière du code possible : tant que l'ancienne colonne existe, l'ancienne version de l'app fonctionne encore.

5. Une CI qui exécute l'app avant qu'un humain valide

Relire un diff généré ne suffit pas. Dans un fil de r/devops sur la dette opérationnelle du code IA, plusieurs participants défendent une règle simple : rien ne passe dans un environnement supérieur sans avoir été testé, et la chaîne doit lancer l'artefact construit plutôt que de lire du texte. L'auteur du fil ajoute qu'il n'a pas d'équipe d'infra dédiée, ce qui est le cas de la plupart des petites équipes : c'est la CI qui doit jouer ce rôle. Ce sont des témoignages, mais la logique tient.

Le minimum : à chaque pull request, installer les dépendances depuis le fichier de verrouillage, construire, lancer les tests. La documentation de GitHub Actions recommande npm ci plutôt que npm install, car il installe exactement les versions du fichier de verrouillage.

.github/workflows/ci.ymlYAMLCopier
name: ci
on: [pull_request]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6
- uses: actions/setup-node@v7
with:
node-version: '24.x'
- run: npm ci
- run: npm run lint
- run: npm test
- run: npm run build

Rends ce contrôle obligatoire avant la fusion dans les réglages du dépôt, sinon il reste décoratif. Ajoute ensuite un test qui appelle l'app déployée en préproduction, par exemple une route de santé qui interroge la base. Si tu es sur GitLab, la même logique est dans bien utiliser GitLab CI/CD.

6. Un retour arrière que tu as déjà fait

Le retour arrière se répète avant d'en avoir besoin. Sur Vercel, l'Instant Rollback remet un déploiement précédent en ligne, mais la même page liste trois limites à connaître : les variables d'environnement ne sont pas mises à jour, les bases et API externes ne reviennent pas en arrière, et l'affectation automatique du domaine de production est désactivée après le retour arrière, ce qui empêche les pushs suivants d'être mis en ligne tant que tu ne l'as pas réactivée. Elle précise aussi qu'en plan Hobby, seul le déploiement immédiatement précédent est disponible.

D'où la règle : un retour arrière de code n'est sûr que si la migration du déploiement était additive, comme dans la brique 4. Fais l'exercice une fois en préproduction, chronomètre-le, et écris la procédure en cinq lignes dans le README. La façon de rendre chaque mise en ligne prévisible est détaillée dans rendre un déploiement ennuyeux.

03Dans quel ordre s'y mettre

Toutes les briques ne pèsent pas pareil selon ce que ton app stocke. Cet arbre de décision donne l'ordre, du plus urgent au moins urgent.

Ta situationCommence par
L'app stocke des données que tu ne peux pas recréerRestauration testée, puis migrations versionnées.
Des clients paient ou en dépendent au quotidienRetour arrière répété, puis logs et alertes.
Plusieurs personnes ou agents poussent du codeCI obligatoire avant fusion, puis migrations versionnées.
Comptes utilisateurs ouverts au publicChecklist sécurité, puis authentification éprouvée.
Outil interne, données recréablesCI minimale et retour arrière : le reste peut attendre.

04Les règles qui valent dans tous les cas

Les secrets ne vivent ni dans le code ni dans l'historique git : la marche à suivre est dans gérer ses secrets proprement. Et la préproduction doit ressembler à la production : les Twelve-Factor Apps recommandent de garder les mêmes services de base de données, de file et de cache dans tous les environnements, plutôt qu'une base légère en local et une autre en prod.

Enfin, garde l'agent dans son couloir. Il peut écrire les tests, les migrations et la CI, mais il ne doit pas avoir d'accès en écriture à la base de production. Les erreurs de méthode les plus fréquentes avec un agent de code sont décrites dans les erreurs courantes avec Claude Code.

À retenir

Ces six briques ne disent rien de la tenue en charge ni de la conformité à une réglementation. Elles servent à pouvoir voir un problème, revenir en arrière et récupérer tes données. C'est le minimum avant que des clients en dépendent.

05Questions fréquentes

Faut-il réécrire le prototype avant la production ?

Rarement. Les six briques s'ajoutent autour du code existant : la plupart sont de la configuration, des tests et des procédures, pas de la réécriture. La question de la réécriture se pose quand personne ne comprend plus le code ou que chaque changement casse autre chose ; le raisonnement est dans réécrire ou reprendre une application.

Les sauvegardes de mon hébergeur ne suffisent-elles pas ?

Elles sont un bon début, à condition de savoir ce qu'elles couvrent. Chez Supabase, les sauvegardes quotidiennes ne concernent pas le plan gratuit et une sauvegarde quotidienne peut faire perdre jusqu'à une journée de données, d'où l'option de restauration à un instant précis, payante. Dans tous les cas, garde une copie hors de l'hébergeur et teste la restauration.

Puis-je demander à l'IA de mettre tout ça en place ?

Oui pour écrire la CI, les migrations, les scripts de sauvegarde et la procédure de retour arrière. Non pour valider : c'est toi qui lances la restauration, qui provoques l'erreur et qui fais le retour arrière, et qui regardes le résultat réel. Un fichier généré qui décrit une procédure ne prouve pas que la procédure marche.

Combien de temps prévoir ?

Ça dépend surtout de l'état du prototype et de l'hébergement. Une façon honnête de l'estimer : passe les six tests du tableau, compte ceux qui échouent, et traite-les dans l'ordre de l'arbre de décision. Si tu veux un regard extérieur sur ce qui manque, c'est le point de départ d'un audit technique.

06Sources

Sources & ressources
01Vercel, Instant Rollbackfonctionnement et limites du retour arrière.↗02Supabase, sauvegardes de baseplans couverts, durée de rétention, restauration, PITR.↗03PostgreSQL, pg_dumpformat custom.↗04PostgreSQL, pg_restorerestauration et option --no-owner.↗05The Twelve-Factor App, logslogs comme flux d'événements.↗06The Twelve-Factor App, parité des environnementsmêmes services en préproduction et en prod.↗07Prisma, appliquer une migrationopérations destructrices et revue.↗08Martin Fowler, Parallel Changele schéma expand and contract.↗09GitHub Actions, Node.jsworkflow de base et npm ci.↗10Fil r/ClaudeAI sur l'échec des projets vibe-codéstémoignages, pas des faits établis.↗11Fil r/devops sur la dette opérationnelle du code IAtémoignages, pas des faits établis.↗
En résumé

Commence par la restauration testée et le retour arrière répété : ce sont les deux briques qui transforment un incident en mauvaise heure plutôt qu'en mauvaise semaine. Le reste s'ajoute brique par brique, chacune avec son test.

Parlons de ton projet ↗
Julien MauclairJulien Mauclair est cofondateur et CTO de Klickbee : il construit les sites, le tracking et les automatisations IA de l’agence, et développe Klickbee Tracking. Il dirige aussi Stralya, qui conçoit et tient l’infrastructure AWS de scale-ups. Avant, il a construit toute l’infrastructure AWS d’un e-commerce, revendu depuis.

À lire ensuite