Vibe coding

Audit de code : ce que nous regardons dans votre application, et ce que vous recevez

Vous avez une application qui tourne. Un collègue l'a peut-être construite en quelques semaines avec Lovable ou Cursor, ou un prestataire l'a livrée avant de ne plus répondre au téléphone. Des clients ou des collègues s'en servent tous les jours, et une décision vous attend : la garder telle quelle, la faire corriger, ou la refaire. Le problème, c'est que vous ne lisez pas le code, et que les avis que vous recevez se contredisent. Le développeur qui voudrait la reprendre trouve que tout est à refaire, l'outil qui l'a écrite assure que tout va bien. Un audit de code sert à sortir de cette impasse avec des faits : ce que nous regardons dans votre application, dans quel ordre, et le document que vous devez avoir en main à la fin pour trancher.

À quoi sert un audit de code quand vous ne lisez pas le code

Un audit de code répond à la question que vous vous posez en tant que dirigeant : que faire de cette application ? Quand l'essentiel tient, vous la gardez et vous faites corriger ce qui doit l'être, dans l'ordre des risques. Une application qui fait son travail, sans rien d'urgent, peut continuer à tourner, à condition de savoir ce qu'elle contient. Et quand chaque correction coûte plus cher que de repartir sur des bases saines, mieux vaut la reconstruire. L'audit dit lequel des trois cas est le vôtre, avec des raisons que vous pouvez vérifier.

Sans audit, cette décision se prend sur des impressions. L'application plante de temps en temps, et un ami développeur qui y jette un œil fait la grimace. Aucune de ces impressions ne dit si le problème se règle en trois jours ou en trois mois, ni s'il met en danger les données de vos clients. La grimace a peut-être ses raisons, mais elle ne vous donne ni un ordre de priorité ni un prix.

L'audit remplace ces impressions par une liste. Chaque point dit ce qui a été trouvé, à quel endroit, ce que cela risque de vous coûter si rien ne change, et ce que coûte la correction. Vous n'avez pas besoin de comprendre le code pour lire cette liste, de la même façon que vous lisez un rapport de contrôle technique sans savoir démonter un moteur. Vous décidez sur deux colonnes, le risque et le prix, et le compte rendu doit vous donner les deux.

Un audit sert aussi quand rien ne va mal, au moment où l'application change de vie : un nouveau prestataire la reprend, ou des clients commencent à y déposer des paiements et des pièces d'identité alors qu'elle ne servait qu'en interne. Un défaut qui dormait devient alors un problème avec un client au bout. Si l'application a été construite en vibe coding, en décrivant à un outil ce qu'on voulait plutôt qu'en écrivant le code, la question se pose plus tôt encore, parce que personne, en général, n'a relu ligne à ligne ce que l'outil a produit.

Revue de code et audit de code : l'une suit chaque modification, l'autre fait le point

Les deux termes se croisent dans les devis et les conversations, et ils désignent deux travaux distincts. La revue de code, que beaucoup d'équipes françaises appellent code review, suit chaque modification au fil de l'eau : un développeur propose un changement, un autre le relit avant qu'il entre dans l'application. Elle porte sur quelques dizaines de lignes à la fois, et elle revient à chaque changement, pendant toute la vie de l'application.

L'audit de code fait le point une fois, sur tout le code. Il regarde l'application comme un ensemble : comment elle est construite, où vivent les données, ce qui se répète, ce qui manque. On le commande à un moment précis, quand une décision approche, par exemple reprendre l'application, la confier à quelqu'un d'autre ou l'ouvrir à des clients. Il aboutit à un compte rendu, là où la revue laisse des commentaires sur une modification précise.

Les deux se complètent. Un audit sans revue derrière ne protège que le jour où il est fait : six mois plus tard, les modifications suivantes ont pu réintroduire ce qu'il avait signalé. Une revue sans audit examine chaque changement à la loupe sans jamais voir l'ensemble, et laisse passer un défaut de structure qui ne tient dans aucune modification isolée.

