Un workflow de programmation par IA doit relier les exigences à une modification vérifiable, aux tests, puis à une GitHub Pull Request, avec une validation humaine avant fusion. Le modèle présenté répartit le travail entre quatre rôles — coordination, implémentation, tests et revue — et convient surtout aux demandes dont les critères d’acceptation peuvent être contrôlés sans interprétation subjective.
Cette méthode s’adresse aux ingénieurs qui veulent déléguer des tâches répétitives à des agents, aux responsables qui évaluent les risques d’une chaîne automatisée et aux équipes qui souhaitent tester une approche progressive. Elle n’est pas adaptée à une demande dont le périmètre, les impacts de sécurité ou le comportement attendu restent indéfinis.
Dernière mise à jour : 8 mars 2025. Les étapes et les contrôles GitHub sont à confronter aux instructions officielles de création d’une Pull Request, aux règles des branches protégées et aux informations officielles sur les contrôles d’état. Pour les agents, les références citées sont la documentation de l’enchaînement des agents et du traçage des exécutions. Les capacités et règles pouvant évoluer, vérifiez-les dans ces documents avant de déployer le processus.
Le flux complet relie des artefacts vérifiables, pas seulement des agents
>L’automatisation ne consiste pas à lancer plusieurs agents sur un même prompt. Elle exige une suite de transmissions explicites : une demande devient une spécification, la spécification devient un changement isolé, le changement est vérifié, puis les éléments probants accompagnent la demande de revue.
Le modèle ci-dessous comporte cinq étapes de travail et quatre responsabilités distinctes. C’est une architecture de référence, pas une mesure de productivité ni la promesse qu’un outil donné implémente ces rôles automatiquement.
| Étape | Entrée | Responsable principal | Sortie et condition de passage |
|---|---|---|---|
| Analyse | Demande, contexte du dépôt | Coordinateur | Critères d’acceptation et tâches sans ambiguïté |
| Implémentation | Tâche assignée, limites de fichiers | Agent de code | Diff et compte rendu des choix |
| Vérification | Diff, consignes et tests du projet | Agent de test | Résultats observés, échecs classés |
| Préparation de la revue | Changement vérifié | Coordinateur | Résumé, preuves, limites et branche cible |
| Décision | Pull Request et contrôles | Relecteur humain | Demande de correction, approbation ou refus |
Le coordinateur transforme la demande en tâches et surveille les dépendances ; l’agent d’implémentation ne dépasse pas son mandat ; l’agent de test vérifie le comportement prévu et rapporte les résultats sans les embellir ; le relecteur humain examine le changement et décide s’il peut être fusionné. La documentation de l’enchaînement des agents décrit un mécanisme de transmission entre agents, tandis que la documentation du traçage des exécutions indique comment examiner les événements d’une exécution. Ces mécanismes ne remplacent ni la définition des responsabilités ni l’évaluation du résultat.
Une tâche convient à l’automatisation lorsque son périmètre est borné, que les modifications attendues sont localisables et qu’un résultat peut être vérifié. Une évolution qui modifie les permissions, touche des données sensibles ou change un comportement critique doit comporter un point d’arrêt explicite : aucune fusion ni action irréversible sans confirmation humaine.
Point de contrôle : si le succès dépend d’une préférence implicite — par exemple « rendre l’interface plus agréable » sans exemple ni règle vérifiable — l’agent ne peut pas déduire de façon fiable la décision attendue. Faites préciser la demande avant l’exécution.
Étape 1 : convertir l’analyse des besoins en tâches acceptables
>Une spécification exploitable doit décrire le résultat, pas dicter seulement une solution technique. Pour un exemple limité, supposons une demande visant à ajouter un filtre d’état à une liste de tâches. L’agent ne devrait pas commencer par modifier l’interface : il lui faut connaître les états disponibles, le comportement du filtre et les cas où la liste est vide.
Consignez ces champs dans le ticket ou dans le contexte transmis au coordinateur :
- Résultat attendu : ce que l’utilisateur doit pouvoir faire et observer.
- Périmètre : composants et fichiers connus, ainsi que les zones exclues.
- Contraintes : conventions existantes, compatibilité, dépendances et règles de sécurité.
- Critères d’acceptation : comportements que l’équipe pourra vérifier.
- Dépendances : données, API, composants ou décisions nécessaires avant de commencer.
- Incertitudes : questions auxquelles un agent n’est pas autorisé à répondre par supposition.
Pour l’exemple du filtre, les tâches peuvent être séparées en inspection du composant de liste, implémentation du contrôle, vérification des états d’affichage et revue du changement. L’inspection précède l’implémentation si le nom des états ou l’organisation du composant n’est pas connu ; le test dépend ensuite du comportement convenu. Le coordinateur indique ce qui constitue une fin acceptable, plutôt que de transmettre une formule vague comme « ajouter le filtre ».
| Élément de la demande | Exemple de spécification | Preuve attendue |
|---|---|---|
| Comportement | La liste peut être limitée à un état choisi | Résultat observable dans l’interface |
| Cas limite | Aucun élément ne correspond au filtre | État vide cohérent avec les règles du projet |
| Périmètre | Composant de liste et tests associés | Diff limité aux zones autorisées |
| Dépendance | Valeurs d’état déjà définies par le projet | Référence au modèle existant |
| Validation | Les comportements retenus sont couverts par les tests pertinents | Sortie réelle des tests et revue du diff |
Cette table sert à détecter un problème avant la génération. Si les états ne sont pas documentés, si la demande contredit une règle du dépôt ou si aucun critère ne permet de distinguer une implémentation correcte d’une implémentation incorrecte, le coordinateur suspend le travail et pose une question. Produire du code malgré ces lacunes transforme une incertitude produit en dette de revue.
Étape 2 : répartir les rôles et rendre le contexte transmissible
>Plusieurs agents ne doivent pas recevoir simultanément la consigne générale de « réaliser la fonctionnalité ». Cette formulation invite aux modifications en double et rend difficile l’attribution d’un résultat. Donnez à chaque rôle une responsabilité, un espace de travail autorisé et un artefact de sortie.
Le contexte partagé peut rester simple : identifiant de tâche, résumé de la demande, critères d’acceptation, dépendances, fichiers autorisés, état courant et dernière décision humaine. L’agent d’implémentation renvoie un diff ou une référence de changement, une liste de fichiers touchés, ses choix importants et les éléments non résolus. L’agent de test reçoit ces éléments avec les critères, pas seulement un message déclarant que le code est terminé.
Une trace d’exécution permet de retrouver quel rôle a reçu le contexte et à quelle étape le processus a échoué ; la documentation officielle du traçage des exécutions constitue la référence pour les mécanismes documentés. Pour une équipe, conservez également un journal de tâche compréhensible par une personne : un historique technique seul ne précise pas toujours pourquoi une décision a été prise.
| Rôle | Peut faire | Ne doit pas décider seul | Passage de relais |
|---|---|---|---|
| Coordinateur | Découper, attribuer, suspendre et résumer | Changer l’exigence produit | Tâches, dépendances, questions ouvertes |
| Implémentation | Modifier les zones assignées et expliquer le diff | Élargir le périmètre ou fusionner | Fichiers modifiés, décisions, limites |
| Test | Choisir les tests pertinents selon le projet et rapporter les sorties | Déclarer correcte une fonctionnalité non vérifiée | Commandes réellement lancées, résultats, échecs |
| Revue humaine | Évaluer le risque, demander une correction, approuver ou refuser | Se fier à un résumé sans lire le diff | Décision documentée |
En cas de délai dépassé, d’échec d’outil ou de conflit de modifications, évitez une relance aveugle. Le coordinateur vérifie d’abord l’état du dépôt et le dernier artefact produit ; il peut ensuite relancer une tâche idempotente avec le contexte manquant, la réattribuer ou la remonter à une personne. Si deux agents proposent des solutions incompatibles, une décision sur la spécification précède toute fusion de leurs changements.
Étape 3 : isoler la génération de code et contrôler le diff
>Avant l’écriture, préparez un espace de travail propre et vérifiez la branche de départ. Utilisez une branche dédiée ou un autre mécanisme d’isolation déjà accepté dans le projet ; la méthode exacte dépend de l’organisation du dépôt. L’agent doit recevoir les fichiers qu’il peut modifier, les contraintes et les critères d’acceptation, mais pas une autorisation générale de réorganiser le code.
Après génération, demandez un compte rendu qui nomme les fichiers modifiés, explique les décisions de conception et signale les questions non résolues. Le coordinateur compare ensuite ce compte rendu au diff réel. Une modification hors périmètre, une refactorisation non demandée, un fichier généré inattendu ou une exigence sans preuve doit être traité comme un écart, même si le code paraît plausible.
Pour l’exemple du filtre, le contrôle consiste à vérifier que le changement correspond au comportement spécifié, qu’il réutilise les valeurs d’état existantes et qu’il ne remplace pas au passage la structure entière de la liste. Le diff est une preuve de ce qui a changé ; il ne prouve pas à lui seul que le résultat fonctionne.
Étape 4 : sélectionner les tests selon le projet et fermer la boucle d’échec
>Ne transmettez pas à l’agent une commande de test supposée universelle. Il doit examiner les instructions du dépôt, les scripts réellement disponibles et les tests pertinents pour les fichiers modifiés. Le parcours dépend de la structure du projet : une vérification ciblée peut être utile au départ, puis des contrôles plus larges sont nécessaires lorsque le changement touche des composants partagés ou des contrats communs.
Le rapport de test doit distinguer les contrôles exécutés, ceux qui n’ont pas été lancés, les résultats observés et les limites de couverture. En cas d’échec, transmettez à l’agent d’implémentation le message utile, le contexte de l’échec et le critère d’acceptation concerné. La correction doit rester limitée à l’écart constaté. L’agent de test relance ensuite les vérifications pertinentes ; un résultat précédent ne valide pas une modification ultérieure.
| Situation | Action de l’agent de test | Décision de coordination |
|---|---|---|
| Échec directement lié au changement | Fournir la sortie et localiser le comportement en cause | Autoriser une correction ciblée, puis refaire les vérifications |
| Échec sans lien évident | Reproduire et comparer avec l’état de départ si possible | Suspendre l’attribution automatique de la cause |
| Test non disponible ou dépendance absente | Signaler ce qui n’a pas pu être vérifié | Demander une décision humaine ou une autre preuve |
| Tests réussis, mais critère non couvert | Nommer le risque restant | Ajouter une vérification ou l’exposer dans la Pull Request |
Un test réussi signifie que les contrôles exécutés n’ont pas détecté l’écart recherché dans leur périmètre ; il ne garantit pas l’absence de défaut. Il faut encore comparer la couverture aux critères d’acceptation et signaler les risques qui n’ont pas pu être vérifiés. Cette distinction empêche le résumé automatique de présenter « les tests passent » comme une preuve absolue de correction.
Étape 5 : préparer la GitHub Pull Request sans automatiser la décision
>La préparation de la Pull Request commence lorsque le diff a été examiné et que les résultats de test sont disponibles. Le résumé doit expliquer l’objectif, les changements, les critères satisfaits, les vérifications réellement exécutées et les limites connues. N’incluez pas une réussite que le journal ne permet pas de confirmer.
Avant de créer la demande, vérifiez la branche source et la branche cible, les commits inclus, l’absence de changements étrangers à la tâche et les contrôles automatiques attendus. GitHub documente la création d’une Pull Request ; les exigences de revue ou de vérification peuvent être encadrées par les règles des branches protégées. Ces documents décrivent les mécanismes de la plateforme, mais le réglage effectif dépend du dépôt et des permissions accordées.
| Option d’automatisation | Atout | Risque ou coût caché | Décision conseillée |
|---|---|---|---|
| Préparer un brouillon de Pull Request | Les preuves et questions sont visibles tôt | Un brouillon peut donner une impression trompeuse d’achèvement | À privilégier si une revue précoce aide à cadrer le changement |
| Créer une Pull Request prête à la revue | Le travail vérifié arrive directement dans le flux de revue | Une mauvaise branche ou un rapport incomplet peut mobiliser les relecteurs | À réserver aux tâches dont les contrôles sont explicitement définis |
| Autoriser l’agent à fusionner | Réduit une étape manuelle | La décision devient difficile à reprendre en cas d’échec de contrôle ou de risque non identifié | À éviter pour les changements sensibles ; conserver l’approbation humaine |
La décision doit suivre le niveau de risque et les règles de l’équipe, pas le fait qu’un agent ait terminé ses étapes. La revue humaine vérifie notamment le diff, les critères d’acceptation, les tests, les permissions utilisées et les contrôles requis avant la fusion.
À ne pas confondre : la création d’une Pull Request, le passage des vérifications et l’autorisation de fusion sont des événements distincts. La disponibilité d’une action automatisée ne signifie pas que le dépôt l’autorise ni que le changement mérite d’être accepté.
Liste de contrôle avant revue et fusion
- Le diff correspond-il au périmètre demandé, sans fichiers ni refactorisations étrangères ?
- Chaque critère d’acceptation dispose-t-il d’une preuve ou d’une limite explicitement signalée ?
- Les tests annoncés ont-ils réellement été exécutés sur la version proposée ?
- Les échecs, les contrôles indisponibles et les risques non couverts sont-ils décrits ?
- La branche cible, les commits et les permissions du compte d’automatisation sont-ils conformes aux règles du dépôt ?
- Une personne habilitée a-t-elle pris la décision de revue et de fusion ?
Un parcours local peut être préférable pour une tâche courte, répétée et sans besoin d’environnement distant. En revanche, un poste local partagé avec d’autres travaux, une configuration difficile à reproduire ou une machine indisponible peut compliquer l’exécution et la vérification. Un environnement Mac distant ne règle pas les ambiguïtés de spécification, les défauts de tests ni les questions de permission, mais peut constituer une option lorsque l’équipe a besoin d’un espace de développement séparé ; les informations disponibles sont présentées sur la page location de Mac dans le cloud. Avant d’y exécuter du code ou de transmettre des données, vérifiez les conditions applicables et les règles de traitement des informations, notamment la politique de confidentialité.
La prochaine étape consiste à choisir une petite modification dont le résultat est vérifiable, à consigner les entrées et sorties de chaque rôle, puis à examiner où le processus s’est arrêté ou a demandé une correction humaine. Si l’exécution distante est nécessaire, comparez d’abord ce besoin à l’utilisation d’un poste local et aux contraintes du dépôt ; la location d’un Mac chez Zilmac peut être envisagée pour tester ce type de flux sans en faire une solution par défaut. Il est préférable de ne pas louer de machine dédiée si l’équipe a besoin d’une charge permanente et prévisible, ou si le travail dépend d’interfaces physiques disponibles uniquement sur place.
Questions fréquentes
Comment transformer une demande produit en tâches adaptées à plusieurs agents ?
Rédigez d’abord le résultat attendu, les fichiers ou composants concernés, les contraintes et des critères d’acceptation observables. Le coordinateur peut ensuite séparer le travail en tâches indépendantes, indiquer leurs dépendances et attribuer une seule zone de modification à chaque agent. Si le périmètre ou le comportement attendu reste ambigu, demandez une clarification avant toute génération de code.
Comment plusieurs agents peuvent-ils partager le contexte sans modifier les mêmes fichiers ?
Utilisez un état de tâche partagé qui contient la spécification, les décisions prises, les fichiers autorisés et le dernier résultat vérifié. Attribuez un propriétaire par tâche et faites passer les artefacts — diff, rapport de test ou question bloquante — au rôle suivant. Le partage de contexte ne signifie pas que tous les agents doivent écrire dans le même espace simultanément.
Que faire lorsqu’un test échoue après une modification générée par un agent ?
Transmettez à l’agent d’implémentation la commande réellement utilisée, la sortie complète utile, le test concerné et le résultat attendu. Demandez une hypothèse et une correction limitée, puis relancez les vérifications pertinentes dans le même environnement. Si l’échec révèle une exigence manquante ou une dépendance extérieure, suspendez la réparation automatique et demandez une décision humaine.
Comment préparer une GitHub Pull Request tout en gardant une validation humaine ?
Avant la création, rassemblez le résumé des changements, les critères d’acceptation satisfaits, les tests exécutés et les limites restantes. Vérifiez la branche cible, le diff, les contrôles automatiques et les permissions réellement accordées au compte utilisé. Une Pull Request peut être préparée automatiquement, mais la revue et la décision de fusion doivent rester conditionnées aux règles du dépôt et à l’approbation requise.
Donnez à vos workflows IA un Mac dédié dans le cloud
Avec Zilmac, louez un Mac mini M4 dédié sous macOS complet pour exécuter vos compilations et vos tests automatisés à distance.
Faites avancer vos tâches de développement en parallèle sur une machine adaptée aux pipelines d’intégration continue et aux charges de travail exigeantes. — Voir les options de forfait