Logo

Confier à l’IA la prise en charge des tickets, les correctifs et les demandes de fusion : notre pratique de GitLab

avatar Jade 21 Nov 2026

Une IA sait corriger un bug. Mais si deux machines repèrent le même bug, laquelle s’en charge ? Et qui décide si le correctif peut rejoindre la branche principale ?

Voici notre fonctionnement en production. Chaque tâche commence par un ticket GitLab. L’IA de chaque collègue relève périodiquement les tickets qui lui sont attribués, applique un correctif, le relit et ouvre une demande de fusion (MR). L’IA du côté de la relecture peut effectuer une vérification indépendante. Une personne décide de fusionner ou non.

Vue d’ensemble

Traits pleins : parcours principal ; pointillés : retours, boucles et chemins secondaires. Les couleurs distinguent cinq étapes : 🟡 création → 🔵 centralisation → 🟣 exécution par l’IA → 🩵 relecture croisée par l’IA → ⚪ validation humaine.

Schéma du processus de collaboration

Les personnes décrivent le problème, valident le résultat et fusionnent. Entre les deux, les agents locaux relèvent les tickets, les prennent en charge, analysent, corrigent et répondent.

Une machine à états pour les tickets

Les étiquettes GitLab jouent le rôle de machine à états.

États et transitions des tickets

Le paramètre labels de PUT /projects/:id/issues/:iid remplace toutes les étiquettes : il faut renvoyer celles à conserver. En cours de traitement ou de relecture, on ajoute ai-doing-〈agent-id〉 ou ai-reviewing-〈agent-id〉. On voit ainsi qui travaille sur quoi et si l’agent est disponible. Les étiquettes communes ai-doing et ai-reviewing servent aux vues d’ensemble.

Cinq choix de conception

1. Un seul support pour le travail : le ticket

Alertes, analyses de sécurité, contrôles qualité et demandes verbales deviennent des tickets. Nous clarifions d’abord, avec l’IA locale, la reproduction, le comportement attendu, le code concerné et les critères d’acceptation. L’IA rédige cinq rubriques (problème, reproduction, comportement attendu, indices, critères d’acceptation), puis crée le ticket via l’API :

curl -X POST -H "PRIVATE-TOKEN: $TOKEN" \
  "https://<你的GitLab>/api/v4/projects/<项目ID>/issues" \
  -d "title=修复 XX 问题" \
  -d "labels=ai-task" \
  -d "assignee_ids[]=<同事用户ID>" \
  -d "description=<按上述模板>"

L’agent qui le prend n’a pas à deviner la solution à partir d’une phrase : il dispose des indices et sait comment vérifier le résultat. Si le problème est déjà clair, on crée directement le ticket.

2. Identifier l’agent qui prend le ticket

Les tickets GitLab n’ont pas de verrou atomique. Deux agents peuvent prendre le même ticket. À l’initialisation, chacun reçoit un identifiant unique <utilisateur-GitLab>-<nom-court-machine>, par exemple zhangsan-mbp, qu’il inscrit dans une étiquette au moment de la prise en charge :

# 1) 占用检查:任一非空即不领新任务
curl ".../issues?labels=ai-doing-<agent-id>&state=opened"
curl ".../issues?labels=ai-reviewing-<agent-id>&state=opened"
# 2) 领取:打上带身份的 doing 标签
curl -X PUT ".../projects/<id>/issues/<iid>" -d "labels=ai-task,ai-doing,ai-doing-<agent-id>"
# 3) 回读确认无其他 agent 的 doing 标签;撞车则撤回自己的标签跳过本轮

Un agent ne garde qu’une tâche ouverte : un ticket en traitement ou en relecture bloque toute nouvelle prise. La limite vaut par agent et par machine, pas par personne. Deux ordinateurs donnent deux identités, chacune avec sa tâche. Vérifier avant et relire après réduit les collisions, sans rendre atomique la succession lecture-écriture.

3. Pas de MR sans autorelecture

Livrer, c’est corriger le problème sans en créer un autre. Avant d’ouvrir une MR, l’agent relit son diff sur cinq points : logique, cas limites et erreurs ; tests des parcours critiques et réussite de toute la suite ; sécurité (injections, défauts de contrôle d’accès, SSRF, désérialisation) ; conventions du projet ; vérification de chaque critère d’acceptation.

Le correctif introduit-il un nouveau problème ? Examiner chaque bloc du diff pour détecter une régression. Après les tests, reprendre les étapes de reproduction et vérifier les chemins d’appel concernés. Limiter le diff au correctif ; réserver les refactorisations sans rapport à une autre MR.

Corriger les problèmes relevés avant de livrer et publier la conclusion dans le ticket. Sans trace de l’autorelecture, la livraison est incomplète.

4. Faire relire par l’IA de l’autre côté

On oublie facilement les hypothèses faites en développant. L’agent de la personne chargée de la relecture relève les tickets labels=ai-reviewing et vérifie indépendamment leurs MR : régressions, effets de bord, sécurité, performances. Il ne tient pas l’autorelecture pour acquise. Chaque doute ouvre une discussion dans la MR ; l’agent auteur corrige, répond, regroupe en un commit et pousse à nouveau.

