---
title: "Dix dépôts, plusieurs agents et aucune frayeur : comment nous travaillons avec Claude Code"
description: "Une petite équipe, plusieurs sessions de Claude Code et un déploiement par jour : des règles, des hooks qui les appliquent, chaque erreur devenue un contrôle."
url: https://blablanote.com/fr/blog/comment-nous-travaillons-avec-claude-code/
lang: fr
author: Gorka Mendez
published: 2026-10-21
tags: engineering
translations:
  ca: https://blablanote.com/ca/blog/aixi-treballem-amb-claude-code/
  en: https://blablanote.com/blog/how-we-work-with-claude-code/
  es: https://blablanote.com/es/blog/asi-trabajamos-con-claude-code/
  eu: https://blablanote.com/eu/blog/horrela-lan-egiten-dugu-claude-coderekin/
  gl: https://blablanote.com/gl/blog/asi-traballamos-con-claude-code/
---

# Dix dépôts, plusieurs agents et aucune frayeur : comment nous travaillons avec Claude Code

BlaBlaNote est une petite équipe avec dix dépôts : l'application, la plateforme d'événements, le moteur de matchmaking, le site web, la communauté, l'extension de navigateur, la documentation, les tests de bout en bout, la conformité légale, et un dernier qui ne déploie rien. Tout le code est écrit par Claude Code, souvent avec plusieurs sessions en même temps, parfois deux sur le même dépôt. Et nous déployons en production plusieurs fois par jour.

Avec une équipe comme celle-là, l'essentiel est que rien ne casse pendant qu'on écrit autant de code.

Un agent ne se fatigue pas, mais il commence chaque session sans se souvenir de ce qui s'est passé la semaine précédente. Une personne, elle, s'en souvient, pendant quelques semaines. C'est pourquoi la règle qui organise tout est simple à dire et bien plus difficile à tenir : **aucune règle importante ne peut dépendre du fait que quelqu'un s'en souvienne.**

Cet article raconte comment nous faisons. Il y a trois pièces : un dépôt qui garde les règles, des hooks qui les font respecter et une boucle qui transforme chaque erreur en une nouvelle vérification.

## Le dépôt qui ne déploie rien

Le dixième dépôt s'appelle *planning*. Il ne contient aucun code produit. Il garde le protocole de travail que lisent toutes les sessions, les plans de chaque chantier ouvert, les hooks, et les registres d'incidents et de constats.

Il vit à part pour une raison pratique. Si le protocole était dans l'application, chaque branche aurait sa propre copie et chaque copie partirait de son côté. Séparé, il survit à n'importe quelle branche et à n'importe quelle copie de travail, et toutes les sessions démarrent depuis lui, avec les dépôts produit à côté.

**Les plans portent leur état en tête.** Chaque plan commence par une ligne d'état (`Statut :`) et un index les regroupe par chantier et indique lequel fait foi dans chacun. Une seule commande sort l'état de tous : avant de considérer une chose comme en attente ou comme faite, on peut vérifier en quelques secondes. Un nouveau plan sans sa ligne d'état ou sans son entrée dans l'index déclenche un avertissement automatique.

