Comment faire en sorte que Claude Code valide son propre travail
modèle très puissant prêt à l’emploi. Cependant, pour exploiter toutes ses capacités, vous devez lui donner accès pour valider et vérifier son propre travail.
Dans un article précédent, j’ai mentionné que Claude valide son propre travail comme un élément important de la façon dont j’optimise ma propre utilisation de Claude Code. Dans cet article, cependant, je vais approfondir la façon dont je fais valider par Claude son propre travail.
Les avantages sont incroyables. Lorsque vous faites valider par Claude son propre travail, vous obtenez :
- Un modèle meilleur pour les implémentations ponctuelles (passe moins de temps à itérer)
- Un modèle qui peut fonctionner plus longtemps (le modèle continue jusqu’à ce qu’il soit en mesure de vérifier avec succès son propre travail)
- Le modèle peut effectuer un travail plus complexe
Je vais approfondir certaines tâches spécifiques où je demande à Claude de vérifier son propre travail, ce qui me fait gagner beaucoup de temps. Je couvrirai également mon processus de réflexion lors de la configuration de Claude de cette manière.
Pourquoi devriez-vous demander à Claude de vérifier son propre travail ?
La principale raison pour laquelle vous devriez demander à Claude de vérifier son propre travail est que cela permet simplement à Claude de mieux performer. Vous pouvez imaginer cela avec le scénario suivant :
Imaginez que vous deviez implémenter un morceau de code pour calculer la séquence de Fibonacci. De toute évidence, certaines personnes ont déjà effectué exactement cette tâche, et cela leur sera relativement simple à faire. Cependant, imaginez que vous deviez accomplir cette tâche parfaitement sans jamais avoir la possibilité d’exécuter le code et de voir le résultat, c’est-à-dire que vous devez créer le code parfait dès votre première tentative de résolution du problème. Donc, naturellement, c’est beaucoup plus difficile que si vous avez la possibilité de tester le code vous-même, de le modifier si vous voyez qu’il ne produit pas exactement les nombres corrects, et de continuer ainsi jusqu’à ce que votre morceau de code produise le résultat correct.
Le même concept s’applique exactement à Claude Code. Si vous ne lui donnez pas la possibilité de vérifier son propre travail, c’est comme lui demander d’écrire du code pour la séquence de Fibonacci sans lui permettre de voir le résultat du code. De toute évidence, vous placez Claude Code dans une position pire, car il produira des résultats inférieurs par rapport au moment où Claude Code aura la possibilité de tester son propre code.
Comment faire vérifier le travail de Claude en pratique
L’expression « faire vérifier par Claude son propre travail » est souvent utilisée, par exemple sur LinkedIn et X. Cependant, je remarque que relativement peu de personnes expliquent exactement comment ils le font eux-mêmes, ce qui rend difficile la reproduction par d’autres.
Ainsi, je couvrirai quelques exemples concrets de la façon dont j’ai fait vérifier à Claude son propre travail. Je couvrirai le processus à partir de :
- Entendre parler d’un problème
- Comprendre la cause du problème
- Implémenter une solution avec Claude et s’assurer qu’elle puisse vérifier son propre travail
Longs délais de traitement LLM
Mon premier exemple concret est un cas où j’analysais les données utilisateur d’une interaction avec un agent d’IA conversationnel. Après la conversation, je dois traiter le chat, par exemple récupérer la transcription et effectuer une classification et une extraction de données sur la transcription.
J’ai commencé à enquêter sur le problème en le reproduisant et en exécutant le traitement LLM plusieurs fois sur la même conversation, et en voyant combien de temps cela prenait. Il s’est avéré que les temps médian et moyen étaient relativement acceptables, environ 30 secondes, mais environ une fois sur dix, le temps de traitement dépassait les deux minutes, ce qui est bien sûr totalement inacceptable. J’ai expliqué la situation à Claude Code et lui ai demandé quelle pouvait être la cause de ce problème.
Il s’est avéré que la cause la plus probable était que j’entrais simplement beaucoup de jetons et que j’en produisais, ce qui, dans certaines situations, prend beaucoup de temps à produire. Ainsi, la solution consistait à prendre cet appel LLM unique et à le diviser en trois pour réduire le nombre de jetons de sortie qu’il devait produire, afin qu’il puisse fonctionner en parallèle.
Ceci est un exemple de tâche parfaite où Claude Code peut vérifier son propre travail :
Une tâche parfaite pour vérifier votre propre travail est une tâche dans laquelle vous disposez d’un résultat attendu connu que vous souhaitez produire et vous pouvez continuer à travailler et à itérer sur le problème jusqu’à ce que vous atteigniez ce résultat exact.
C’est génial car ce que j’ai maintenant, c’est un certain nombre de jetons d’entrée qui sont exécutés et une sortie attendue, ce à quoi je m’attends si je fais tout en un seul appel LLM. Et je peux simplement demander à Claude Code de diviser un appel LLM en trois morceaux et pour m’assurer que vous l’avez fait correctement, comparer le résultat des appels LLM divisés par rapport à l’appel LLM monolithique unique, ils sont presque exactement les mêmes (pas exactement les mêmes car les LLM sont stochastiques)
J’ai demandé à mon instance Claude Code toutes ces informations. Il a continué à itérer sur son code jusqu’à ce qu’il s’assure que les résultats étaient les mêmes, et il a réussi à résoudre le problème, me revenant avec une solution réussie.
Concevoir une page Web
Le dernier exemple que j’ai fourni était génial car il est très simple pour le LLM ou Claude Code de vérifier les résultats. Il peut simplement effectuer un appel API, comparer les sorties et voir si c’est correct.
Cependant, que se passe-t-il lorsque le résultat que vous souhaitez produire est un visuel ?
Mon deuxième exemple inclut un problème dans lequel j’ai reçu une conception indiquant à quoi devrait ressembler une page Web et je voulais que Claude Code produise cette conception exacte. Bien sûr, étant donné le cadre de l’application et la base de code existante pour laquelle elle a été écrite.
Cela peut sembler une tâche plus difficile car elle implique un examen visuel des résultats. Heureusement, nous avons Claude dans Chrome, qui est un MCP où vous pouvez donner à Claude accès à votre Google Chrome et le laisser inspecter visuellement les résultats.
On m’a donc fourni une capture d’écran d’une conception de ce à quoi la page devrait ressembler, y compris la façon dont la page était organisée en différents composants et le schéma de couleurs utilisé dans la conception.
Cette tâche est assez simple. J’ai simplement donné des captures d’écran à Claude Code et lui ai demandé d’implémenter le design. Si votre conception est assez simple, cela pourrait fonctionner immédiatement. Cependant, certaines conceptions plus complexes sont plus difficiles à réaliser en une seule fois, surtout si vous le faites dans une grande base de code existante qui comporte de nombreuses dépendances et protocoles de conception.
Ainsi, pour donner à Claude Code la meilleure chance de résoudre le problème lui-même, je lui ai donné accès à Google Chrome. Si vous souhaitez le mettre en place vous-même, vous pouvez simplement demander à votre instance Claude Code, comment puis-je vous donner accès à Google Chrome ?
J’ai demandé à mon agent Claude d’essayer d’abord de mettre en œuvre la conception, puis d’aller dans Google Chrome, de charger la page correspondante après avoir démarré les serveurs, bien sûr, en prenant une capture d’écran et en comparant les conceptions. S’il constate des divergences, il doit continuer à itérer jusqu’à ce que les conceptions soient presque identiques.
De plus, j’ai demandé à mon agent de m’informer de toute divergence entre les deux conceptions s’il n’était pas possible de mettre en œuvre quelque chose ou s’il n’était pas clair comment mettre en œuvre quelque chose. C’est une excellente tactique car elle amène Claude à vous poser des questions au lieu de devoir lui donner des instructions sur absolument tout ce qui concerne la conception. Dans l’ensemble, c’est une excellente technique pour mieux travailler avec vos agents de codage.
Conclusion
Dans cet article, j’ai expliqué comment faire en sorte que Claude Code valide son propre travail, pour améliorer considérablement les performances de votre instance Claude Code ou de votre agent de codage en général. J’ai expliqué pourquoi il est si important de souligner comment permettre à Claude de vérifier son propre travail le rend tout simplement beaucoup plus performant avec un taux de réussite plus élevé sur les implémentations ponctuelles, et en laissant l’agent travailler pendant de plus longues périodes tout en accomplissant ses tâches avec succès. J’ai couvert deux situations spécifiques dans lesquelles j’ai donné accès à Claude Code pour vérifier son propre travail, notamment diviser un appel LLM en trois appels distincts pour améliorer la latence et suivre les conceptions réalisées pour une page Web et les implémenter dans mon application. Ce sont deux situations spécifiques dans lesquelles j’ai été placé et où j’ai permis à Claude de vérifier son propre travail et d’augmenter ses performances.
👉 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 :