L’IA vérifie la justesse, la sécurité, les conventions et l’absence de nouveaux problèmes ; les arbitrages métier et d’architecture restent humains. La relecture croisée n’occupe pas le créneau de tâche de l’agent. Sans réponse, une personne reprend la main pour qu’une IA n’en bloque pas une autre.

En pratique, au lieu de lire tout le diff ligne à ligne, on consulte les conclusions, vérifie quelques points et tranche. Les revues sont nettement plus courtes.

5. Ouvrir la MR en poussant la branche

Les options de push GitLab permettent de pousser la branche et d’ouvrir la MR en une opération, avec la clé SSH locale :

git push origin ai/fix-42-xxx \
  -o merge_request.create \
  -o merge_request.target=<默认分支> \
  -o merge_request.title="fix: ..." \
  -o merge_request.description="Closes #42"

Un jeton de lecture-écriture des tickets, limité au dépôt central, suffit. L’écriture du code, le push et la MR reposent sur les droits SSH du développeur, sans jeton supplémentaire pour le dépôt de code. Pour un ticket dans A et un correctif dans B, utiliser Closes <group>/<repo-A>#42 : la fusion dans la branche par défaut de B ferme alors le ticket de A.

Six difficultés rencontrées

Ticket encore ouvert après fusion. Closes #N ne prend effet qu’à l’arrivée dans la branche par défaut. Si celle-ci est master et que la MR vise develop, il faut attendre l’intégration dans master ; le processus fonctionne normalement.

Disparition d’étiquettes. labels remplace la liste entière. Renvoyer aussi les anciennes étiquettes à conserver.

Historique morcelé. L’IA ajoutait un commit à chaque retour. Regrouper les corrections en un seul commit avec reset --soft et amend, puis repousser avec push --force-with-lease.

Worktrees orphelins. Dossiers isolés et branches locales survivaient aux tickets. Les ranger sous .worktrees/<agent-id>-<numéro-ticket>-<nom-court-dépôt>/, puis, à la clôture, exécuter git worktree remove et supprimer la branche déjà fusionnée.

Double prise de tâche. Un agent a pris deux tickets lors du même passage. Faire du contrôle d’occupation et de la limite d’une tâche des règles impératives, pas un accord verbal.

Jeton absent du shell non interactif. La tâche planifiée ne voyait pas la variable définie dans la configuration du shell. Utiliser un shell interactif (zsh -ic, par exemple) ou charger explicitement la configuration.

Liste de mise en service

• GitLab : activer les tickets et utiliser une version prenant en charge les options de push, comme les versions récentes.

• Étiquettes : ai-task (disponible), ai-doing (en cours/verrou), ai-reviewing (MR à relire), plus les catégories propres au projet.

• Un jeton de projet partagé : portée api, rôle Maintainer, réservé à la lecture, à la modification et aux commentaires des tickets. Surveiller son expiration et le renouveler.

• Une clé SSH par personne : autoriser le push vers les dépôts concernés. La création de MR utilise cette clé, sans jeton.

• Un agent local par personne : ZCode, Claude Code ou équivalent. Écrire les règles dans ses instructions persistantes (AGENTS.md / CLAUDE.md).

• Autorelecture obligatoire avant la MR, avec conclusion dans le ticket. Relecture croisée recommandée : l’agent de relecture surveille ai-reviewing.

• Protéger develop et master contre le push direct. L’IA passe par une MR ; la validation humaine est intégrée au processus.

• Préparer une fiche d’accueil : créer un ticket d’initialisation à partir d’un modèle et l’attribuer à la nouvelle recrue. Son agent le lit, vérifie sa configuration et mémorise les règles.

Mettre le guide directement dans ce premier ticket permet à l’agent de le trouver dès sa première relève. Il vérifie le jeton, la relève, les droits de push et la branche par défaut, enregistre les règles et répond dans le ticket. Ensuite, la prise en charge est automatique.

Ce qu’on ne confie pas à l’IA

• Refactorisations importantes : l’évaluation de l’impact et les arbitrages d’architecture reviennent aux personnes.

• Demandes floues : poser des questions dans le ticket, sans correction au jugé. Si le besoin reste obscur, reprendre et redéfinir la tâche.

• Identifiants ou opérations payantes : ne pas les déléguer et ne pas en inclure les détails dans le ticket.

• Filtrer les sources : mieux vaut peu de tickets précis que beaucoup de tickets ambigus. La qualité possible du correctif dépend déjà du ticket de départ.

Ce qui a changé

Le grand changement n’est pas la vitesse. Une tâche ne dépend plus de quelqu’un qui s’en souvient et la transmet : l’alerte devient ticket, le ticket atteint son destinataire, l’IA le traite et une personne tranche. Les branches protégées empêchent toute IA, même la vôtre, de modifier la branche principale sans revue. Les étiquettes d’identité rendent lisible le travail en parallèle sur plusieurs machines et entre plusieurs personnes.

Pour essayer, faites parcourir toute la chaîne à un vrai petit bug : ticket → prise en charge → correctif → MR → fusion → clôture automatique. Ajoutez ensuite les alertes de supervision et les analyses comme sources. Vos retours d’expérience sont les bienvenus.

中文 · English · Français · Deutsch · Español · Italiano

Contactez-nous