Si votre application a été construite par une personne seule, avec un outil qui écrit le code, il n'y a probablement eu ni l'un ni l'autre : personne n'a relu les modifications une à une, ni regardé l'ensemble. L'audit passe en premier, parce qu'il dit sur quoi bâtir. La revue de code se branche ensuite sur chaque modification, une fois que le code de départ a été remis d'aplomb.

Ce que nous regardons en premier : structure, secrets, dépendances et tests

Nous commençons par quatre questions, dans cet ordre, parce qu'elles disent vite si l'application est saine ou fragile. La première porte sur la structure : de quoi l'application est faite, où les données sont stockées, qui peut les lire, et par quel chemin elles passent entre l'écran de l'utilisateur et la base. Une application où l'écran décide seul qui a le droit de voir quoi, sans que le serveur vérifie derrière, se repère à ce stade, et c'est l'un des défauts qui coûtent le plus cher quand on le découvre tard.

Les secrets viennent ensuite. Une application parle à d'autres services, un outil d'envoi de courriels ou un moyen de paiement, et chacun demande une clé, l'équivalent d'un mot de passe. Quand cette clé est écrite en clair dans le code, toute personne qui voit le code peut utiliser le service à votre place, parfois jusqu'à vos données ou votre compte de paiement. Effacer la clé du fichier ne suffit pas : l'historique du code la conserve, et il faut la changer.

Troisième question, les dépendances. Aucune application ne part de zéro : elle s'appuie sur des briques extérieures, nombreuses, écrites et entretenues par d'autres. Nous regardons si elles sont encore suivies par leurs auteurs, si certaines portent des failles connues et publiées, et lesquelles ont été ajoutées puis jamais utilisées. Une brique abandonnée ne casse rien le jour même ; elle devient un problème le jour où quelqu'un y trouve une faille et que personne ne la corrige.

Reste la question des tests automatiques, ces petits programmes qui vérifient à chaque modification que l'inscription marche encore et qu'une facture donne toujours le bon montant. Une application sans tests peut très bien fonctionner aujourd'hui. Chaque modification s'y vérifie à la main, ou pas du tout, et une correction faite à un endroit peut en casser un autre sans que personne le remarque avant vos utilisateurs.

La lisibilité : un autre développeur peut-il reprendre ce code demain ?

Un code peut fonctionner sans accroc et rester illisible pour quiconque ne l'a pas écrit. Pour vous, la conséquence est concrète : tant qu'une seule personne, ou un seul outil, comprend l'application, vous dépendez d'elle. Le jour où cette personne n'est plus disponible, chaque évolution commence par des jours de lecture, facturés, avant la première ligne utile.

Nous mesurons la lisibilité avec un test que vous pouvez suivre sans lire le code : combien de temps faut-il à un développeur qui découvre le projet pour le faire tourner sur son ordinateur, puis pour y apporter une petite modification sans rien casser ? Si la réponse tient dans la journée, le code se transmet. Si personne ne sait lancer le projet ailleurs que sur la machine de celui qui l'a construit, vous avez un problème de dépendance avant même d'avoir un problème de code.

Les signes que nous relevons se comprennent sans être développeur. Un fichier qui s'appelle « nouveau_final2 » ne dit rien de ce qu'il contient, alors qu'un fichier « factures » se trouve sans chercher. Un projet sans page d'explication oblige le prochain développeur à deviner comment l'installer et le mettre en ligne. Et une règle de votre métier codée sans un mot sur sa raison d'être finit par devenir intouchable : celui qui la découvre dans deux ans n'osera pas la modifier.

La lisibilité n'a pas besoin d'être parfaite, et elle ne se répare pas en une fois. Le compte rendu dit ce qui suffit pour que le code change de mains : en général un document d'installation, quelques renommages dans les parties centrales, et des explications sur les règles métier qui ne sautent pas aux yeux. Ce travail coûte peu à côté de ce qu'il évite, à savoir payer un nouveau prestataire pour qu'il reconstitue ce que le précédent n'a jamais écrit.

Ce qui coûte cher à garder dans une application

