# Vibe coding en entreprise : les garde-fous pour développer avec l’IA sans dérive

> Ce qui dérive quand une IA écrit le code, et les garde-fous qui le tiennent : architecture, contrat d’API, dépendances, documentation, sécurité, livraison.

Source : https://www.8tech.fr/guides/developper-avec-ia-garde-fous/ — version Markdown de la page, produite à chaque publication.

Guide pratique · 31 min de lecture

Mis à jour le 18 novembre 2026 · [8TECH](https://www.8tech.fr/a-propos/) · sources datées en fin de guide

Développer avec l’IA sans dérive repose sur trois maîtrises. Ce que l’agent peut faire : une machine dédiée, des permissions minimales, et pour chaque service externe un outil qui garde le secret et n’expose que des opérations nommées. Ce qu’il produit : des contrôles automatiques qui refusent toute modification non conforme, de l’architecture à la mise en production. Ce qui est accepté : une analyse validée par un humain et un risque résiduel assumé. Le vibe coding, qui consiste à accepter le code sans le lire, convient à un prototype ; un logiciel qui porte les données d’une entreprise demande ces garde-fous.

8TECH développe et exploite ses propres logiciels : son outil de gestion interne, l’espace client de ses clients et l’[Entreprise augmentée](https://www.8tech.fr/entreprise-augmentee/). Elle développe de la même façon les [applications et les automatisations sur mesure](https://www.8tech.fr/developpement-sur-mesure/) de ses clients. Nous les développons avec des agents de programmation, Claude Code et Codex : des IA qui lisent le projet, modifient les fichiers et lancent elles-mêmes les commandes.

Ce guide liste tout ce qu’il faut mettre en place pour qu’un logiciel développé de cette façon reste maîtrisé. La méthode tient en trois maîtrises : ce que l’agent peut faire, ce qu’il produit, et ce qui est finalement accepté. C’est celle que nous appliquons à nos propres développements ; elle ne dépend pas de l’agent utilisé.

Nous développons avec l’assistance de l’IA depuis 2022, et avec des agents depuis 2024. Ce second pas change la nature de la question. Tant que l’IA suggérait du code, il suffisait de vérifier ce code. Un agent agit : il faut désormais maîtriser les actions qu’il est autorisé à entreprendre, les ressources auxquelles il accède, et les conditions dans lesquelles ses modifications peuvent être acceptées.

## Le vibe coding : de quoi parle-t-on

L’expression vient d’un message publié le 2 février 2025 par le chercheur Andrej Karpathy. Il y décrit une façon de programmer où l’on s’en remet entièrement à l’IA : on décrit ce qu’on veut, on accepte ce qu’elle produit sans le lire, on lui recolle les messages d’erreur jusqu’à ce que ça marche, et l’on oublie que le code existe. Son auteur la réservait à des projets sans enjeu, faits en un week-end.

Le mot a depuis débordé son sens d’origine et désigne souvent tout développement assisté par IA. La distinction reste pourtant utile, parce qu’elle sépare deux situations qui n’ont pas le même risque.

|                         | Vibe coding                                                   | Développement avec IA, sous garde-fous                                        |
| ----------------------- | ------------------------------------------------------------- | ----------------------------------------------------------------------------- |
| **Qui lit le code ?**   | Personne                                                      | Des contrôles automatiques à chaque modification, un humain sur les décisions |
| **Ce qui valide**       | « Ça a l’air de marcher »                                     | Une série de vérifications qui doit être entièrement verte                    |
| **Convient pour**       | Une maquette, un prototype, un outil jetable, un essai d’idée | Un logiciel qui porte des données, des factures, des accès                    |
| **Le jour où ça casse** | On recommence, ou on jette                                    | On sait quoi a changé, pourquoi, et comment revenir en arrière                |

Le vibe coding n’est pas une faute. C’est un excellent moyen de tester une idée en une après-midi. Le problème commence quand le prototype part en production tel quel, avec les données des clients dedans.

## Ce qui dérive quand personne ne tient le cadre

Un agent de programmation est rapide, infatigable et sincèrement utile. Il a aussi des pentes naturelles, que nous avons rencontrées sur nos projets avant de les fermer une à une.

Il réécrit au lieu de réutiliser Trouver la fonction qui existe déjà demande de connaître le projet. En écrire une seconde est plus court. Le code grossit, les mêmes règles vivent à trois endroits et finissent par diverger.

Il contourne la règle qui le gêne Une consigne d’architecture écrite dans un document est respectée tant qu’elle ne coûte rien. Le jour où elle bloque, l’agent prend le raccourci : un accès direct à une couche interne, une exception « provisoire ».

Il fait passer le test plutôt que de corriger le défaut Quand un test échoue, deux chemins mènent au vert : réparer le code ou affaiblir le test. Sans surveillance, le second est emprunté plus souvent qu’on ne le croit.

Il élargit le périmètre On demande un champ, on reçoit le champ, un réglage, deux fonctions d’aide et une refonte du fichier voisin. Chaque ajout est défendable ; l’ensemble n’a été décidé par personne.

Il laisse la documentation mentir Le code change, le document qui le décrit reste. Or la documentation est précisément ce que l’agent relira demain pour décider : une erreur s’y recopie de session en session.

Il choisit la solution qui fonctionne, pas la plus sûre Une entrée non contrôlée, une dépendance ajoutée sans examen, un secret laissé dans un fichier : rien de cela n’empêche le programme de tourner.

Ces six pentes concernent le code. Trois autres risques tiennent à ce qu’est un agent : un programme qui agit, pas un texte qu’on relit.

Il dispose de plus de moyens que sa mission n’en demande Un agent lit des fichiers, lance des commandes, installe des paquets. Lancé sur un poste de travail ordinaire, il a sous la main tout ce que ce poste contient et tout ce à quoi il donne accès, sans rapport avec la tâche.

Il peut prendre pour un ordre ce qu’il lit Un commentaire dans le code, un document, un ticket, une page web, la réponse d’un outil : tout contenu que l’agent consulte peut contenir une phrase rédigée pour le détourner, lui faire ignorer ses règles ou entreprendre autre chose. C’est l’injection d’instructions. Pour un humain, la différence entre une information consultée et une instruction qui fait autorité va de soi ; pour un modèle, les deux arrivent sous la même forme, du texte.

Il manipule les identifiants qu’on lui confie Une clé d’accès donnée à l’agent est lisible par toute commande qu’il lance, et par tout ce qu’une instruction injectée lui ferait lancer.

Les mesures publiées vont dans le même sens. Veracode a soumis le code produit par plus de cent modèles, dans quatre langages, à ses analyses : une faille de sécurité était introduite dans 45 % des tests.

GitClear, sur 211 millions de lignes modifiées entre 2020 et 2024, relève que la part des lignes copiées-collées est passée de 8,3 % à 12,3 % entre 2021 et 2024, pendant que celle des lignes déplacées, signe qu’on réorganise et qu’on réutilise, tombait de 25 % à moins de 10 %.

Ces deux études viennent d’éditeurs d’outils d’analyse, et la seconde constate une tendance sans en démontrer la cause ; elles décrivent néanmoins ce que nous voyons.

L’enquête DORA de 2025, menée auprès de près de 5 000 professionnels dont 90 % utilisent l’IA dans leur travail, donne la clé de lecture : l’IA n’arrange pas une équipe, elle amplifie ce qui s’y trouve déjà. Les équipes livrent plus vite, mais la stabilité de ce qu’elles livrent continue de se dégrader là où les contrôles en aval n’ont pas suivi.

L’ANSSI et son homologue allemand, le BSI, rappelaient dès octobre 2024 que ces assistants ne remplacent pas des développeurs expérimentés, que le code généré doit être contrôlé, et qu’une analyse de risque précède leur adoption.

Le même rapport décrit l’injection indirecte d’instructions, et l’OWASP place le détournement de l’objectif d’un agent et l’usage abusif de ses outils en tête de sa liste des risques des applications à base d’agents. Aucune consigne ne l’empêche à coup sûr : la réponse est dans ce que l’agent peut atteindre, pas dans ce qu’on lui demande d’ignorer.

## Le principe : une règle qui ne s’exécute pas ne tient pas

Tout ce qui suit découle d’une seule observation. Une consigne écrite en français dans un fichier d’instructions est une demande. L’agent la suit le plus souvent, l’oublie parfois, et l’interprète quand elle le gêne. Un contrôle automatique qui fait échouer la série de vérifications est un fait : la modification n’entre pas.

Notre règle de travail est donc de transformer chaque consigne importante en garde-fou exécuté. Cinq propriétés distinguent un garde-fou qui tient d’un garde-fou décoratif.

Il refuse, il ne signale pas Un avertissement se lit une fois, puis se fond dans le décor. Nos contrôles n’ont que deux issues : passé ou refusé. Zéro avertissement toléré.

Il est fermé par défaut Un élément nouveau que le contrôle ne connaît pas est refusé, pas ignoré. Et des planchers empêchent le contournement le plus simple : vider la liste de ce qui est contrôlé.

Sa liste d’exceptions est vide Une exception accordée devient un précédent que l’agent citera. Quand une règle a besoin d’exceptions, c’est la règle qu’il faut revoir, par une décision écrite.

Il est lui-même testé Un contrôle cassé qui répond toujours « passé » est pire que pas de contrôle. Chaque garde a son propre test, qui lui présente un cas fautif et vérifie qu’il le refuse.

L’agent ne peut pas le neutraliser seul Un contrôle n’est indépendant que si celui qu’il contrôle ne décide pas de son sort. Un agent qui peut supprimer une vérification, affaiblir un test ou abaisser un seuil dans la même modification que son code se contrôle lui-même.

Modification proposée par l’agent

4 passés · 1 refusé · 1 en attente

1. Architecture Passé

   Couches et surface publique

   aucun import interdit · liste d’exceptions vide

2. Contrat Passé

   Types de l’interface régénérés

   identiques à la version enregistrée

3. Qualité Passé

   Format, règles de code, typage, tests

   zéro avertissement toléré

4. Sécurité Passé

   Dépendances, analyse statique, secrets

   versions verrouillées · historique complet

5. Documentation Refusé

   Liens, tâches et décisions

   une tâche citée dans le code est absente du backlog

6. Livraison En attente

   Promotion vers la recette

   attend une série entièrement verte

Un seul refus suffit : rien n’est intégré tant que la série n’est pas entièrement verte. L’agent corrige, la série rejoue.

Exemple de présentation · aucun projet réel

Cette dernière propriété est la plus difficile à tenir, parce que les contrôles vivent dans le même dépôt que le code. Trois choses doivent rester distinctes : la modification que l’agent propose, les règles qui disent si elle est acceptable, et l’autorité qui peut changer ces règles.

Chez nous, plusieurs mécanismes y concourent : des planchers qui font échouer un registre de contrôles vidé, des tests qui visent les gardes elles-mêmes, des branches de production que personne ne peut réécrire, et une livraison lancée par un humain qui a sous les yeux tout ce qui a changé, contrôles compris.

La règle qui complète l’ensemble : toute modification des tests, des seuils ou de l’intégration continue est relue par quelqu’un d’autre que son auteur, humain ou agent. Aucun de ces mécanismes n’est infranchissable à lui seul ; ensemble, ils rendent une neutralisation visible et coûteuse.

Le reste du guide suit l’ordre des trois maîtrises : d’abord ce que l’agent peut faire, puis ce qu’il produit, famille par famille, enfin ce qui est accepté. Le vocabulaire est parfois technique ; l’idée à retenir pour chaque garde-fou est ce qu’il empêche, et ce qu’il laisse passer.

## Tenir l’environnement dans lequel travaille l’agent

Avant de contrôler ce que l’agent produit, il faut décider de ce qu’il peut faire. Un agent de programmation n’écrit pas seulement du texte : il lit et modifie des fichiers, exécute des commandes, installe des dépendances, appelle des outils. C’est un programme autonome doté de moyens réels, qui peut mal comprendre une demande, se tromper de cible ou suivre une instruction injectée.

Le premier garde-fou n’est donc pas une instruction donnée à l’IA. C’est la limite technique des moyens qu’on met à sa disposition.

### Une machine dédiée, et rien d’autre dedans

Chez 8TECH, les agents travaillent dans des machines virtuelles dédiées, distinctes des postes des collaborateurs et des serveurs de production. Elles ne portent que l’agent, les dépôts sur lesquels il travaille et les outils de développement et de contrôle. La différence avec un agent lancé sur un poste de travail se lit en trois lignes.

|                                                 | Sur un poste de travail                                                                                       | Dans une machine dédiée                                         |
| ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| **Ce que l’agent a sous la main**               | Documents des clients, messagerie, identifiants enregistrés, applications connectées, droits d’administration | Le dépôt et les outils prévus pour la mission                   |
| **Ce qu’une mauvaise instruction peut toucher** | Des ressources sans aucun rapport avec la tâche                                                               | Ce que la configuration de la machine lui laisse atteindre      |
| **Après un doute**                              | Un poste entier à examiner                                                                                    | Un environnement minimal, que l’on sait décrire et reconstruire |

Le bénéfice est d’abord une réduction : moins de logiciels, de fichiers et de services à portée, donc moins de choses qu’une erreur peut abîmer, et une erreur qui reste dans l’environnement de travail. C’est aussi une séparation des rôles, puisque le développement ne se fait ni là où l’entreprise travaille ni là où le logiciel est exploité, et un gain de diagnostic : dans un environnement minimal, ce qui s’est passé se retrouve et se rejoue.

Une machine virtuelle ne protège pas par elle-même. Elle vaut ce que valent ses réglages : les droits de l’agent à l’intérieur, les réseaux qu’elle peut joindre, les dossiers qu’on y monte, et surtout les identifiants qu’on y dépose. Une machine isolée qui détient la clé de la production n’isole plus rien.

### Des permissions au plus juste

La règle est celle du moindre privilège, appliquée à un programme : seuls les outils utiles à la mission sont présents, et chaque accès confié à l’agent est propre à un usage, réduit au périmètre le plus étroit que le service permet. En lecture seule quand la mission ne demande que de lire ; restreint à l’adresse de la machine quand le service le propose ; distinct pour chaque service, pour qu’un accès compromis ne les ouvre pas tous.

L’OWASP en fait la première règle de ses recommandations sur les agents : n’accorder que les outils nécessaires à la tâche, et faire appliquer les autorisations par le code qui exécute, pas par le modèle.

### Les services externes : utiliser sans connaître

Un agent a besoin de services extérieurs : la plateforme qui héberge le code, le suivi des tâches, les systèmes de test, des interfaces de programmation tierces. Chacun demande un identifiant, une clé ou un jeton. Or donner un secret à un agent, c’est le mettre à la portée de tout ce qui s’exécute avec ses droits, et lui donner du même coup tout ce que ce secret permet.

Il faut donc dissocier deux choses que l’on confond : pouvoir utiliser un service, et détenir le secret qui y donne accès. Le principe est celui d’un intermédiaire : l’agent demande une opération nommée ; un composant distinct vérifie qu’elle est autorisée, s’authentifie lui-même, et ne renvoie que le résultat.

### Notre façon de faire : une capacité isolée par service

Chez 8TECH, cet intermédiaire est un outil, et chaque service a le sien. C’est la raison pour laquelle nos développements se répartissent en autant de dépôts frères : chacun a la charge d’un service, et d’un seul.

Un dépôt par service Un outil en ligne de commande pour la suite collaborative Microsoft 365, un pour la supervision de sécurité, un pour la comptabilité, un pour la téléphonie, un pour la production de documents, et un orchestrateur qui les enchaîne sans porter de logique métier. Chacun a son code, ses tests, ses règles et sa documentation.

Des opérations nommées L’agent appelle une commande de l’outil. Il n’écrit pas de requête vers le service et n’en manipule pas l’identifiant : ce qu’il peut faire est ce que l’outil expose, rien de plus.

Le secret reste dans l’outil Il est chargé par l’outil au moment de l’exécution, depuis une configuration tenue hors du dépôt versionné. Il ne figure ni dans la conversation avec l’agent, ni dans le code qu’il produit, ni dans un ticket ou un message.

Lire et écrire sont deux accès Pour la suite collaborative, la lecture et l’écriture passent par deux identités distinctes. L’écriture demande une confirmation, et les opérations les plus lourdes de conséquences, sur les rôles, les applications, les consentements ou les domaines, restent hors de l’outil : elles exigent une session humaine. Un accès ouvert pour une enquête expire au bout de trois mois et se retire à sa clôture.

Voir avant de faire Les commandes qui modifient quelque chose sont rejouables sans effet de bord et proposent un mode à blanc, qui affiche le plan sans l’exécuter. Chaque outil a son contrôle d’invariants en lecture seule, et les appels sont journalisés.

Cette découpe est ce qui contient l’agent dans sa mission. Un agent qui travaille sur un projet s’appuie sur ces capacités comme sur des briques : il demande un inventaire, un rapport, une publication, et reçoit un résultat. Il ne détient pas pour autant les clés du service, et aucun agent ne tient la chaîne de services de bout en bout.

La bonne question n’est donc pas seulement « l’agent connaît-il le secret ? », mais « que peut-il déclencher à travers cet outil ? » : une commande `consulter_tache`, qui lit une tâche d’un projet, n’expose pas la même chose qu’une clé générale qui permet de tout lire, de tout modifier et de tout supprimer.

La limite se dit aussi nettement que le principe. Tenir le secret hors de la conversation et hors du code écarte les fuites ordinaires : le secret recopié dans un fichier, un message de commit, un journal ou une réponse. Ce n’est une frontière au sens strict que si l’agent ne peut pas non plus le retrouver par ses propres commandes, dans ses fichiers, ses variables, ses processus ou ses journaux.

Une clé placée dans une variable d’environnement n’est pas protégée si l’agent peut lancer la commande qui l’affiche ; un secret masqué à l’écran n’est pas séparé du modèle ; et un serveur MCP, le protocole qui sert à brancher des outils sur un agent, expose des capacités sans être un mécanisme de sécurité : doté de privilèges excessifs, il reste dangereux.

La forme la plus stricte fait donc tourner l’outil ailleurs que là où l’agent travaille, sous un autre compte ou sur une autre machine. C’est ainsi que tournent nos traitements planifiés : sur un serveur dédié, sous un compte qui leur est propre, avec un accès au code en lecture seule.

Ces deux mesures sont aussi la réponse à l’injection d’instructions. La machine dédiée limite ce qu’une instruction malveillante peut atteindre ; l’outil par service limite ce qu’elle peut déclencher. Elles ne l’empêchent pas d’influencer le code ou les conclusions de l’agent : c’est le rôle des contrôles qui suivent.

## Tenir l’architecture

Nos logiciels reposent sur un socle commun, réutilisé d’un produit à l’autre, et sur des couches qui ont chacune leur rôle. C’est la première chose qu’un agent pressé abîme.

**Les imports sont contrôlés par analyse du code.** Un programme lit chaque fichier et vérifie deux choses : le produit n’utilise le socle que par sa surface publique, jamais par ses mécanismes internes, et le code livré ne dépend jamais d’une couche de test. Côté interface, une règle équivalente interdit les imports internes, et une seconde garde, jouée à la construction, attrape les dépendances indirectes que la première ne voit pas.

**L’agent n’a pas le droit d’écrire partout.** C’est un cas réel, et il montre la forme complète d’un garde-fou, limite comprise.

La dérive Pour faire passer son travail sur un produit, l’agent modifie le socle commun au lieu de s’y conformer.

La cause C’est le chemin le plus court, et le socle est à portée de main, dans le dossier voisin.

Le contrôle Claude Code permet d’exécuter un programme avant chacune de ses actions. Nous nous en servons comme d’un verrou : toute écriture dans le dépôt du socle est refusée, à l’exception d’un fichier où l’agent note ce qu’il faudrait y changer.

Le blocage L’action est refusée avant d’être exécutée, et l’agent reçoit le motif avec la marche à suivre. Le verrou a sa propre suite de tests, qui lui présente des écritures directes et détournées.

La limite C’est un filet pour les gestes courants, pas un bac à sable : une commande suffisamment contournée pourrait passer au travers. Une seconde barrière existe donc plus loin : le produit n’installe le socle que dans une version publiée, verrouillée par son empreinte. Une modification locale du socle ne peut pas partir en livraison.

**Les oublis dangereux empêchent le logiciel de démarrer.** Un modèle de données qui n’est pas rattaché à un client, une opération d’écriture sans règle d’autorisation déclarée : ce ne sont pas des remarques de relecture, ce sont des erreurs au lancement. Un test interdit par ailleurs toute lecture qui sortirait du périmètre d’un client, et sa liste d’autorisations est vide.

**Les espaces restent étanches.** L’application destinée aux clients et celle des équipes internes ne partagent pas leur code d’écran. Trois tests et deux gardes le vérifient, pour qu’une fonction d’administration ne puisse pas se retrouver par accident dans ce qui est servi aux clients.

## Tenir le contrat entre le serveur et l’interface

Un agent modifie volontiers le serveur sans toucher à l’interface, ou l’inverse. L’écart ne se voit qu’à l’usage. Nous l’avons rendu impossible à livrer.

Chaque point d’entrée est inscrit dans un registre Des suites de tests parcourent ce registre et vérifient pour chacun le même comportement : forme des réponses, refus sans identification, refus sans droit, objet introuvable, modification concurrente, isolation entre clients. Un point d’entrée absent du registre fait échouer la suite.

La liste des opérations publiques est figée Rendre une opération accessible sans identification demande de modifier cette liste, donc de le faire en connaissance de cause. La matrice des autorisations est testée groupe par groupe.

Les entrées inconnues sont refusées Des balayages automatiques vérifient que chaque schéma d’entrée rejette un champ non prévu, que les textes ont une longueur bornée et que les erreurs métier sont déclarées.

Les types de l’interface sont régénérés et comparés À chaque envoi, l’intégration continue régénère les types de l’interface à partir de la description du serveur, puis exige qu’ils soient identiques à la version enregistrée. Le moindre écart arrête tout.

Un changement de modèle sans migration est refusé Si le code décrit une base de données que les scripts de migration ne produisent pas, le contrôle échoue avant la livraison, pas pendant.

## Tenir les dépendances

Ajouter une bibliothèque est le geste le plus facile pour un agent, et l’un des plus engageants pour le projet : c’est du code que personne ici n’a écrit et qui entre en production.

Les versions sont verrouillées avec leur empreinte : la machine de développement, l’intégration continue et la production installent exactement les mêmes fichiers, et un paquet modifié en amont est refusé. Les paquets viennent d’un seul index, jamais d’une source secondaire ajoutée en complément, ce qui ferme la porte à la substitution d’un paquet interne par un homonyme public. Le socle commun est épinglé à une version exacte des deux côtés.

Quand le socle annonce qu’une fonction sera retirée, l’annonce est traitée comme une erreur dans les tests : la suite casse avant le retrait, pas après. Les vulnérabilités connues des dépendances sont recherchées à chaque envoi, côté serveur comme côté interface, et à date fixe chaque semaine, indépendamment de l’activité : une faille publiée entre deux envois n’a pas à attendre le suivant.

## Tenir la documentation et le backlog

Avec un agent, la documentation change de statut. Ce n’est plus un livrable de fin de projet, c’est sa mémoire de travail : il la relit à chaque session, et il décide d’après elle. Une documentation fausse produit donc du code faux, avec assurance. Nous la contrôlons comme du code, par un programme qui a lui aussi ses tests.

Liens, ancres et commandes citées Un lien cassé, un document que rien ne référence, une commande mentionnée qui n’existe plus : refusé.

Fichiers d’instructions plafonnés Les consignes que l’agent relit à chaque session, `CLAUDE.md` pour Claude Code et `AGENTS.md` pour Codex, ont une taille maximale. Au-delà, elles ne sont plus lues avec attention, par l’IA comme par les humains ; le plafond oblige à trier.

Backlog au format imposé Chaque tâche a un identifiant et une longueur bornée. Tout renvoi laissé dans le code vers une tâche à faire doit correspondre à une tâche qui existe.

Le présent seulement La documentation décrit ce qui est, pas l’histoire de ce qui a été. Les dates, les récits de version et les tâches closes vont au journal des changements ; ailleurs, le contrôle les refuse. C’est ce qui évite qu’un agent réapplique une décision abandonnée.

Les décisions sont écrites Chaque choix d’architecture structurant a sa fiche : contexte, décision, conséquences. Un registre garde aussi les demandes d’interface refusées et leur motif, pour ne pas les rediscuter à chaque session.

## Tenir la qualité, la sécurité et les données

C’est la partie la plus classique, et l’IA n’y change rien d’autre que l’intransigeance nécessaire : formatage imposé, règles de code, vérification des types et tests automatiques des deux côtés, construction réelle des applications, et contrôle des réglages de sécurité dans une configuration de production. L’intégration continue joue tout, à chaque envoi, sans filtre par dossier : un contrôle qui ne se déclenche pas ne protège rien.

Deux compléments ferment les angles morts des tests. La couverture se mesure, et son plancher fonctionne à cliquet : il peut monter, jamais redescendre, ce qui empêche d’ajouter du code sans les tests qui vont avec. Et les parcours essentiels se rejouent de bout en bout dans l’application réelle, parce qu’une suite de tests entièrement verte ne prouve pas qu’un écran s’ouvre.

**Ce qu’une suite verte prouve, et ce qu’elle ne prouve pas.** Elle prouve que le logiciel respecte les propriétés que quelqu’un a pensé à vérifier. Elle ne dit rien d’une exigence mal comprise, d’un scénario que personne n’a écrit, ni d’une faille encore inconnue. Trois niveaux sont à distinguer.

La conformité Le logiciel respecte les règles techniques imposées : architecture, format, types, contrat. C’est ce que les garde-fous de ce guide établissent le mieux.

La correction Il se comporte comme attendu et respecte les règles du métier. Les tests y contribuent s’ils vérifient un comportement, et pas seulement qu’une fonction s’exécute : les cas d’erreur et de refus autant que les cas nominaux, des propriétés qui doivent tenir pour toute entrée, et, là où l’enjeu le justifie, des tests de mutation, qui altèrent volontairement le code pour vérifier qu’un test s’en aperçoit.

La pertinence Il traite le bon besoin, sans complexité inutile. Aucun test ne le dit : c’est l’objet de l’analyse validée par un humain, décrite plus bas.

1 600+ tests automatiques côté serveur, joués à chaque envoi

450 cas de test environ côté interface

84 contraintes d’intégrité déclarées dans la base de données

12 décisions d’architecture écrites et tenues à jour

Relevé 8TECH sur son logiciel de gestion interne, novembre 2026

**La sécurité a sa propre série.** Audit des dépendances, analyse statique du code à la recherche de constructions dangereuses, et recherche de secrets dans tout l’historique du dépôt, avec un outil dont le fichier est lui-même vérifié par son empreinte avant d’être exécuté. Les branches qui mènent à la production sont protégées : personne, humain ou agent, ne peut en réécrire l’histoire.

**La confidentialité se joue à quatre endroits.** Ce que l’agent peut lire sur sa machine ; ce qui part chez le fournisseur du modèle, c’est-à-dire tout ce que l’agent lit pour travailler ; ce que ses outils et ses connecteurs peuvent atteindre ; et ce que gardent les journaux de ses sessions.

La règle est la même partout : ne mettre à sa portée que ce que la mission exige, classer les informations avant de décider lesquelles peuvent s’y trouver, et séparer les environnements.

L’engagement d’un fournisseur à ne pas entraîner ses modèles sur vos données ne règle qu’une partie de la question : restent la durée de conservation, le lieu de traitement, les transferts éventuels et ce que le contrat garantit réellement.

**La base de données se défend seule.** Les règles qui ne doivent jamais être violées, comme un montant qui ne peut pas être négatif, une référence unique ou deux périodes qui ne peuvent pas se chevaucher, sont déclarées dans la base elle-même. Si un agent écrit un jour un code qui les oublie, la base refuse l’écriture.

Chaque nuit, un contrôle d’intégrité relit les données de production et les fichiers stockés, et un autre vérifie que chaque tâche planifiée a bien tourné.

## Tenir la mise en production

Aucun agent ne met en production. La livraison est un script, toujours le même, et c’est un humain qui le lance.

Avant Le script vérifie l’état du dépôt, n’accepte dans le commit de livraison qu’une liste fermée de fichiers, et attend que l’intégration continue soit entièrement verte.

Pendant La branche de production n’avance que par promotion de ce qui a déjà été validé, sans fusion ni réécriture. La recette reçoit la version en premier ; la production attend que la recette ait réussi.

Sur le serveur Chaque version est installée dans son propre dossier, jamais par-dessus la précédente. Le script contrôle la place disque, sauvegarde la base avant toute migration, pose un verrou, et refuse d’avancer si une action manuelle prévue n’a pas été confirmée. Un disjoncteur arrête le déploiement automatique après un échec.

En répétition Avant une livraison, une commande repart d’une copie de la base et rejoue exactement le chemin de mise à jour que suivra le serveur. Une migration écrite à la main y est refusée.

Les scripts de livraison sont eux-mêmes du code, et ils ne s’exécutent pour de bon qu’en production : ils ont donc leurs propres suites de tests, et passent par un analyseur statique qui repère les constructions fragiles. Quant à la sauvegarde et au retour arrière, ils s’exercent à date fixe, comme on teste une [sauvegarde](https://www.8tech.fr/guides/strategie-sauvegarde-pme/) : une restauration jamais essayée n’est qu’une hypothèse.

## Ce qui reste à l’humain

Les garde-fous disent si une modification est conforme. Ils ne disent pas si c’était la bonne modification. Cette part ne se délègue pas, et elle tient en trois règles.

**L’analyse avant le code.** Notre cycle est toujours le même : analyse, validation, code, documentation, tests. L’agent commence par dire ce qu’il a compris, ce qu’il propose et ce qu’il écarte. Un humain valide. Corriger une analyse coûte cinq minutes ; corriger le code issu d’une mauvaise analyse coûte la journée.

**Le modèle minimal.** On n’ajoute que ce que le besoin exige aujourd’hui. Un champ, une option ou une abstraction « au cas où » sont refusés à l’analyse : c’est le seul moment où le refus est gratuit.

**Des rôles séparés.** L’audit du projet se fait par un agent en lecture seule, qui ne peut rien modifier et n’a donc aucun intérêt à trouver son propre travail satisfaisant. La vérification d’une fonction se fait dans l’application réelle, pas seulement dans les tests.

**L’acceptation du risque qui reste.** Aucun garde-fou ne ferme entièrement son domaine. Chacun réduit un risque et laisse une limite, qu’un autre contrôle vient couvrir : c’est leur superposition qui protège. Décider que ce qui reste est acceptable, pour ce logiciel et pour ces données, est une décision humaine, et elle se prend en connaissant la limite de chaque contrôle.

| Le risque                                             | Le garde-fou                                                                     | Ce qui reste                                                  |
| ----------------------------------------------------- | -------------------------------------------------------------------------------- | ------------------------------------------------------------- |
| **Accès à des fichiers sans rapport avec la mission** | Machine dédiée, accès restreints                                                 | Une configuration fautive, ou un accès accordé trop largement |
| **Exposition d’identifiants**                         | Un outil par service, qui garde le secret et n’expose que des opérations nommées | L’abus d’une opération pourtant autorisée                     |
| **Instruction malveillante dans un contenu**          | Permissions limitées, contenus traités comme des données                         | Une influence sur le code ou les conclusions de l’agent       |
| **Affaiblissement d’un contrôle**                     | Planchers, gardes testées, relecture indépendante                                | Un défaut dans les contrôles eux-mêmes                        |
| **Erreur de métier**                                  | Analyse validée, tests de comportement                                           | Une exigence de départ fausse ou incomplète                   |
| **Régression**                                        | Tests automatiques, parcours réels                                               | Le scénario que personne n’a écrit                            |

Enfin, un garde-fou de plus n’est pas toujours un progrès. Nous avons écarté un contrôle supplémentaire avant chaque enregistrement du code, parce que la livraison attend déjà une intégration continue verte : il aurait ralenti le travail sans rien empêcher de plus. Chaque garde-fou doit pouvoir dire quelle dérive il ferme.

## La liste de contrôle complète

Voici l’ensemble, famille par famille. Chaque ligne est un contrôle automatique ou une règle de méthode ; aucune ne repose sur la bonne volonté de l’agent.

Méthode Analyse validée par un humain avant le code · modèle minimal · décisions d’architecture écrites · audit par un agent en lecture seule · vérification dans l’application réelle

Environnement de l’agent Machine virtuelle dédiée, distincte des postes de travail et de la production · rien d’autre que l’agent, les dépôts et les outils de la mission · permissions minimales · un outil par service externe, aux opérations nommées · lecture et écriture séparées · secrets chargés par l’outil, jamais dans la conversation ni dans le code · mode à blanc avant toute modification · contenus lus traités comme des données, jamais comme des ordres · appels et actions sensibles tracés

Architecture Imports contrôlés par couche · socle utilisé par sa seule surface publique · zones interdites en écriture à l’agent · oublis dangereux bloquants au démarrage · isolation des données entre clients · listes d’exceptions vides · gardes elles-mêmes testées, que l’agent ne peut pas neutraliser seul

Contrat Registre des points d’entrée balayé par les tests · opérations publiques figées · autorisations testées par groupe · entrées inconnues refusées · types de l’interface régénérés et comparés · migrations vérifiées

Dépendances Versions verrouillées avec empreintes · index unique · dépréciations traitées comme des erreurs · recherche de vulnérabilités à chaque envoi et chaque semaine

Documentation Liens, ancres et commandes citées contrôlés · fichiers d’instructions plafonnés · backlog au format imposé, relié au code · le présent seulement, l’histoire au journal des changements

Qualité Format, règles de code, types et tests à chaque envoi · zéro avertissement · construction réelle des applications · plancher de couverture à cliquet · parcours de bout en bout · intégration continue sans filtre

Sécurité Analyse statique du code · recherche de secrets dans tout l’historique · outils vérifiés par leur empreinte · branches de production protégées

Données Règles vitales déclarées dans la base · contrôle d’intégrité chaque nuit · surveillance des tâches planifiées

Livraison Script unique lancé par un humain · intégration continue verte exigée · promotion sans réécriture · recette avant production · versions installées côte à côte · sauvegarde avant migration · répétition sur une copie de la base · restauration et retour arrière exercés à date fixe · scripts testés et analysés

## Par où commencer, et quoi demander à un prestataire

Tout cela s’est construit par étapes, un garde-fou après l’autre, chaque fois qu’une dérive était constatée. Pour une petite équipe qui démarre, six mesures ferment l’essentiel, dans cet ordre.

Un environnement dédié pour l’agent Une machine virtuelle qui ne contient que le dépôt et les outils, pas le poste où se trouvent votre messagerie, vos documents et vos accès. Et aucun branchement sur un système sensible tant que le reste de la liste n’est pas en place.

Une intégration continue qui joue tout, à chaque envoi Format, règles de code, types, tests. Rien n’est intégré si elle n’est pas verte.

Des dépendances verrouillées et une recherche de secrets Ce sont les deux incidents les plus coûteux et les plus simples à prévenir.

Les règles vitales dans la base de données Ce qui ne doit jamais arriver aux données se déclare là où aucun code ne peut l’oublier.

L’analyse validée avant le code Une règle de méthode, gratuite, qui supprime la moitié des dérives de périmètre.

Une livraison scriptée, lancée par un humain Avec une sauvegarde avant et un retour arrière essayé au moins une fois.

Si vous faites développer un outil, par un prestataire, par un indépendant ou par un collaborateur qui s’y est mis avec une IA, vous n’avez pas à lire le code pour savoir s’il est tenu. Dix questions suffisent, et les réponses se montrent.

| La question                                                                       | Ce qu’une bonne réponse montre                                                                                                                                          |
| --------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Utilisez-vous une IA pour écrire le code, et qui répond du résultat ?**         | Une réponse franche sur les outils employés, et le nom d’une personne responsable.                                                                                      |
| **Où s’exécutent vos agents, et à quoi ont-ils techniquement accès ?**            | Un environnement dédié, décrit précisément : ce qu’il contient, ce qu’il peut joindre, ce qu’il ne peut pas atteindre.                                                  |
| **Comment accèdent-ils aux services externes, et peuvent-ils lire les secrets ?** | Des accès limités à des opérations précises, et une réponse nette à la seconde question, commandes exécutées par l’agent comprises.                                     |
| **Qu’est-ce qui empêche une modification non conforme d’être livrée ?**           | Une liste de contrôles automatiques, et le résultat de la dernière exécution.                                                                                           |
| **Qui peut modifier les contrôles eux-mêmes ?**                                   | Une personne identifiée, distincte de l’auteur de la modification, et une trace de chaque changement.                                                                   |
| **Les tests tournent-ils à chaque modification ?**                                | Un historique d’exécutions, pas une intention.                                                                                                                          |
| **Où sont mes données quand l’IA travaille ?**                                    | Ce que l’agent peut lire est écrit noir sur blanc, et le fournisseur du modèle est nommé au contrat, avec l’engagement de ne pas entraîner ses modèles sur vos données. |
| **Comment se passe une mise en production, et un retour arrière ?**               | Une procédure écrite, une sauvegarde avant, et la date du dernier retour arrière essayé.                                                                                |
| **Les décisions techniques sont-elles écrites ?**                                 | Des documents que vous pouvez lire, et qui vous sont remis.                                                                                                             |
| **Si nous nous séparons, que me remettez-vous ?**                                 | Le code, son historique, la documentation, et de quoi le reconstruire sans vous.                                                                                        |

La dernière question est la même que pour un contrat informatique : le guide [choisir un prestataire informatique](https://www.8tech.fr/guides/choisir-prestataire-informatique/) détaille ce qu’il faut exiger sur la réversibilité.

Tout ce guide tient en une phrase. On ne sécurise pas le développement avec l’IA en demandant à l’agent d’être prudent : on limite techniquement ses pouvoirs, on vérifie systématiquement ce qu’il produit, et on garde une autorité indépendante sur les décisions importantes.

## Questions fréquentes

### Qu’est-ce que le vibe coding ?

Le vibe coding est une façon de programmer où l’on décrit ce que l’on veut à une IA et où l’on accepte le code qu’elle produit sans le lire, en se fiant au résultat apparent. L’expression a été lancée le 2 février 2025 par le chercheur Andrej Karpathy, qui la réservait à des projets sans enjeu. Elle désigne aujourd’hui, par extension, une grande partie du développement assisté par IA.

### Le vibe coding est-il dangereux pour une entreprise ?

Pour un prototype ou un outil jetable, non : c’est un moyen rapide de tester une idée. Il le devient quand le résultat part en production avec des données réelles, sans tests, sans contrôle de sécurité et sans personne qui sache ce que le code fait. Les risques sont alors ceux d’un logiciel non maîtrisé : faille de sécurité, fuite de données, impossibilité de le faire évoluer.

### Peut-on confier un logiciel d’entreprise à une IA ?

On peut lui confier l’écriture du code, pas la responsabilité du logiciel. Ce qui tient un logiciel écrit avec une IA, ce sont des contrôles automatiques qui refusent toute modification non conforme, une analyse validée par un humain avant le code, et une mise en production que l’IA ne déclenche jamais elle-même.

### Qu’est-ce qu’un garde-fou en développement avec l’IA ?

Un garde-fou est un contrôle automatique, joué à chaque modification, qui fait échouer la livraison quand une règle n’est pas respectée : règle d’architecture, cohérence entre le serveur et l’interface, version des dépendances, exactitude de la documentation, sécurité. À la différence d’une consigne écrite, il ne dépend pas de la bonne volonté de l’IA ni de l’attention d’un relecteur.

### Un agent de programmation a-t-il accès aux données de l’entreprise ?

Il a accès à tout ce que contient la machine où il tourne, et à tout ce que les identifiants présents sur cette machine permettent d’atteindre. C’est pourquoi il ne doit pas travailler sur le poste d’un collaborateur : chez 8TECH, les agents s’exécutent dans des machines virtuelles dédiées, qui ne portent que l’agent, les dépôts de code et les outils de développement. Pour chaque service externe, il passe par un outil dédié qui garde le secret d’accès et n’expose que des opérations nommées. Ce que l’agent lit pour travailler est par ailleurs transmis au fournisseur du modèle : c’est un second périmètre à maîtriser, par le choix de ce qu’on place à sa portée et par le contrat.

### Qu’est-ce que l’injection d’instructions (prompt injection) dans un agent de programmation ?

C’est une instruction cachée dans un contenu que l’agent consulte, fichier, commentaire de code, ticket, page web ou réponse d’un outil, et rédigée pour le détourner de sa mission. Aucune consigne ne l’empêche à coup sûr. On en limite les effets en réduisant ce que l’agent peut atteindre et les actions qu’il peut déclencher. Elle peut encore fausser le code ou les conclusions qu’il produit : les contrôles automatiques et la validation humaine sont là pour le rattraper.

### Faut-il relire tout le code écrit par une IA ?

Relire chaque ligne ne tient pas dans la durée : un agent produit plus de code qu’un humain ne peut en lire avec attention. La relecture humaine se concentre sur l’analyse, les décisions d’architecture et ce qui touche à la sécurité et aux données ; le reste est confié à des contrôles automatiques, à condition qu’ils refusent réellement ce qui n’est pas conforme.

### L’IA remplace-t-elle les développeurs ?

Non. Elle déplace leur travail : moins d’écriture, davantage d’analyse, de décision et de conception des contrôles. L’ANSSI et le BSI le rappellent dans leurs recommandations d’octobre 2024 : ces assistants ne remplacent pas des développeurs expérimentés. Concevoir les garde-fous décrits ici demande précisément l’expérience de ce qui casse en production.

### Quels outils 8TECH utilise-t-elle pour développer avec l’IA ?

8TECH développe avec l’assistance de l’IA depuis 2022 et avec des agents depuis 2024 ; aujourd’hui avec Claude Code, l’agent de programmation d’Anthropic, et Codex, celui d’OpenAI. 8TECH développe et exploite avec eux ses propres logiciels, dont son outil de gestion interne, l’espace client de ses clients et [l’Entreprise augmentée](https://www.8tech.fr/entreprise-augmentee/). Les garde-fous décrits dans ce guide ne dépendent pas de l’outil : ce sont des contrôles du projet, qui s’appliquent quel que soit l’agent, et aux humains aussi. Aucun agent ne met en production : la livraison est scriptée et lancée par un humain.

Méthode décrite d’après les projets de développement de 8TECH. Les chiffres cités sont ceux d’un logiciel et d’une date ; ils évoluent avec lui. Voir aussi, pour comprendre pourquoi un modèle affirme le faux avec la même assurance que le vrai, l’article [l’intelligence artificielle n’est pas intelligente](https://www.8tech.fr/intelligence-artificielle-nest-pas-intelligente/).

Pour vérifier

## Sources et références

Ce que ce guide affirme et qui ne vient pas de notre pratique vient d’ici. Chaque référence porte son éditeur et sa date.

[L’ANSSI et le BSI publient leurs recommandations de sécurité concernant les assistants de programmation basés sur l’IA](https://cyber.gouv.fr/actualites/lanssi-et-le-bsi-publient-leurs-recommandations-de-securite-concernant-les-assistants-de-programmation-bases-sur-lia/) ANSSI et BSI · 2024-10-04 — rapport conjoint « AI Coding Assistants », en anglais : analyse de risque préalable, contrôle du code généré, confidentialité, injections indirectes

[AI Agent Security Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html) OWASP Cheat Sheet Series · 2026-11-15 — fiche tenue à jour en continu, consultée à cette date : outils et permissions au minimum, contenus externes traités comme non fiables, exécution isolée, validation humaine des actions à fort impact

[OWASP Top 10 for Agentic Applications for 2026](https://genai.owasp.org/resource/owasp-top-10-for-agentic-applications-for-2026/) OWASP GenAI Security Project · 2025-12-09 — les dix risques des applications à base d’agents, dont le détournement d’objectif et l’usage abusif des outils

[MCP Security Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/MCP_Security_Cheat_Sheet.html) OWASP Cheat Sheet Series · 2026-11-15 — fiche tenue à jour en continu, consultée à cette date : permissions minimales par serveur, identifiants distincts, réponses d’outils traitées comme des données non fiables

[State of AI-assisted Software Development 2025](https://dora.dev/research/2025/dora-report/) DORA (Google Cloud) · 2025-09-23 — près de 5 000 professionnels interrogés : l’IA amplifie les forces et les faiblesses d’une organisation ; le débit de livraison monte, la stabilité reste en baisse

[2025 GenAI Code Security Report](https://www.veracode.com/resources/analyst-reports/2025-genai-code-security-report/) Veracode · 2025-07-30 — code produit par plus de 100 modèles dans quatre langages : une faille de sécurité introduite dans 45 % des tests ; étude d’un éditeur d’outils d’analyse de code

[AI Copilot Code Quality: 2025 Look Back at 12 Months of Data](https://www.gitclear.com/ai_assistant_code_quality_2025_research) GitClear · 2025-02 — 211 millions de lignes modifiées de 2020 à 2024 : le copié-collé dépasse la réutilisation ; étude d’un éditeur d’outils de mesure, qui constate une tendance sans en prouver la cause

[Message d’Andrej Karpathy introduisant l’expression « vibe coding »](https://x.com/karpathy/status/1886192184808149383) Andrej Karpathy, sur X · 2025-02-02 — l’origine du terme, employé par son auteur pour des projets sans enjeu
