Comment j’améliore continuellement mon code Claude
des articles sur les techniques que j’applique lorsque j’utilise Claude Code pour en tirer le meilleur parti. Cependant, un sujet sur lequel j’ai passé moins de temps est de savoir comment améliorer mon utilisation de Claude Code en général. Comment optimiser la façon dont j’interagis avec mes instances Claude Code et la façon dont mon Claude Code fonctionne au sein des référentiels de code que je mets à jour ?
Dans cet article, je souhaite souligner comment je mets continuellement à jour la façon dont j’interagis avec Claude Code et comment mon Claude Code fonctionne, ce qui rend moi et mon agent de codage de plus en plus efficaces au fil du temps.
Le concept d’apprentissage continu est incroyablement puissant, car si vous parvenez à vous améliorer de quelques pour cent chaque jour, l’effet cumulatif au fil des semaines et des mois deviendra énorme. Vous pouvez devenir bien plus efficace qu’avec la simple version prête à l’emploi de Claude Code ou de tout autre agent de codage.
Pourquoi effectuer une formation continue ?
J’essaie toujours d’expliquer pourquoi un sujet est important, pourquoi vous devriez vous en soucier et comment il peut vous aider. La raison pour laquelle vous devez effectuer un apprentissage continu est simple : si vous utilisez uniquement la version prête à l’emploi de Claude Code, Codex ou tout autre agent de codage, vous perdez quelque chose. Bien sûr, ces modèles sont incroyablement puissants, et si vous les comparez à ceux d’il y a quelques années seulement, vous pouvez encore être bien plus efficace qu’avant.
Cependant, cela n’a pas vraiment d’importance. Ce qui compte vraiment, c’est que l’application de l’apprentissage continu vous apportera à nouveau un énorme gain d’efficacité.
Dans cet article, je vais aborder une technique très simple sur la façon dont j’améliore mon Claude Code chaque jour, et je vous donnerai également un aperçu de la façon dont j’essaie d’optimiser mes propres interactions avec Claude Code pour rendre l’interaction de l’agent de codage humain aussi efficace que possible.
Faire apprendre à Claude Code de lui-même
Je vais commencer par aborder la technique simple que vous pouvez commencer à utiliser dès maintenant, qui va presque certainement améliorer les performances de votre Claude Code.
Vous pouvez simplement créer une compétence dans Claude Code qui ressemble à ceci :
Review my last interactions with Claude Code from the last 24 hours.
Look for any problems that I encountered, things that weren't working
efficiently, and unnecessary tool calling. Look for common mistakes
Claude Code was doing and other things that can be optimized.
Look thoroughly through all conversations and make a plan for how we
can optimize our flow in the future, both within each repository and
cross-repositories. Also look for insights that would be useful for the
coding agent to know beforehand, both before entering a repository and
when working in multiple repositories at the same time. Disons que nous appelons cela l’évaluation des compétences-performances passées. Maintenant, ce que vous devez faire est de configurer une tâche cron pour déclencher cette compétence à 2 heures du matin tous les soirs ou à un moment où vous savez que vous n’interagissez pas activement avec vos agents.
Ce qui va se passer lorsque vous implémenterez et exécuterez cette compétence, c’est que Claude passera en revue toutes les conversations que vous avez eues au cours des dernières 24 heures. Il va regarder les discussions. Il verra où vous êtes resté coincé avec Claude Code (c’est-à-dire où vous avez passé plus de temps que vous n’auriez dû), et où Claude Code s’est retrouvé bloqué en faisant des appels d’outils incorrects, des hypothèses incorrectes, ou où il n’avait tout simplement pas le contexte dont il avait besoin pour effectuer la tâche efficacement.
Il élaborera ensuite un plan pour éviter que ces choses ne se reproduisent à l’avenir et permettre à Claude Code de fonctionner plus efficacement dans la plupart des cas. Cela mettra en œuvre des changements tels que :
- Ajout de plus d’informations à agents.md ou à des fichiers de démarques génériques similaires
- Créer des compétences spécifiques que l’agent peut soit charger à la demande, soit exécuter à la demande lorsqu’il s’occupe de certaines tâches
- Implémenter des scripts ou des outils spécifiques, tels que des hooks de pré-commit, des scripts de test, etc., pour éviter que des erreurs ne se reproduisent
L’avantage de la configuration d’une tâche cron pour exécuter cette compétence au quotidien est que vous n’avez même pas besoin d’interagir du tout avec les agents. Il sera capable de réfléchir de manière efficace, de découvrir les inefficacités, de les peaufiner et ainsi d’améliorer Claude Code au fil du temps. L’un des meilleurs aspects de cela est que Claude Code sera personnalisé en fonction de vos cas d’utilisation spécifiques. Vous pouvez avoir une pile technologique ou des préférences spécifiques lorsque vous travaillez dans des référentiels. L’exécution de cette compétence découvrira ces préférences et les optimisera pour les rendre aussi efficaces que possible.
En exécutant simplement cette tâche cron tous les soirs, j’ai débloqué d’énormes gains d’efficacité, où mes agents de codage sont devenus beaucoup plus puissants qu’avant, simplement parce qu’ils font moins d’erreurs. Ils sont plus conscients de la bonne approche pour faire les choses et, dans l’ensemble, ils suivent mieux mes préférences.
Améliorer l’interaction humaine avec les agents de codage
Une autre chose plus compliquée à optimiser est l’interaction humaine avec les agents de codage. Je passe beaucoup de temps à réfléchir et à réfléchir sur la manière de communiquer le plus efficacement possible avec mes agents pour leur faire mettre en œuvre le code que je souhaite le plus rapidement et le plus efficacement possible.
De toute évidence, ce n’est pas encore un problème résolu, car il existe encore de nombreux outils et plates-formes différents qui rendent les agents de codage et l’interaction avec eux plus faciles, meilleurs et plus efficaces. Dans cette section, je couvrirai certaines de mes réflexions sur l’interaction humaine avec les agents de codage et comment j’essaie de l’optimiser moi-même.
Notez que les techniques que je vais aborder sont, bien sûr, optimisées et adaptées à mes propres flux de travail, et je vous invite à les lire et à en apprendre davantage et à réfléchir à la manière dont cela s’applique à vos propres flux de travail.
Exécuter plus de 7 agents à la fois
Je me retrouve souvent à gérer plusieurs agents à la fois simplement parce que j’ai beaucoup de tâches à accomplir et que je peux commencer à travailler dessus en parallèle. Bien sûr, il existe des facteurs externes qui déterminent s’il est possible ou même pertinent d’exécuter autant d’agents à la fois. Lorsque la situation le permet et que cela a du sens du point de vue de l’efficacité, je ferai bien sûr fonctionner autant d’agents que possible en parallèle.
Cependant, j’ai constaté que lorsque je commence à contacter plus de sept agents à la fois, je commence à perdre le contrôle sur tous mes agents. Je ne suis pas en mesure de basculer efficacement entre eux, de suivre ce que fait chaque agent et de répondre efficacement à l’agent lorsqu’il me pose des questions.
J’ai essayé de nombreux outils et plateformes différents pour rendre cette interaction plus efficace. J’utilise actuellement Warp, où j’utilise des volets divisés pour chaque onglet lorsque je travaille avec des agents parallèles dans un référentiel et que je démarre de nouveaux onglets pour chaque référentiel différent sur lequel je travaille. Cela fonctionne relativement bien, même si, comme mentionné, je reste bloqué lorsque j’exécute plus de sept agents à la fois.
J’ai également essayé des approches plus basées sur l’IDE comme Conductor ou Omnara, mais je n’ai pas l’impression qu’elles m’apportent des gains de productivité par rapport à ce que Warp peut me fournir.
Ce que je retiens de cette section, ce sont quelques techniques qui vous permettent d’exécuter autant d’agents que possible à la fois. Il faut d’abord que la situation le permette. Il faut que vous disposiez de suffisamment de tâches pouvant toutes être exécutées en parallèle et que vous puissiez laisser l’agent s’exécuter suffisamment longtemps pour ne pas être constamment interrompu. La première étape consiste simplement à ce que la ou les tâches que vous effectuez doivent le permettre.
Deuxièmement, un récapitulatif est une chose très puissante lorsque l’on travaille avec de nombreux agents en parallèle. Claude Code a commencé à proposer un récapitulatif en bas du chat, ce qui est incroyablement puissant. Il vous donne un très bref aperçu de ce que vous faites dans cette discussion, ce qui vous permet de retrouver rapidement le contexte lorsque vous devez à nouveau interagir avec un agent. Je vous invite à activer les récapitulatifs et à les utiliser activement si vous avez besoin de lire le contexte d’un fil de discussion spécifique.
Enfin, dans cette rubrique, je voudrais également souligner que Claude Code, aujourd’hui, au moment de la rédaction de cet article, vient de publier un vue agent dans Claude Code. Il s’agit d’une vue qui devrait permettre de garder plus facilement une vue d’ensemble de tous vos agents à la fois. Je ne l’ai pas encore essayé moi-même, même s’il semble résoudre exactement le problème que je décris dans cette section. Je vais certainement l’essayer et écrire un article là-dessus à l’avenir.
Laissez l’agent vous poser des questions, et non l’inverse
Cette sous-section est intéressante car la manière courante d’interagir avec les modèles d’IA, du moins au début, était de leur poser des questions et de leur demander de vous répondre de manière concise. Cependant, cela change complètement une fois que vous commencez à gérer des sessions de code de longue durée. Vous ne voulez plus lui poser de questions, vous voulez qu’il fonctionne le plus indépendamment possible le plus longtemps possible et qu’il ne s’arrête que lorsqu’il doit vous poser des questions.
C’est donc quelque chose que je vous recommande de saisir dans les invites de vos agents de codage. Vous souhaitez qu’ils fonctionnent aussi longtemps et de manière indépendante que possible et qu’ils n’arrêtent leur mise en œuvre que lorsqu’ils doivent poser une question à l’utilisateur. Ceci, bien sûr, est également étroitement lié à un autre article que j’ai écrit, qui explique comment laisser Claude Code valider son propre travail. Pour que l’agent fonctionne pendant une longue période, vous devez lui donner une option ou une possibilité de vérifier son propre travail, ce que j’ai abordé dans un autre article de Towards Data Science. Découvrez-le ci-dessous :
Comment faire en sorte que Claude Code valide son propre travail
Conclusion
Dans cet article, j’ai expliqué comment j’améliore continuellement mon instance Claude Code, à la fois en faisant en sorte que Claude Code s’améliore grâce à l’auto-réflexion chaque nuit et en améliorant l’interaction humaine avec Claude Code et d’autres agents de codage. Je pense que ces deux choses sont des choses que vous devriez essayer d’optimiser en tant qu’ingénieur pour rendre votre codage plus efficace. En tant qu’ingénieur, vous devez toujours être attentif au prochain goulot d’étranglement : ce qui vous ralentit le plus et débloquerait le plus grand gain de productivité. Pour ma part, j’ai découvert que c’était :
- Claude Code répétant des erreurs, qui sont corrigées par la première section de cet article
- L’interaction humaine avec Claude Code, dont j’ai parlé dans la deuxième section de cet article
Je vous exhorte à rechercher constamment de tels goulots d’étranglement et à essayer de les supprimer le plus rapidement possible pour rendre vos efforts de codage aussi productifs que possible.
👉 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 :