Certains défauts ne cassent rien aujourd'hui et vous coûtent à chaque évolution. Le plus courant est le code écrit deux ou trois fois. Une règle de calcul, par exemple le prix d'un abonnement avec ses remises, existe dans l'écran de commande, dans le récapitulatif et dans la facture. Le jour où la remise change, quelqu'un la modifie à deux endroits sur trois. L'écran annonce un prix, la facture en réclame un autre, et c'est un client qui vous le signale.

Les fichiers géants forment le deuxième poste. Un seul fichier de plusieurs milliers de lignes qui gère à la fois l'inscription, le paiement et l'envoi des courriels tient debout tant que personne n'y touche. Chaque modification oblige à comprendre tout le reste, deux personnes peuvent difficilement y travailler en même temps, et une correction sur le paiement peut casser l'inscription trois cents lignes plus haut.

Le troisième est un piège fréquent des outils qui écrivent le code : la même logique recopiée d'écran en écran. Quand on construit une application en demandant un écran après l'autre, l'outil a tendance à écrire chaque écran comme s'il était seul. Le contrôle des droits, la vérification d'un formulaire ou l'affichage d'une date se retrouvent alors en dix exemplaires presque identiques, et une faille corrigée sur un écran reste ouverte sur les neuf autres.

Pour chacun de ces défauts, le compte rendu indique combien d'endroits sont touchés, ce que coûte le regroupement, et ce que vous payez à chaque évolution si rien ne bouge. Il arrive que la bonne réponse soit de ne rien faire : une duplication dans une partie de l'application que personne ne modifie jamais ne mérite pas qu'on y consacre une journée.

Un code écrit avec Lovable, Bolt, Cursor ou ChatGPT : ce qui change dans l'audit

Un code produit par un outil n'est pas mauvais par nature. Il est souvent bien présenté, avec des noms lisibles et une mise en forme propre, parfois plus soignée que celle d'un développeur pressé. La différence tient à la façon dont il a été construit : une suite de demandes, chacune traitée sans toujours tenir compte des précédentes, par quelqu'un qui n'a pas forcément relu le résultat. On y trouve les mêmes défauts que dans un code écrit à la main, répartis autrement.

L'audit insiste donc sur quelques endroits. Le premier est le contrôle des droits : nous vérifions, page par page, que le serveur refuse ce que l'écran cache, car un outil construit volontiers un bouton invisible pour les visiteurs sans interdire l'action qu'il déclenche. Les clés collées dans le code pour que ça marche tout de suite viennent juste après. Restent les versions multiples d'une même règle, puisque chaque demande a pu produire la sienne, et les traces d'une structure de données changée en cours de route.

La deuxième différence tient à l'auteur. Dans un projet classique, nous pouvons demander au développeur pourquoi il a fait tel choix. Ici, la personne qui a construit l'application sait très bien ce qu'elle voulait obtenir, et beaucoup moins comment l'outil s'y est pris. Nous commençons donc par une heure avec elle sur l'usage : à quoi sert chaque écran, qui s'en sert, ce qui ne doit jamais casser. Le code se lit après, avec cette carte en main.

L'audit ne vous demande pas d'abandonner l'outil. Vous pouvez continuer à faire évoluer l'application avec lui une fois les corrections faites, et c'est le choix le plus raisonnable quand la personne qui s'en sert connaît bien votre métier. Il faut seulement des garde-fous autour : des tests qui signalent une régression, une relecture avant chaque mise en ligne. Notre guide du vibe coding détaille ce que ces outils permettent et les endroits où ils cassent. Pour savoir ce que vous possédez du code produit, reportez-vous aux conditions de l'outil que vous utilisez.

La reprise de code quand le prestataire d'origine n'est plus là

La reprise de code commence avant la première ligne lue. Quand le prestataire qui a construit l'application est parti, injoignable ou fâché avec vous, le premier travail consiste à rassembler ce qui existe : le code lui-même, les accès à l'hébergement, au nom de domaine et à la base de données, et les comptes des services branchés dessus, comme l'envoi de courriels ou le paiement. Il manque souvent une pièce, et mieux vaut le découvrir maintenant que le soir d'une panne.

