L'un des meilleurs aspects de nos tout derniers modèles Claude est leur capacité à répondre au niveau d'effort sans casser le cache de prompt dans Claude Code, mais j'ai reçu énormément de questions à ce sujet de la part des utilisateurs. Qu'est-ce que l'effort exactement, et quand utiliser tel ou tel niveau ? Pourquoi avons-nous même besoin de cette notion ?
Pour y répondre, j'ai décidé de plonger en profondeur dans les évaluations (evals) et de mener mes propres tests sur l'effort appliqué à des tâches courantes.
Remarque : vous pouvez consulter davantage de diagrammes interactifs et d'explications pour cet article sur https://claude.dev/blog/spending-your-effort/
De manière générale, j'ai constaté que l'effort était un excellent moyen de moduler l'intensité de la vérification et des tests de cas limites effectués par Claude, ainsi que la part de jugement personnel qu'il mobilise.
Un effort supplémentaire a donné de meilleurs résultats dans les domaines où la vérification et les tests de cas limites sont particulièrement utiles, comme le matériel, la revue de code et la sécurité.
En revanche, un effort faible ou moyen s'est révélé parfait pour avancer rapidement et rester impliqué aux côtés de Claude.
Pour le développement logiciel classique, je fonctionne désormais avec une boucle : je demande au modèle de m'interviewer, puis j'implémente avec un effort faible/moyen, je passe en revue ce qui a été construit, et enfin je lance une vérification avec un effort élevé.
Qu'est-ce que l'effort ?
Globalement, l'effort donne au modèle une indication approximative de la puissance de calcul que vous souhaitez qu'il consacre à la tâche. C'est en quelque sorte lié à votre propre évaluation de la difficulté du travail demandé.
Imaginez ceci : si quelqu'un vous demandait de travailler sur un projet pendant 12 heures d'affilée, vous supposeriez probablement qu'il veut simplement que vous le fassiez et que vous y mettiez toute votre énergie. Si on vous demandait de réaliser la même tâche en 1 heure, vous chercheriez à fournir la meilleure version possible répondant au besoin, en prévoyant ensuite des itérations.
Ou bien, vous pourriez émettre des réserves et affirmer que la tâche nécessite au moins 3 heures, puis travailler ces 3 heures pour livrer le résultat.
Vous devriez envisager l'effort de la même manière. Claude cherchera toujours à accomplir votre tâche de façon raisonnable, mais un effort plus élevé l'amènera à prendre davantage d'initiatives autonomes pour juger et vérifier.
Les courbes d'effort
Les courbes d'effort de Fable 5.1 et Opus 5.5 sont nos meilleures à ce jour : à chaque niveau, on observe une hausse des scores de benchmark et du nombre de tokens consommés. Voici un graphique des scores Terminal Bench 3.0 selon l'effort, mesurés lors de mes sessions d'évaluation pour cet article.
Mais qu'est-ce que cela signifie concrètement ? Pour l'évaluer, j'ai testé plusieurs tâches à différents niveaux d'effort et j'ai minutieusement analysé les benchmarks.
Construire avec l'effort
La meilleure façon de comprendre le fonctionnement des modèles est de mener des expériences. J'ai essayé de réaliser les mêmes tâches à plusieurs niveaux d'effort sur Opus 5.5 afin de comprendre le travail qu'il allait fournir. Je l'ai fait sur une grande variété de sujets, mais je vais illustrer cela avec quelques exemples simples.
Tâche de construction sous-spécifiée
Si je demande à Claude de « créer une application personnelle de suivi de fitness et d'entraînement », l'effort modifie radicalement le degré d'aboutissement de l'application, mais amène aussi Claude à faire davantage de choix en cours de route. Avec un effort faible, l'application de fitness n'est qu'un journal et un graphique basique. À des niveaux d'effort plus élevés, l'application devient plus complexe et détaillée. À l'effort maximal, on obtient même une carte thermique.
Si je voulais une base simple pour itérer ensuite, un effort faible ferait parfaitement l'affaire. L'effort maximal serait idéal si je souhaitais obtenir la meilleure version possible de Claude du premier coup.
Tâche de conception légèrement spécifiée
Que se passe-t-il si j'ai une tâche déjà assez bien définie, mais que je souhaite explorer des pistes avec Claude ? Par exemple, j'ai essayé de lui demander de repenser le menu /config dans Claude Code. Chaque passage reposait à peu près sur la même idée : utiliser des sous-menus et améliorer la recherche.
Avec un effort faible (qui a pris 1 minute), j'ai obtenu une maquette interactive qui transmettait l'idée, mais ne ressemblait pas vraiment à Claude Code.
Avec un effort maximal (qui a pris 28 minutes), j'ai obtenu un mockup très fidèle à l'apparence de Claude Code, accompagné de plusieurs parcours utilisateur pour différents flux.
Si mon objectif était d'itérer et de donner mon avis, un effort faible m'y amènerait beaucoup plus vite. Mais l'effort maximal me fournit d'emblée un résultat bien plus abouti. Pour cette tâche précise, je pense préférer l'effort faible afin de mieux saisir la vision de Claude.
Tâche de construction hautement spécifiée
Et si je donnais énormément de détails à Claude ? J'ai essayé de lui demander de m'interviewer en profondeur au sujet de l'application de fitness, puis j'ai soumis ce cahier des charges à différents modèles, à différents niveaux d'effort, pour qu'ils l'implémentent.
J'ai constaté qu'avec ce cahier des charges, les modèles se comportaient de manière beaucoup plus similaire. J'ai obtenu des designs assez proches et des implémentations comparables, mais avec des détails différents ; à l'effort maximal, Claude a pris le temps de simplifier certains de ces détails.
Ce qu'il faut retenir
Pour le développement logiciel courant, en particulier la création de nouvelles fonctionnalités, le niveau d'effort dépend fortement du degré d'implication que je souhaite conserver. Un effort faible permet à Claude de répondre rapidement avec un point de départ, tandis qu'un effort plus élevé abat davantage de travail, mais pousse aussi Claude à faire plus de suppositions à ma place.
Une boucle particulièrement fructueuse que j'utilise pour le développement de fonctionnalités est la suivante :
- Fournir un cahier des charges à Claude et lui demander de m'interviewer sur les détails manquants
- L'implémenter avec un effort faible
- Vérifier qu'il a bien saisi l'essentiel, et itérer avec un effort faible si nécessaire
- Vérifier et tester avec un effort élevé
Comment les niveaux d'effort influencent le résultat sur les tâches difficiles
Il s'agit évidemment d'exemples simples, que Claude est tout à fait capable de réaliser. Mais qu'en est-il lorsque la différence se joue entre réussir ou échouer la tâche ?
Pour trouver ces problèmes ardus, il faut se tourner vers les benchmarks. Je me suis donc plongé dans l'un de mes préférés : Terminal Bench 3, un benchmark alimenté par la communauté.
Les problèmes de Terminal-Bench 3.0 peuvent globalement être classés dans des catégories telles que la sécurité, le matériel, le ML, les sciences, les logiciels, les opérations et les médias. Vous pouvez consulter tous les problèmes ici : https://github.com/harbor-framework/terminal-bench/releases/tag/v3.0.0. Ils proviennent de la communauté, donc n'importe qui peut y contribuer.
Cela vaut la peine de les lire pour se faire une idée du type de problèmes auxquels ces modèles sont confrontés. J'ai d'ailleurs été surpris par l'ampleur et l'ambition de bon nombre de ces tâches. Elles sont bien plus complexes que les problèmes que je rencontre habituellement.
Par exemple, certaines tâches incluaient :
- Matériel (retro-console-soc) : construire une console de jeu 8 bits en Verilog qui tient sur un petit FPGA et exécute une ROM de test.
- Sciences (takens-embedding-lean) : prouver formellement le théorème d'inclusion de Takens dans Lean 4.
- ML (mp-checkpoint-consolidation) : fusionner 16 fragments d'un checkpoint mixture-of-experts en un seul fichier reproduisant les logits de référence.
- Opérations (intrastat-meldung) : exécuter de bout en bout la déclaration mensuelle des statistiques commerciales européennes d'une entreprise.
- Médias (layout-config-recreation) : recréer l'image d'une affiche sous forme de fichier de mise en page modifiable.
Un effort plus élevé est utile face à de nombreux cas limites
Ma principale conclusion après avoir lu les résultats de Terminal Bench 3 est qu'un effort plus élevé est optimal pour les tâches comportant de nombreux cas limites cachés.
Un exemple parlant est html-js-filter, une tâche de Terminal-Bench 3.0 qui demande un assainisseur HTML supprimant toutes les méthodes permettant d'injecter du JavaScript dans une page. Fable 5.1 est passé de 1/5 à effort faible à 5/5 à effort xhigh.
Une tentative typique à effort faible prend environ 2 minutes. Chacune de ces tentatives a écrit un filtre en une seule passe, puis l'a testé sur une unique page rédigée à la main.
Une exécution à effort élevé se termine en environ 33 minutes. Dans celle que j'ai analysée, le modèle a revu son premier brouillon de manière contradictoire, puis a lu le code source de l'analyseur installé pour y chercher des bugs, a exécuté de nombreux cas de test valides jusqu'à obtenir une sortie identique à l'entrée, a lancé une suite de tests XSS standard et, enfin, a écrit un fuzzer de documents aléatoires.
Pour un outil aussi sujet aux cas limites qu'un assainisseur HTML, cet effort supplémentaire en vaut largement la peine. Consommer plus de tokens pour être exhaustif a également du sens pour les tâches complexes soumises à de fortes exigences de production, comme l'optimisation des performances ou la revue de sécurité.
Mais vous n'avez pas besoin de ce niveau d'effort pour chaque tâche.
Le diagramme ci-dessous présente tous les résultats de Terminal-Bench 3.0 et la nature des échecs, selon les modèles et les niveaux d'effort. Globalement, augmenter l'effort tend à réduire les échecs liés à des cas limites oubliés (blocs violets), mais ne corrige pas les situations où le modèle adopte une mauvaise approche (blocs bleus).
Les domaines où l'effort fait la différence
L'une des conclusions les plus intéressantes tirées de l'évaluation de ces modèles sur TerminalBench est que certains domaines bénéficiaient davantage de l'effort que d'autres. Vous pouvez voir la répartition dans le diagramme suivant :
Pour illustrer cela, j'ai sélectionné quelques problèmes issus de différents domaines de Terminal Bench 3.0, où Opus 5.5 a échoué à effort faible mais réussi à effort élevé — principalement parce qu'il a testé et pris en compte les cas limites :
mvcc-lsm-compaction : une tâche de Terminal-Bench 3.0 qui demande de corriger un bug de moteur de stockage à partir de son rapport de plantage, sans casser la compaction. Opus 5.5 est passé de 0/5 à effort faible à 4/5 à effort xhigh.
À effort faible (environ une minute par tentative), Claude modifiait le code avant de le compiler ou de lancer le script de reproduction, et ne vérifiait pas si son nouveau test aurait détecté le bug initial.
À effort xhigh (environ 11 minutes), Claude a d'abord reproduit le plantage, écrit un test aléatoire comparé à une référence qui ne compacte jamais, et vérifié que ses tests échouaient sur des correctifs incomplets.
cli-2ph-simple : une tâche de Terminal-Bench 3.0 qui demande un solveur de programmation linéaire en ligne de commande écrit en Python. Opus 5.5 est passé de 0/5 à effort faible à 5/5 à effort élevé.
Les tentatives à effort faible ont généré un solveur en une seule passe, l'ont vérifié sur quelques petits problèmes et se sont arrêtées autour de 10 000 tokens. Dans le dernier message, Claude a prévenu qu'il pourrait être lent sur de gros problèmes, mais ne l'a pas vérifié.
Lors des tentatives à effort élevé, Claude a testé son solveur sur des problèmes aléatoires en le comparant à un solveur distinct par force brute, puis a chronométré des problèmes plus vastes, a rencontré des cas qui prenaient beaucoup trop de temps ou plantaient, et a retravaillé sa méthode de recherche.
gsea-proteomics : une tâche de Terminal-Bench 3.0 qui demande une analyse d'enrichissement de jeux de gènes (GSEA) sur des données protéomiques pour déterminer lesquels de huit traitements ressemblent à un tissu cible. Opus 5.5 est passé de 0/5 à effort faible à 4/5 à effort élevé.
À effort faible, Claude a choisi une méthode de préparation des données qui semblait raisonnable, a exécuté l'analyse de cette unique manière et a rapporté le résultat.
À effort élevé, Claude a essayé deux méthodes de préparation des données, a remarqué que la liste des traitements significatifs changeait, et a creusé la question avant de choisir la bonne.
Si un utilisateur avait été impliqué, Claude lui aurait peut-être demandé comment configurer le problème, mais sans intervention humaine, l'effort élevé donne de meilleurs résultats.
Quand utiliser les différents niveaux d'effort dans Claude Code
Voici ma règle empirique pour savoir quel niveau d'effort choisir :
- Faible : lorsque je veux des réponses rapides tout en restant impliqué, par ex. brainstorming, esquisses, modifications simples.
- Moyen : pour la majorité de mon travail de développement logiciel courant, par ex. l'implémentation de nouvelles fonctionnalités.
- Élevé : pour les travaux où la vérification est cruciale ou lorsqu'il existe des cas limites, par ex. corriger un bug dans une base de code existante (brownfield).
- Maximal : lorsque je veux que Claude opère de manière totalement autonome pour résoudre des problèmes difficiles, par ex. la construction et la vérification de bout en bout d'une application, ou la recherche de failles de sécurité dans des logiciels critiques.
Essayez de faire varier l'effort pour Opus 5.5 et Fable 5.1 en fonction de votre tâche, ou même en pleine conversation, en utilisant /effort dans Claude Code, et dites-moi si cela correspond à votre intuition.
