Comment exécuter les agents Claude Code en parallèle
Les connaissances générales soulignent que le multitâche doit être évité autant que possible, car il vous détourne de votre concentration. Cependant, avec l’essor des agents de codage, le travail parallèle est devenu une nécessité pour être efficace. Étant donné que les agents de codage peuvent fonctionner pendant une période plus longue, vous ne voulez pas perdre de temps à attendre qu’ils terminent. Au lieu de cela, vous souhaitez déclencher un agent et, pendant que cet agent travaille, vous souhaitez démarrer une autre tâche.
Cependant, démarrer des tâches en parallèle n’est pas simple. Vous devez prendre en compte de nombreuses considérations, telles que
- Comment exécuter plusieurs agents de codage dans le même référentiel ?
- Comment minimiser autant que possible le changement de contexte ?
- Comment gardez-vous une vue d’ensemble de tous vos agents en cours d’exécution ?
Je couvrirai tous ces points dans l’article d’aujourd’hui avec des détails sur la façon dont je gère ces problèmes et la solution que j’applique.
Pourquoi exécuter des agents en parallèle
Comme dans la plupart des autres articles que j’ai écrits, la principale raison des techniques que je décris dans l’article est de gagner du temps et d’être plus efficace en tant qu’ingénieur. Si vous souhaitez tirer le meilleur parti des agents de codage et de l’incroyable développement LLM auquel nous avons assisté ces dernières années, vous devez paralléliser votre travail.
Pour comprendre pourquoi, imaginons l’exemple inverse. Imaginons travailler uniquement de manière séquentielle, comme vous le faisiez habituellement lors de la programmation avant que les LLM ne soient disponibles. La programmation séquentielle avec des agents de codage ressemblerait à ceci :
- Trouvez la tâche que vous souhaitez effectuer
- Décrivez-le à un agent et faites un plan
- Démarrez l’agent et laissez-le s’exécuter. Attendez qu’il termine ou qu’il vous demande quelque chose
- Tester la mise en œuvre et itérer
La durée de chacune de ces tâches varie considérablement. Parfois, décrire la tâche à un agent et créer un plan prend le plus de temps, mais d’après mon expérience, la troisième étape est souvent une étape longue, en particulier pour les implémentations plus importantes telles que l’implémentation d’une nouvelle fonctionnalité ou la résolution d’un bug complexe.
Aujourd’hui, pour devenir plus efficaces, nous voulons éliminer les goulots d’étranglement. La troisième étape est un goulot d’étranglement que nous pouvons facilement minimiser ou éliminer. Il est très difficile d’être plus efficace dans les étapes un et deux. Vous devez le faire de manière séquentielle et y consacrer du temps. La quatrième étape est certainement quelque chose que vous pouvez rendre plus efficace, comme je l’ai décrit dans d’autres articles, tels que mon article sur Rendre Claude meilleur lors des implémentations ponctuelles. Je vais donc me concentrer sur l’étape 3 de cet article et comment la rendre plus efficace.
Comment exécuter des agents en parallèle
La solution simple pour rendre l’étape 3 plus efficace consiste à exécuter les agents en parallèle. Cela semble simple en théorie, mais c’est en réalité plus difficile à mettre en œuvre efficacement en pratique. La raison en est que l’exécution de tâches en parallèle présente un certain nombre de défis.
L’un des défis auxquels vous devez faire face est celui des agents qui écrivent du code les uns sur les autres. Vous ne voulez pas que les agents soient en compétition pour modifier un fichier spécifique ou tester leur propre implémentation. C’est donc un problème auquel vous devez faire face. Un autre problème auquel vous devez faire face est le fait que vous devez effectuer un changement de contexte. Ainsi, lorsque vous exécutez des tâches en parallèle, vous devez naturellement effectuer un changement de contexte entre les différentes tâches. Un aspect du changement de contexte est que vous devez d’abord décrire une tâche et comment la résoudre, puis décrire une autre tâche et comment la résoudre. Un autre aspect du changement de contexte est le moment où l’agent demande des commentaires, par exemple en vous posant des questions sur une implémentation ou en vous demandant de tester une implémentation. Ainsi, minimiser le changement de contexte est un autre aspect que je décrirai dans les dernières sections.
Exécuter plusieurs agents dans le même référentiel à l’aide d’arbres de travail
Le premier sujet que j’aborderai est de savoir comment exécuter plusieurs agents dans le même référentiel. La réponse simple à cette question est d’utiliser des arbres de travail.
Vous pouvez simplement demander à votre agent d’utiliser un arbre de travail, qui est une fonctionnalité git qui copie essentiellement l’intégralité de votre référentiel. Ainsi, différents agents peuvent travailler dans des référentiels complètement différents. Une fois qu’un agent a terminé son implémentation, il peut être fusionné dans la branche principale du référentiel principal, et de cette manière, vous pouvez avoir plusieurs agents travaillant dans le même référentiel sans conflits.
Cependant, il peut parfois exister des moyens plus simples de configurer l’arbre de travail. D’après mon expérience personnelle, j’ai eu des problèmes en utilisant Claude Code et en lui demandant de consulter un arbre de travail. Claude oubliait souvent d’extraire un nouvel arbre de travail, puis de commencer à travailler dans le référentiel principal. Puis, lorsque plusieurs agents faisaient la même chose, j’ai commencé à avoir des conflits. Heureusement, Claude Code a mis en place un –commande worktree que vous pouvez utiliser lors de la création de code cloud, comme ci-dessous
claude --worktreeSi vous utilisez cette commande dans un référentiel GitHub, Claude extraira automatiquement vers un nouvel arbre de travail étant donné le référentiel existant et stockera tous les arbres de travail dans un dossier Claude caché. Ceci est incroyablement utile pour deux raisons principales :
- Vous garantissez que vous utilisez toujours un worktree et que vos agents n’interféreront pas les uns avec les autres.
- Les worktrees sont stockés dans un dossier Claude caché et non dans votre dossier principal. Cela réduit considérablement la quantité de bruit dans votre structure de dossiers, ce qui facilite la navigation manuelle dans votre structure de dossiers si vous devez le faire.
Si vous utilisez un autre agent de codage, vous pouvez comprendre comment ils ont configuré les arbres de travail, car les arbres de travail deviennent de plus en plus une fonctionnalité attendue pour tout programme d’agent de codage, tel qu’un IDE comme Cursor ou une CLI comme Claude Code.
Minimiser le changement de contexte
Le deuxième aspect auquel vous devez penser lors de l’exécution d’agents de codage en parallèle est que vous devez minimiser le changement de contexte. J’ai mentionné plus tôt que cela se présentait principalement sous deux aspects. Un, lorsque vous démarrez après des tâches, et deux, lorsque vous interagissez avec l’agent pendant la tâche, par exemple lorsque l’agent vous pose des questions, ou lorsqu’il termine sa mise en œuvre et vous demande de la tester.
Il n’existe pas de solution simple pour simplement éliminer la commutation de contact, car le travail en parallèle implique intrinsèquement une commutation de contact. Cependant, je garde quelques points à l’esprit pour minimiser mes changements de contact.
La première chose que je garde à l’esprit est de toujours terminer ma tâche en cours avant de passer à une autre tâche. Cela semble très évident lorsque je le décris ; cependant, je souhaite fournir un exemple spécifique. Vous pouvez trouver l’exemple décrit dans le texte ci-dessous, mais je vais également montrer l’image pour vous permettre de mieux comprendre le concept juste en dessous.
Disons que vous devez accomplir deux tâches, A et B. La tâche A nécessite une interaction de cinq minutes de la part de l’utilisateur, tandis que la tâche B nécessite une interaction de deux minutes de la part de l’utilisateur. Après cette interaction, l’agent fonctionnera pendant dix minutes pour terminer la tâche. De plus, vous avez déjà commencé la tâche A et votre contexte mental est actuellement sur la tâche A.
Dans cette situation, il est très tentant de passer de la tâche A à la tâche B, d’effectuer la configuration de deux minutes sur la tâche B afin que l’agent puisse s’exécuter pendant que vous terminez la tâche A. Cependant, je vous conseille vivement d’éviter cela autant que possible et d’essayer plutôt de terminer le travail que vous êtes en train de faire, puis de passer à la tâche suivante en ligne, même si cela peut ne pas sembler être l’approche optimale à première vue.
La raison en est que vous pouvez, bien sûr, voir combien de minutes il faut pour accomplir chaque tâche. La tâche A prend 5 minutes, la tâche B prend 2 minutes d’interaction puis 10 minutes pour s’exécuter. Cependant, ce que vous ne voyez pas, c’est le coût caché du changement de contexte, et je dirais que passer de la tâche A à la tâche B puis revenir à la tâche A vous coûtera plus de temps que simplement terminer la tâche A puis terminer la tâche B.
La deuxième façon de minimiser les changements de contact est de minimiser les distractions sur mon ordinateur. Il existe de nombreuses façons de procéder, mais en général, je vous conseille vivement de désactiver toutes les notifications. J’ai par exemple désactivé les notifications Slack sur mon ordinateur ainsi que le numéro apparaissant sur l’application Slack qui vous informe si vous avez un message qui vous attend. Je trouve cela très distrayant et cela me détourne du travail que je fais actuellement.
De plus, j’essaie de garder un onglet dans la configuration de mon terminal par référentiel sur lequel je travaille. Et si je travaille sur plusieurs tâches dans un seul référentiel, je divise l’onglet. Je discuterai de la configuration de mon terminal plus en détail dans la section suivante.
Gardez une vue d’ensemble de tous vos agents
Lorsque vous exécutez plusieurs agents, il est extrêmement important de garder une vue d’ensemble de tous vos agents. Cependant, cela ne vient pas nécessairement naturellement et il faut faire des choix actifs pour avoir une vue d’ensemble aussi simple que possible.
C’est là que la configuration de mon terminal entre en jeu. Lorsque j’ai 5 à 10 agents fonctionnant en parallèle, il peut facilement être très confus de savoir quel agent fait quoi et avec quoi vous devez interagir.
Pour la configuration de mon terminal, j’utilise Warp. Je pense que Warp est un bon terminal d’IA doté d’une bonne saisie semi-automatique et avec lequel je peux facilement interagir pour utiliser Claude Code efficacement. J’utilise un onglet dans Warp par référentiel dans lequel je travaille. Il peut s’agir par exemple d’un référentiel de codage contenant le frontend ou l’application, mais il peut également s’agir d’un référentiel de vente dans lequel je ferai tout le travail de vente.
Ensuite, si j’exécute plusieurs agents dans un même référentiel, ce que je fais souvent, je divise simplement les onglets en utilisant CMD + D sur Mac. Je reçois donc plusieurs sous-onglets divisés pour chacun de mes onglets principaux. Cela m’aide à conserver un seul onglet principal pour chaque référentiel, tout en exécutant plusieurs agents dans le référentiel.
De plus, j’aime renommer mes onglets dans Warp avec le nom du référentiel afin qu’il soit facile de naviguer vers le bon onglet. Et utilisez CMD 1/2/3 et ainsi de suite pour naviguer rapidement entre les différents onglets. Et je reçois des notifications de Warp chaque fois qu’un agent a besoin d’une interaction.
Je voudrais également noter qu’il existe de nombreuses autres configurations que vous pouvez utiliser pour vos agents de codage. Tout d’abord, vous pouvez utiliser un autre terminal, qui fonctionnera probablement très bien également, même si ma préférence reste au chaud. Une autre bonne alternative que je connais est d’utiliser l’application Claude ou une application appelée Conductor, qui permet de donner facilement un aperçu de vos différents référentiels et agents de codage que vous utilisez.
Dans l’ensemble, cependant, votre configuration dépend de vos préférences. Si vous trouvez une configuration qui vous convient, je vous recommande fortement de l’utiliser et de simplement vous y tenir.
Conclusion
Dans cet article, j’ai expliqué comment paralléliser efficacement vos tâches de programmation. La principale raison pour laquelle vous devriez faire cela est simplement d’être plus efficace en tant qu’ingénieur. Si vous exécutez des tâches en parallèle, vous serez bien plus efficace qu’un ingénieur similaire qui exécute des tâches de manière séquentielle. Cependant, exécuter des tâches en parallèle n’est pas simple et vous devez utiliser des techniques spécifiques pour garder une vue d’ensemble de tous vos agents, minimiser les changements de contexte et garantir que vos agents n’entrent pas en collision les uns avec les autres. Je pense que le concept que j’ai décrit dans cet article représente l’avenir du travail avec l’IA. Les humains deviendront des orchestrateurs d’agents d’IA, et vous devez être capable de paralléliser efficacement votre travail et de déclencher des agents pour accomplir des tâches spécifiques tout en interagissant avec les agents uniquement à la demande.
👉 Mon eBook et mon webinaire gratuits :
🚀 10x votre ingénierie avec les LLM (cours gratuit par e-mail de 3 jours)
📚 Obtenez mon ebook gratuit sur les modèles de langage de vision
💻 Mon webinaire sur les modèles de langage de vision
👉 Retrouvez-moi sur les réseaux sociaux :
You may also like