Nous faisons ensuite tourner une copie de l'application à côté de celle qui sert, sans rien toucher à la production. Cette copie permet de lire le code en le voyant fonctionner, de vérifier ce que fait réellement chaque écran, et de tester sans risquer les données de vos utilisateurs. Si elle refuse de démarrer, nous apprenons déjà quelque chose : il manque une configuration ou un secret que seul l'ancien prestataire connaissait.

Les données passent avant le code. Un code se réécrit, alors que des inscriptions, un historique client ou des documents déposés par vos utilisateurs ne se reconstituent pas. Au Groupe des Arbitres Genevois, les inscriptions passaient par un site dont plus personne n'avait documenté le fonctionnement, et les pièces d'identité des candidats étaient dispersées sans contrôle d'accès clair. Avant de reconstruire, nous avons récupéré les 557 inscrits et les 18 sessions, puis placé les 1 355 pièces d'identité derrière un accès réservé au comité.

Nous avons aussi mené une revue de sécurité des formulaires, des envois de fichiers et des accès administrateur, et diagnostiqué des courriels qui n'arrivaient pas en production. Le cas du Groupe des Arbitres Genevois raconte la reprise en entier. Si votre application a quelques années et que chaque évolution coûte plus cher que la précédente, notre chapitre sur la dette technique explique d'où vient ce surcoût et comment le résorber sans tout jeter.

Le compte rendu : ce que vous recevez à la fin d'un audit de code

Le compte rendu est ce qui reste de l'audit, et il doit pouvoir être lu par la personne qui décide. Il s'ouvre sur une page de synthèse en français courant : ce que fait l'application, ce qui tient, ce qui ne tient pas, et notre recommandation entre garder, corriger et refaire. Un dirigeant qui ne lit que cette page sait quoi décider, et pourquoi.

Viennent ensuite les points relevés, classés par risque plutôt que dans l'ordre où nous les avons trouvés. En tête, ce qui peut vous coûter cher rapidement, comme des données de clients lisibles par n'importe qui ou une application jamais sauvegardée. Puis ce qui ralentit chaque évolution, comme les doublons et les fichiers géants. Enfin, ce qui gêne sans urgence. Chaque point dit où il se trouve, ce qu'il risque, et ce qui se passe si vous ne faites rien.

Chaque correction est chiffrée séparément. Vous voyez ce que coûte la sortie des clés hors du code, et à part ce que coûtent les droits d'accès revus page par page. Vous pouvez tout faire, ne traiter que le haut de la liste, ou étaler les corrections sur plusieurs mois. Quand une reconstruction revient moins cher que la somme des corrections, le compte rendu le dit et chiffre aussi cette option.

Le document vous appartient, et il est écrit pour servir à n'importe quel prestataire. Les points citent les fichiers concernés, et les corrections sont décrites assez précisément pour qu'une autre équipe les chiffre de son côté puis les réalise. Vous pouvez le remettre à votre développeur interne, vous en servir pour mettre plusieurs prestataires en concurrence, ou nous confier les corrections : l'audit se paie à part, et la suite se décide après.

Combien de temps prend un audit de code, et ce qui fait varier ce délai

Pour une application, comptez une à deux semaines entre le moment où nous avons les accès et la remise du compte rendu. Votre temps à vous se limite à deux rendez-vous d'une heure : un au début pour nous dire à quoi sert l'application et qui s'en sert, un à la fin pour parcourir le compte rendu ensemble et répondre à vos questions. Entre les deux, nous lisons le code sans rien y modifier.

La taille du code est le premier facteur, sans surprise. Une application de prise de rendez-vous construite en un week-end se lit plus vite qu'une plateforme avec espace client, paiement et tableau de bord. Le nombre de services branchés compte aussi : chaque outil extérieur, qu'il serve à envoyer des courriels ou à stocker des fichiers, ajoute des réglages à vérifier et des clés à suivre.

Les accès pèsent souvent plus lourd sur le calendrier que le code lui-même. Si le dépôt, l'hébergement et la base de données sont à votre nom, l'audit peut démarrer dès que le prix est signé. S'il faut d'abord les récupérer auprès d'un ancien prestataire ou d'un collègue parti, le délai ne court qu'une fois tout rassemblé, et cette étape peut durer plus longtemps que la lecture.

