Vibe coding en entreprise : les garde-fous pour développer avec l’IA sans dérive
Sommaire · 14 sections
8TECH développe et exploite ses propres logiciels : son outil de gestion interne, l’espace client de ses clients et l’Entreprise augmentée. Elle développe de la même façon les applications et les automatisations 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.
01Le 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.
02Ce 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.
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.
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.
03Le 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.
ArchitecturePassé
Couches et surface publique
aucun import interdit · liste d’exceptions vide
ContratPassé
Types de l’interface régénérés
identiques à la version enregistrée
QualitéPassé
Format, règles de code, typage, tests
zéro avertissement toléré
SécuritéPassé
Dépendances, analyse statique, secrets
versions verrouillées · historique complet
DocumentationRefusé
Liens, tâches et décisions
une tâche citée dans le code est absente du backlog
LivraisonEn 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.
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.
04Tenir 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.
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.
05Tenir 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.
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.
06Tenir 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.
07Tenir 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.
08Tenir 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.
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.09Tenir 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.
1 600+tests automatiques côté serveur, joués à chaque envoi
450cas de test environ côté interface
84contraintes d’intégrité déclarées dans la base de données
12dé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é.
10Tenir 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.
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 : une restauration jamais essayée n’est qu’une hypothèse.
11Ce 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.
12La 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.
13Par 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.
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 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.
14Questions 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. 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.