(Image: Le dépôt des règles, avec le protocole, les plans, les hooks et les incidents, à côté des neuf dépôts produit. En dessous, une commande qui liste la ligne d'état de chaque plan : livré, en cours ou remplacé.)

**Le protocole a un budget.** Il est plafonné à 30 000 octets, et le dépasser déclenche un avertissement. Cela ressemble à un détail, et c'est pourtant le plus important de tout le dépôt. Chaque session de Claude Code charge le protocole entier dans son contexte, et un protocole qui grossit sans limite finit comme n'importe quel long manuel : personne ne le lit vraiment. La règle d'élagage est la suivante : tout avertissement qui a déjà une machine derrière lui se réduit à une ligne qui dit ce qui se passe et qui le surveille. L'histoire complète (date, symptôme, cause, mesures) part dans un fichier d'incidents qu'aucune session ne charge.

## Une tâche, du début à la fin

(Image: Animation de trois tâches qui parcourent huit stations : session, worktree, test, clôture, e2e, CI, merge et production. Une tâche formate son code à l'édition ; une autre tente un push direct sur main et la garde le bloque ; une autre lance la suite e2e parce qu'elle passe d'un dépôt à l'autre, puis sort en rouge en CI ; une quatrième scène montre une tentative d'écriture en production bloquée, et la dernière tâche se heurte au merge à une autre du même dépôt, fait un rebase et passe.)

Voici le chemin d'une tâche jusqu'à la production.

**1. Démarrer avec tout à jour.** Au début de la session, un hook récupère les changements des dix dépôts et compare chacun avec son dépôt distant et avec ce qui est installé. Lire du vieux code ne produit aucune erreur : ni à la lecture, ni en regardant son historique. Le hook passe aussi en revue chaque copie de travail et signale ce qui échouerait sans rien dire, comme une configuration qui pointe vers l'environnement d'une autre copie ou des ressources non construites. Ce sont des pannes qui finissent en tests verts qui ne prouvent rien, ou en e-mails envoyés au mauvais endroit.

(Image: La sortie du hook de démarrage : les dix dépôts à jour et trois avertissements sur des copies dont les pannes ne produiraient aucune erreur, chacun avec sa conséquence, plus la liste des catégories de constats à automatiser.)

**2. Chaque tâche dans sa propre copie.** On ne travaille jamais dans le checkout principal, parce que d'autres sessions tournent en parallèle. Chaque tâche crée sa copie de travail (un *worktree* git) avec sa branche, ses ports et sa propre base de données. Les ports sont attribués par un script et personne ne les tape à la main. Deux sessions sur la même base de données s'effaceraient mutuellement leurs données de test, et le feraient en silence.

(Image: Le checkout principal, où personne ne travaille, et trois copies en parallèle, chacune avec sa branche, ses ports et sa propre base de données.)

**3. D'abord le test qui échoue.** Côté backend comme côté interface. Un bug commence toujours par un test qui le reproduit et qui échoue avant de toucher quoi que ce soit. Ensuite vient le code minimal qui le fait passer au vert.

**4. La clôture obligatoire de chaque dépôt.** Chaque dépôt a sa liste de clôture, et elle n'est ni optionnelle ni fonction de la taille du changement. Dans l'application, ce sont huit étapes fixes : formatage, analyse statique, les tests du changement, simplification, revue, la suite complète, vérifier que ce qu'un autre dépôt affirme sur l'application est toujours vrai, et mettre à jour la documentation. Plus deux qui dépendent de ce que touche la tâche : si un écran change, on le capture sur mobile et sur ordinateur et on le regarde ; si un prompt change, on lance son évaluation contre le vrai modèle. Dans la plateforme d'événements, il y en a onze, dont le lint du frontend, ses tests unitaires, des tests de mutation et un test de navigateur quand le changement a une interface.

(Image: Les deux listes de clôture côte à côte : celle de l'application, avec huit étapes fixes et deux qui dépendent du changement, et celle de la plateforme d'événements, avec onze.)

**La revue est faite par un autre agent, sans le contexte de celui qui a écrit le code.** C'est un sous-agent qui reçoit un paquet avec le diff, les règles du dépôt et le résultat des tests, et qui renvoie des constats avec leur gravité. Ce n'est jamais la session qui a écrit le code qui le relit, parce que celui qui écrit ne voit pas ses propres angles morts. Et la CI ne refait pas la revue : ce que le relecteur ne voit pas, personne ne le voit.

(Image: La session autrice remet un paquet avec le diff, les règles, la mutation sur le diff et les types de constats à un relecteur sans contexte, qui renvoie des constats de gravité haute, moyenne et basse.)

**5. Des tests entre dépôts, seulement quand il le faut.** Chaque dépôt teste sa partie avec une doublure de l'autre côté. Cela veut dire que deux dépôts peuvent passer au vert avec le contrat entre eux cassé. C'est pour ça qu'il existe un dépôt de tests de bout en bout avec une table des coutures : si tu touches le message que la plateforme d'événements envoie à l'application, tel flux casse et tel test tourne. Si le changement tombe sur une couture, la tâche met ce test à jour et le lance, ou dit explicitement qu'elle n'a pas pu le lancer. S'il n'en touche aucune, on passe.

(Image: La plateforme d'événements envoie un champ appelé début et l'application en attend un appelé date. Les tests de chaque côté passent avec une doublure de l'autre ; la suite de bout en bout lance les deux et détecte que l'événement arrive sans date. En dessous, une table qui décide quand elle tourne.)

**6. La PR.** Elle s'ouvre en brouillon, lance les tests répartis en quatre lots en parallèle et, quand elle est au vert, passe en prête. En rouge, on ne merge pas, et « en local ça passait » n'est pas une raison.

**7. Le merge.** C'est ici que se trouve la garde la plus travaillée de toutes, et elle a sa propre section plus bas.

**8. La production.** Merger, c'est publier : le merge sur main déploie tout seul. La tâche est close quand elle est sur main, déployée au vert, et qu'un script a ramassé la copie de travail, sa base de données et ses branches.

## Hooks : des règles qui s'appliquent toutes seules

Claude Code permet de configurer des *hooks* : des scripts qui s'exécutent à des moments fixes (au démarrage d'une session, après chaque édition, avant chaque commande de terminal) et qui peuvent bloquer ce qui va se passer. Pour nous, c'est la différence entre une règle écrite et une règle respectée.

Nous en avons quatre :

- **Au démarrage**, celui qui met les dépôts à jour et signale les pannes silencieuses.
- **Après chaque édition**, celui qui formate le code et passe le lint. Si l'édition touche une des gardes, il lance en plus le test des gardes.
- **Avant chaque commande de terminal**, une garde qui bloque le push direct sur main dans les dépôts produit, toute façon de détruire la base de données de développement hors d'une copie de travail, et les commandes qui balaieraient du travail non sauvegardé. Cette dernière ne bloque que s'il y a vraiment quelque chose à perdre.
- **Avant chaque commande de terminal**, une autre garde qui met la production en lecture seule. Il n'en sort que des agrégats (combien, depuis quand) et jamais de champs avec des données personnelles.

(Image: Les quatre hooks sur la ligne de temps d'une session : au démarrage, après chaque édition et deux avant chaque commande. En dessous, un terminal où la garde bloque un push direct sur main et un merge avec des changements en commun.)

On peut modifier des données de production, mais par un seul chemin : une commande qui, par défaut, se contente d'indiquer ce qu'elle ferait et n'agit qu'avec un drapeau explicite. Elle arrive dans une PR, elle est relue, puis déployée. Cela coûte quelques heures de plus, mais laisse une trace dans git et peut être annulé. Une console ouverte sur la production n'existe que dans l'historique d'une conversation.

(Image: Ce qui sort de la production et ce qui n'en sort pas : oui le nombre d'enregistrements, les dates, les états et les identifiants ; non les noms, les e-mails, les lignes entières ni les écritures. Et le chemin pour modifier des données : commande qui informe par défaut, PR, revue, déploiement et drapeau.)

Les gardes suivent quelques principes que nous avons appris à force de nous tromper :

**Toujours une liste blanche.** Une garde qui énumère ce qui est dangereux te protège de l'erreur d'hier. Une garde qui énumère ce qui est permis te protège aussi de celle de demain. Nous appliquons la même chose dans le code, par exemple dans la vérification qui décide si une commande peut effacer des données :

(Image: Un tableau avec cinq valeurs de l'environnement : production, vide, mal orthographié, un environnement créé plus tard et local. La liste noire ne s'arrête qu'en production et détruit dans les trois cas bizarres ; la liste blanche s'arrête partout sauf en local.)

La liste noire laisse passer, et détruit, si la variable d'environnement arrive vide, mal orthographiée ou avec le nom d'un environnement créé plus tard. La blanche traite comme production tout ce qu'elle ne reconnaît pas.

**Si elle ne peut pas vérifier, elle bloque.** S'il manque un outil à une garde, si elle n'a pas de réseau ou si la machine est si chargée qu'elle n'arrive pas à vérifier à temps, elle ne laisse pas passer. Elle bloque et dit pourquoi.

**Une garde qui gêne finit désactivée.** Un faux positif coûte plus cher qu'il n'y paraît : la troisième fois qu'une garde bloque quelque chose d'inoffensif, quelqu'un cherche le moyen de l'éteindre. C'est pour ça que le test des gardes commence par les faux positifs.

**Les gardes ont aussi des tests.** Aujourd'hui, il y a 326 cas, chacun avec son entrée et le résultat attendu. En plus, chaque garde a une mutation : une version cassée exprès que le test doit détecter. Si une mutation survit, il manque un cas.

**Chaque hook doit mériter sa place.** Nous n'automatisons une panne que si elle remplit deux conditions : elle est silencieuse (pas d'erreur, ou l'erreur parle d'autre chose) et une machine peut la détecter. C'est pour ça qu'il n'y a pas de hook qui lance la suite entière à chaque édition, ni de hook qui vérifie la clôture à la fin de chaque session. Le premier coûterait des minutes à chaque changement. Le second aurait tant de faux positifs que nous le désactiverions en une semaine.

## Le vert expire

La garde du merge mérite sa propre section, parce qu'elle résout le problème le plus typique du travail avec plusieurs agents à la fois.

Une PR au vert est au vert par rapport au main qui existait quand ses tests ont tourné. Si entre-temps une autre tâche merge en dessous, ce vert ne vaut plus rien, et GitHub ne relance pas les tests de lui-même. Avec plusieurs sessions en parallèle, cela arrive tous les jours.

Alors, avant chaque merge, la garde décide. Elle vérifie que la PR est au vert et que ce qui va être mergé est exactement ce qui a été testé. Puis elle regarde si main a avancé. Si ce qui est entré et ce que tu veux merger touchent des fichiers différents, elle laisse passer. S'ils se croisent, ou si l'un des deux change quelque chose qui modifie l'environnement des tests (dépendances, configuration, migrations de base de données, routes), elle bloque. Il faut alors faire un rebase, repasser la CI et réessayer.

(Image: Deux cas : avec des fichiers différents, la porte laisse merger ; avec des fichiers en commun, elle bloque et oblige à faire un rebase et à repasser la CI. Et elle bloque toujours si l'un des deux touche aux dépendances, à la configuration, aux migrations ou aux routes.)

C'est le cas qu'on voit dans l'animation : deux tâches sur le même dépôt, la première passe, et la seconde trouve la porte fermée jusqu'à ce qu'elle se mette à jour.

## Chaque minute de CI compte

Les minutes de GitHub Actions se paient, et avec plusieurs sessions qui poussent en même temps, elles partent très vite. Il nous est arrivé d'en manquer en milieu de mois. Depuis, chaque pièce de la CI doit justifier ce qu'elle coûte, exactement comme les gardes.

**La PR naît en brouillon et ne passe en prête que quand nous sommes sûrs.** En brouillon, les tests tournent, mais rien n'est déployé. Avant, chaque push déployait sur l'environnement de test : environ 8 minutes par déploiement, et presque deux déploiements jetés par PR, parce que le push suivant les rendait obsolètes. Maintenant, la PR passe en prête seulement quand la clôture est faite et que les tests du brouillon sont au vert. C'est à ce moment-là, et seulement là, qu'elle déploie.

**Un arbre déjà validé n'est pas retesté.** Au passage en prête, GitHub relançait la suite entière sur le même commit que le brouillon venait de valider. Et au merge, encore une fois, sur un nouveau commit au contenu exactement identique. Maintenant, la première étape de la CI regarde le contenu exact qu'elle va tester, quels que soient la branche ou le commit, et demande s'il a déjà passé tous les tests. Si la réponse est oui, la suite est sautée, et ce sont environ 24 minutes de runner à chaque fois. Si main a changé en dessous, l'arbre est différent et les tests tournent, comme il se doit.

(Image: Un tableau avec quatre moments : le push en brouillon lance les quatre lots sans déployer ; au passage en prête et au merge, l'arbre est déjà testé, les tests sont sautés, environ 24 minutes sont économisées, et on déploie en test puis en production ; si main a bougé, l'arbre est différent et les tests tournent. En dessous, avant et maintenant : un déploiement par push contre un seul au passage en prête.)

**Nous n'utilisons pas la file de merge de GitHub.** Elle réglerait la course entre des PR qui touchent la même chose, mais elle relance la CI pour chaque PR qui entre dans la file. Et l'alternative habituelle, exiger que la branche soit à jour avec main, impose un rebase et une suite complète chaque fois que main bouge, même si ce qui est entré n'a rien à voir. La porte décrite plus haut fait le même travail en ne demandant que le nécessaire : si les changements ne se croisent pas, le vert vaut ; s'ils se croisent, un tour de plus.

**La mutation, seulement sur ce qui change.** Les tests de mutation introduisent exprès de petites erreurs et vérifient si les tests s'en aperçoivent. Dans l'application, nous mutions les fichiers entiers touchés par chaque changement, presque dix minutes par tâche. Désormais, chaque tâche ne mute que ce que son changement ajoute : elle retire chaque nouvelle condition, une par une, et vérifie qu'un test tombe. Cela prend quelques secondes. Nous avons aussi coupé la mesure hebdomadaire de tout le code : elle coûtait des milliers de minutes de CI par mois et allait rarement jusqu'au bout. Dans la plateforme d'événements, où muter les fichiers touchés coûte moins d'une minute, ce passage reste en plus dans la clôture.

**Et ce qui peut casser, mieux vaut le casser en local.** Chaque push en rouge, c'est un pipeline complet de plus. La clôture obligatoire existe aussi pour ça : ce qu'elle trouve en local ne coûte pas une seule minute de CI.

## La boucle qui apprend

Tout ce qui précède évite les erreurs que nous connaissons déjà. Mais celles qui font le plus mal sont les nouvelles, et pour celles-là il y a une boucle à deux entrées.

**Les constats des revues.** Chaque constat du relecteur de clôture est noté dans un registre avec une catégorie : « test qui ne prouve pas ce qu'il dit », « panne qui passe en silence », « traduction qui change le sens ». La règle : une catégorie qui apparaît dans deux PR et n'a pas encore de vérification automatique en reçoit une la semaine même. Cette vérification doit détecter la catégorie dans n'importe quel diff ; répéter le test du cas qui l'a révélée ne suffit pas.

Soyons honnêtes avec les chiffres. Nous avons 119 PR enregistrées, 49 catégories distinctes, et seulement 4 sont déjà devenues une vérification automatique. Écrire une vérification qui voit une catégorie entière sans faux positifs est difficile, et une mauvaise vérification est pire que pas de vérification du tout. Ce qui est automatisé, en revanche, c'est le rappel : chaque session démarre avec la liste des catégories en attente sous les yeux.

(Image: Un extrait du registre avec trois catégories : une déjà automatique, une autre vue dans deux PR qu'il faut convertir cette semaine, et une dernière vue une seule fois. En dessous, une barre : 4 catégories sur 49 converties.)

**Les incidents.** Malgré tout cela, les choses continuent de casser. Presque toujours pour l'une de ces raisons :

- **Ce qui ne produit pas d'erreur.** Une configuration qui pointe vers le mauvais environnement, un test qui passe sans rien prouver ou une donnée calculée sur une source qui n'existe plus. Tout au vert, et tout faux.
- **Deux changements corrects qui, ensemble, ne le sont pas.** Chaque PR passe ses tests séparément et le problème n'apparaît que lorsqu'elles cohabitent dans main.
- **Ce qui n'arrive que dans un environnement.** Les tests locaux et la CI utilisent des bases de données différentes, et ce que l'une tolère, l'autre le rejette. Ou une variable que personne n'a fixée et qui, sur ta machine, vaut autre chose.
- **Les commandes dont la moitié dangereuse est celle qui ne demande rien.** Une commande qui efface quand tu la lances sans arguments est un piège qui attend quelqu'un de pressé. C'est pourquoi toute commande qui efface, tronque ou écrase des données informe par défaut et n'agit qu'avec un drapeau explicite.

(Image: Un terminal : sans arguments, la commande indique qu'elle effacerait 312 fichiers et n'efface rien ; avec le drapeau, elle les efface et laisse la liste dans le journal.)

Chaque incident est noté avec sa date, son symptôme, sa cause et les mesures prises. Si une machine peut le détecter, il devient une garde avec ses cas de test et sa mutation, et il n'en reste qu'une ligne dans le protocole. Sinon, l'avertissement reste écrit et explique pourquoi il n'a pas de machine derrière lui.

(Image: Le parcours d'un incident : registre, la question de savoir si une machine le détecte, et les deux sorties : nouvelle garde avec ses cas de test et sa mutation, ou un avertissement écrit avec son pourquoi.)

## Est-ce une software factory ?

Aujourd'hui, tout le monde parle de *software factories* : des agents qui reçoivent une idée d'un côté et livrent du logiciel terminé de l'autre. La question est inévitable, et la réponse courte, c'est : en partie seulement.

Certaines choses relèvent bien de l'usine. Il y a une ligne avec des stations fixes, et chaque dépôt a la sienne. Les gardes font ce que font, dans une usine, les dispositifs anti-erreur : elles rendent la panne impossible. La ligne s'arrête toute seule quand quelque chose va mal, avec une CI au rouge ou un merge qui en heurte un autre. Et il y a de l'amélioration continue, parce que chaque erreur qui se répète doit finir transformée en vérification.

D'autres, non. Ce qu'on construit, quand une tâche commence et si elle est bien posée, c'est toujours nous qui le décidons. Il n'y a pas de file qui se traite toute seule, du backlog jusqu'à la production. Et l'amélioration continue est en retard, comme le montrent ces 4 sur 49.

C'est pourquoi nous préférons un autre nom pour ce que nous avons construit : **le contrôle qualité d'une usine logicielle**. Les agents produisent et la ligne décide de ce qui passe.

## Ce que nous en retenons

- **Le contexte est un budget.** Un protocole que personne ne lit ne protège de rien. Mieux vaut une ligne avec une machine derrière qu'un paragraphe bien écrit.
- **Qui écrit ne relit pas.** Un relecteur sans contexte trouve ce que l'auteur ne peut plus voir, qu'il s'agisse d'une personne ou d'un agent.
- **Les machines avant la mémoire.** Tout ce qui peut se vérifier se vérifie tout seul, et tout ce qui ne le peut pas s'écrit avec son pourquoi.
- **Tout ne mérite pas une machine.** Une vérification qui coûte des minutes à chaque changement, ou qui gêne plus qu'elle ne protège, finit désactivée. Chaque pièce doit se rembourser par le temps qu'elle fait gagner.

Travailler ainsi nous rend sereins. La plupart de ce qui pourrait mal tourner s'arrête avant d'arriver en production, et ce qui y arrive laisse quelque chose d'appris pour la prochaine fois.

Si toi aussi tu travailles avec des agents et que tu veux comparer vos notes, écris-nous. Nous adorons parler de ça.