Plusieurs applications qui se parlent, un site public et l'outil interne qui l'alimente par exemple, se relisent ensemble, parce que leurs défauts se répondent : une faille dans l'une peut ouvrir la porte de l'autre. Le délai s'allonge un peu. Le prix, lui, est fixé et signé avant de commencer, quelle que soit la durée réelle du travail.

Après l'audit : corriger, installer une revue de code, ou reconstruire

Quand l'essentiel tient, la suite commence par ce qui protège : les mots de passe et les clés sortis du code, les droits d'accès vérifiés page par page, des sauvegardes qui tournent, les formulaires et les envois de fichiers contrôlés. Les tests automatiques arrivent après, sur les parcours qui comptent (l'inscription, le paiement, ce que vos clients font tous les jours), avec l'installation sur un hébergement que vous contrôlez. Le code reste dans votre dépôt du début à la fin.

Pour que les corrections tiennent, une revue de code doit accompagner chaque modification qui suit. Chez Hairdex, une plateforme de téléconsultation capillaire, trois développeurs faisaient déjà écrire du code par des assistants sur neuf applications, chacun à sa façon, sans aucun test automatisé au départ. Nous formons l'équipe sur ses propres dépôts : les tests d'abord, sur les parcours qui touchent au patient, un fichier de contexte par dépôt tenu à jour automatiquement, et une revue de code branchée sur chaque modification proposée.

La mission est en cours, et nous ne publions aucun chiffre avant le bilan avec l'équipe ; le cas Hairdex décrit la méthode. Pour une application plus petite, sans équipe technique, la même logique tient en moins de choses : des tests sur les deux ou trois parcours qui ne doivent jamais casser, et une relecture par quelqu'un d'autre que l'auteur avant chaque mise en ligne. Le suivi mensuel sert à cela, et il s'arrête librement le mois suivant.

Quand corriger coûte plus cher que repartir, la suite est une reconstruction, et elle ne part pas de rien. L'application existante vous a appris des choses : les écrans dont vos utilisateurs se servent vraiment, et les cas particuliers de votre métier que personne n'avait écrits ailleurs. La page sur la reprise d'une application codée vite décrit comment nous enchaînons relecture, consolidation et suite, et notre guide de la refonte d'un logiciel explique comment reconstruire sans perdre ce que l'ancien savait faire.

Quand l'audit dit non, et comment nous vous le disons

Un audit peut dire non de deux façons, et la première arrive avant même qu'il commence. Une démo construite pour convaincre un client, un outil interne utilisé par trois personnes sans données sensibles : ces applications font leur travail, et un audit coûterait plus cher que ce qu'il protège. Nous vous le disons au premier appel. Notez seulement ce qu'il faudra regarder le jour où l'application sortira de ce cadre, en s'ouvrant à des clients ou en recevant des données personnelles.

La seconde arrive à la fin de l'audit : le code ne vaut pas d'être repris. Des blocs entiers écrits trois fois, une structure de données changée si souvent que chaque correction en casse deux autres. Corriger reviendrait alors plus cher que reconstruire. Nous vous le disons dans le compte rendu, avec le chiffrage d'une reconstruction et la liste de ce qu'elle garderait de l'existant, avant de facturer quoi que ce soit d'autre.

Ce non n'a rien d'agréable à recevoir, surtout quand l'application a demandé des semaines d'efforts à quelqu'un de votre équipe. Nous l'écrivons avec des faits que vous pouvez montrer à cette personne, ou à un autre prestataire si vous voulez un second avis : les fichiers en cause et le coût comparé des deux chemins. Le travail fait garde sa valeur, puisque l'application a prouvé que l'idée tenait et montré ce dont vos utilisateurs ont besoin.

Nous préférons renoncer à la suite d'une mission que vous laisser payer des corrections sur un code qui n'en vaut pas la peine. Un non argumenté vous coûte moins cher qu'une année de rustines, et il rend crédibles les fois où nous vous disons que votre application tient. Vous restez libre de confier la reconstruction à qui vous voulez, compte rendu en main.

Questions fréquentes

Combien coûte un audit de code ?

Les prix varient d'un prestataire à l'autre, selon la taille du code et ce que couvre le compte rendu. Chez nous, une relecture de code se facture comme un <a href="/offres/cadrage/">cadrage</a> : 3 900 € HT pour une application, 5 000 € HT quand plusieurs applications passent en revue. Le prix est fixé et signé avant de commencer. Les corrections se chiffrent ensuite à partir du compte rendu, poste par poste, et vous choisissez ce que vous faites faire.

Combien de temps dure un audit de code ?

Une à deux semaines pour une application, à compter du moment où les accès sont réunis. Votre présence se limite à une heure au début, pour expliquer à quoi sert l'application et qui s'en sert, et à une heure à la fin, pour parcourir le compte rendu. Si les accès doivent d'abord être récupérés auprès d'un ancien prestataire, ajoutez le temps de cette récupération.

Faut-il donner l'accès au code source pour un audit de code ?

Oui, et un accès en lecture suffit : nous lisons le code sans le modifier. Le plus pratique est de nous inviter sur le dépôt où il est rangé, puis de retirer cet accès une fois l'audit terminé. Si le code vit encore dans l'outil qui l'a écrit, il faut d'abord l'exporter dans un dépôt à votre nom, selon la méthode propre à l'outil. Pour ce qui se voit de l'extérieur, sans aucun accès, l'<a href="/techmind-tools/analyseur/">analyseur de site</a> donne une première idée en quelques minutes.

Le code écrit par une IA est-il moins bon ?

Pas par nature. Un outil comme Cursor ou ChatGPT écrit souvent un code propre en apparence, avec des noms lisibles. Ses défauts viennent de la façon dont on s'en sert : des demandes successives qui produisent chacune leur version d'une même règle, ou des contrôles d'accès posés sur l'écran sans que le serveur vérifie. Un développeur pressé commet les mêmes erreurs. L'audit applique la même grille aux deux, en insistant sur ces endroits-là.

Peut-on auditer une application sans le développeur d'origine ?

Oui, c'est la situation ordinaire d'une reprise de code. Le code, les données et la façon dont l'application est utilisée suffisent pour comprendre ce qu'elle fait. Il faut en revanche récupérer les accès : le dépôt, l'hébergement, le nom de domaine, la base de données et les comptes des services branchés dessus. Nous dressons cette liste avec vous au début, et si une pièce manque, le compte rendu dit ce qu'elle bloque et comment la remplacer.

Que contient un rapport d'audit de code ?

Une page de synthèse lisible par un dirigeant, avec une recommandation : garder, corriger ou refaire. Puis la liste des points relevés, classés par risque, chacun avec l'endroit où il se trouve, ce qu'il risque et le prix de sa correction. Ce qui tient y figure aussi, pour que vous sachiez à quoi ne pas toucher. Le document est écrit pour qu'un autre prestataire puisse s'en servir sans nous.

Quelle différence entre un audit de code et un audit de sécurité ?

L'audit de sécurité cherche ce qu'une personne mal intentionnée peut faire de votre application : lire des données qui ne la regardent pas, entrer dans un compte, détourner un formulaire. L'audit de code couvre aussi ces points, puisqu'ils se trouvent dans le code, et regarde en plus ce qui détermine le coût de la suite : la lisibilité, les doublons, les dépendances, les tests. La sécurité de votre réseau et de vos postes de travail relève d'un autre métier que le nôtre.

On continue la lecture ?

  1. Vibe coding : le guide du dirigeant qui a une application codée vite sur les bras
  2. Audit sécurité d'un site web ou d'une application : ce que nous vérifions, dans quel ordre
  3. Prototype d'application : quand et comment le mettre en production
  4. Audit de code : ce que nous regardons dans votre application, et ce que vous recevez
  5. Lovable, Bolt, Cursor : notre avis pour une entreprise qui veut un outil qui dure

Nos guides

  1. Audit informatique en PME : le guide
  2. Logiciel sur mesure : le guide
  3. Automatisation : le guide
  4. Assistant IA : le guide complet
  5. Faire analyser mon site
  6. Voir comment se passe un audit stratégique

On en parle ?

On regarde votre application ? Prendre rendez-vous