- Accueil
- Centre d'apprentissage
- Où placer les approbations humaines dans un workflow de codage par IA
Où placer les approbations humaines dans un workflow de codage par IA
Mis à jour le
Quels moments de la livraison assistée par IA exigent une approbation humaine, comment séparer les tâches quand un agent écrit le code, et comment éviter les approbations de pure forme.
Sur cette page
Les approbations humaines ont leur place aux moments où le travail d'un agent IA devient difficile à annuler ou commence à toucher d'autres personnes : avant qu'un changement soit fusionné dans la branche principale, avant qu'il soit déployé en production, et avant que des agents entament des types de travail risqués comme des changements d'infrastructure ou de dépendances. Tout le reste peut s'exécuter automatiquement derrière des barrières. Pour qu'une approbation ait un sens, elle doit venir de quelqu'un d'autre que la personne qui a demandé le changement, être donnée avec les preuves sous les yeux, et porter sur la version exacte qui est livrée.
Cette page approfondit la section « Humain dans la boucle » de Comment les agents IA s'intègrent-ils au cycle de vie logiciel ?.
Dans la boucle, en supervision, hors de la boucle
Trois niveaux d'implication humaine méritent d'être distingués, car les équipes en nomment souvent un en pensant à un autre.
| Niveau | Ce que fait la personne | Adapté à |
|---|---|---|
| Dans la boucle | Approuve avant que le travail de l'agent prenne effet | Fusions, déploiements en production, changements d'infrastructure et d'accès |
| En supervision | Observe l'agent agir et peut l'arrêter ou annuler ce qu'il a fait | Automatisation à faible risque, avec une bonne supervision et un rollback facile |
| Hors de la boucle | Ne relit qu'après coup, voire pas du tout | Travail dont les résultats sont vérifiés par d'autres moyens, comme des brouillons |
La plupart des travaux de codage par IA les combinent : les agents planifient, écrivent et testent seuls, des personnes approuvent à quelques moments définis, et l'ensemble du processus est enregistré pour être examiné plus tard.
Quelles décisions exigent une personne
Un test utile consiste à se demander ce qui se passe si l'agent se trompe et que personne ne s'en aperçoit pendant une semaine. Si la réponse est « pas grand-chose » ou « on fait un revert », l'automatisation avec des barrières suffit. Si la réponse implique des clients, des données, de l'argent, la sécurité ou un incident, placez une personne devant.
Les décisions qui exigent généralement une approbation :
- La fusion dans la branche principale. Après ce point, d'autres personnes construisent sur le changement.
- Le déploiement en production. Surtout lorsque le rollback est lent ou que des migrations de données sont en jeu.
- La modification de l'infrastructure, des pipelines de CI ou du contrôle d'accès. Leur portée dépasse l'application.
- L'ajout ou la mise à niveau de dépendances. Chaque nouveau paquet est un nouveau fournisseur.
- Le lancement d'un travail coûteux ou de longue durée, comme de grands refactorings ou des tâches planifiées sur de nombreux dépôts.
- Tout ce qui envoie des données hors de l'organisation.
Les décisions qui n'en exigent généralement pas : quels fichiers un agent lit, comment il structure son plan, quels tests il écrit, ou s'il faut relancer une étape en échec. Les soumettre à approbation ajoute de la friction sans ajouter de sécurité.
La séparation des tâches quand un agent écrit le code
La séparation des tâches est un contrôle ancien : la personne qui fait un changement ne devrait pas être la seule à l'approuver. Avec les agents IA, la question est de savoir qui compte comme auteur.
L'agent ne peut être tenu responsable de rien ; l'auteur est donc la personne qui lui a confié la tâche. Elle a choisi l'objectif, le périmètre et souvent l'approche, et c'est elle qui est la plus encline à croire que le résultat est juste. Son approbation apporte peu d'indépendance.
En pratique :
- Le demandeur ne devrait pas être le seul approbateur lorsque quelqu'un d'autre peut approuver.
- Les approbations devraient être comptées par personne, afin qu'une personne qui vote deux fois ne compte pas pour deux approbations.
- Les chemins sensibles peuvent désigner des approbateurs précis, par exemple un relecteur sécurité pour le code d'authentification.
- Les développeurs seuls sont un vrai cas. Une équipe d'une personne ne peut pas séparer les tâches, et le processus devrait y autoriser l'auto-approbation plutôt que d'imposer un contournement, tout en enregistrant qu'elle a eu lieu.
Ce que l'approbateur doit voir
Un approbateur à qui l'on demande de décider sans contexte bloquera tout ou approuvera tout. Placez les preuves à côté de la décision :
- la tâche confiée à l'agent, pour que l'approbateur puisse juger si le changement fait ce qui était demandé ;
- le diff lui-même, pas un résumé du diff ;
- les résultats de tests pour cette version exacte, y compris ce qui a été ignoré ou non exécuté ;
- les constats de revue et la façon dont chacun a été trié ;
- les éventuelles décisions de politique, comme un chemin protégé qui a rendu cette approbation nécessaire.
S'il manque une preuve, l'approbateur doit voir qu'elle manque.
Éviter la lassitude des approbations
Les approbations perdent leur valeur lorsqu'elles sont trop nombreuses. Les personnes qui approuvent des dizaines de changements triviaux par jour cessent de lire, et leurs approbations deviennent de pure forme.
- Approuvez moins de choses, mais plus significatives. Utilisez la politique pour décider quels changements exigent une personne, et laissez les barrières gérer le reste.
- Gardez les changements petits. Un changement ciblé peut être lu ; un changement tentaculaire est survolé.
- Rendez le rejet peu coûteux. Avec des agents, un changement rejeté peut être refait avec une meilleure tâche. Les approbateurs doivent se sentir libres de dire non.
- Exigez un motif de rejet. Il améliore la tentative suivante et crée une trace de ce que l'équipe n'accepte pas.
- Faites expirer les approbations. Une demande qui attend des semaines est approuvée sur une base de code qui a évolué depuis.
Lier les approbations aux versions
Une approbation est une déclaration sur un changement précis. Si le changement est modifié après l'approbation, par une personne ou par une exécution de suivi d'un agent, l'approbation doit être réinitialisée. Sinon, un changement relu peut être remplacé par un changement non relu après la décision.
Il en va de même pour les preuves. Les résultats de tests et les constats de revue doivent appartenir à la version pour laquelle ils ont été produits, afin que les preuves de l'approbateur et le code livré correspondent.
Enregistrer la décision
Chaque approbation doit laisser une trace : qui a approuvé ou rejeté, quand, quelle version, avec quelle note, et quelles preuves étaient disponibles. C'est cette trace que chercheront un auditeur, une revue d'incident ou un futur mainteneur lorsqu'ils se demanderont comment un changement est arrivé en production.
Comment AI CodeOps s'y prend
Dans AI CodeOps, chaque changement de code issu d'une session doit avoir une revue approuvée avant l'ouverture de sa pull request, quel que soit le réglage de confiance de l'espace de travail. La personne qui a lancé la session ne peut pas approuver son changement tant que quelqu'un d'autre dans l'espace de travail le peut ; un espace de travail d'une seule personne peut approuver son propre travail. Les rôles Owner, Admin et Security Admin peuvent approuver par défaut, un rôle personnalisé peut recevoir cette permission, et une demande peut désigner des approbateurs précis. Les approbations sont comptées par personne distincte.
Un seul rejet met fin à la demande, et un rejet exige un motif. Les revues de changement de code expirent au bout de 7 jours. Modifier un changement après son approbation remet son approbation à l'état pending.
Les règles de politique ajoutent des points de contrôle plus tôt. Une règle ask sur workflow.dispatch retient une session avant son démarrage, par exemple pour chaque mise à niveau de dépendances, et cette demande expire au bout de 3 jours. Une règle ask sur diff.apply avec un chemin tel que infra/** exige une revue approuvée pour les changements de ces fichiers. Chaque décision est enregistrée dans le journal d'audit, et les approbations ainsi que chaque vote font partie du dossier de preuves signé du changement.
Consultez Approbations et politiques pour l'ensemble des règles, l'entrée du glossaire humain dans la boucle, et Journaux d'audit, rôles et politiques pour une vue d'ensemble.
Questions fréquentes
Quelle est la différence entre human-in-the-loop et human-on-the-loop ?
Dans la boucle (in the loop), le travail de l'agent ne prend effet qu'après l'approbation d'une personne. En supervision (on the loop), l'agent agit seul et une personne surveille et peut intervenir. Hors de la boucle (out of the loop), personne ne regarde tant que rien ne tourne mal.
La personne qui a rédigé le prompt d'un agent IA peut-elle approuver son changement ?
Seulement lorsque personne d'autre ne le peut. La personne qui a rédigé la tâche est de fait l'auteur du changement, si bien que son approbation revient à l'auteur qui se donne raison à lui-même. Un développeur seul n'a pas d'autre choix, et la trace doit le montrer.
Combien d'approbateurs faut-il pour un changement écrit par l'IA ?
Un approbateur indépendant est le minimum habituel avant la fusion. Ajoutez-en un second, ou un approbateur précis comme un relecteur sécurité, pour les chemins sensibles tels que l'authentification, les paiements ou l'infrastructure.
Que doit-il se passer si un changement est modifié après son approbation ?
L'approbation ne doit plus compter. Elle portait sur la version que l'approbateur a vue ; la version modifiée exige donc une nouvelle décision.
Voir aussi
- Comment les agents IA s'intègrent-ils au cycle de vie logiciel ?
- Approbations et politiques
- Humain dans la boucle (human-in-the-loop)
- Dossiers de preuves
- Journaux d'audit, rôles et politiques pour le codage par IA
- Politique de codage par IA : un template gratuit pour vos équipes
- Tout le centre d'apprentissage