Méthode Fable : des skills d’agent pour tout modèle

Ce que la méthode Fable affirme réellement

La méthode Fable est un petit ensemble de skills d’agent qui consigne les habitudes de travail d’un modèle sous la forme d’une procédure ordonnée, afin qu’un autre modèle puisse exécuter la même procédure. Le dépôt est Sahir619/fable-method, il est distribué sous licence MIT, et sa propre description en une ligne est la suivante : « comment Claude Fable 5 fonctionnait, synthétisé en skills que n’importe quel modèle peut exécuter, avec l’évaluation qui en vérifie la fiabilité ». La seconde moitié de cette phrase est l’affirmation qui mérite d’être testée.

Personne en dehors d’Anthropic ne peut vérifier si un fichier texte décrit réellement la façon dont un modèle donné raisonne. En revanche, vous pouvez vérifier vous-même si un modèle moins coûteux se comporte différemment lorsqu’il lit ce fichier texte, sur un seul VPS, en une après-midi. C’est l’objectif de toutes les mesures ci-dessous : exécuter deux fois la même tâche, avec et sans la méthode, puis compter les appels aux outils et le coût.

Si le terme skill est nouveau pour vous, commencez par ce qu’est réellement un skill d’agent : un dossier contenant un fichier SKILL.md dont la description dans le frontmatter indique à l’agent quand charger le contenu. Le modèle qui a donné son nom au dépôt est présenté dans le coût de Claude Fable 5 et les tâches auxquelles il convient.

Installer les skills et figer la version testée

Il existe deux méthodes d’installation. Dans Claude Code, la méthode avec le plugin se résume à deux commandes :

/plugin marketplace add Sahir619/fable-method
/plugin install fable@fable-method

Sur un VPS, si vous voulez conserver une copie versionnée sur le disque, clonez d’abord le dépôt, puis basculez sur un tag :

git clone https://github.com/Sahir619/fable-method ~/fable-method
cd ~/fable-method
git checkout v1.4.0
bash install.sh
ls ~/.claude/skills

install.sh n’a pas besoin de sudo, car il écrit uniquement sous $HOME/.claude/skills. Une fois son exécution terminée, ls ~/.claude/skills affiche fable-judge, fable-loop et fable-method. Vérifiez les éléments absents. Le dépôt fournit quatre skills, mais l’installateur shell en copie trois. Un utilisateur autonome n’obtient donc pas fable-domain, sauf s’il le copie manuellement :

cp -r ~/fable-method/skills/fable-domain ~/.claude/skills/

Figez le tag et notez-le à côté des résultats obtenus. Ce dépôt a publié cinq releases entre 2026-07-06 et 2026-07-15, de v1.0.0 à v1.4.0. La version v1.4.0 a modifié la méthode elle-même en ajoutant une nouvelle étape de routage. En août 2026, v1.4.0 est toujours le tag le plus récent. Si votre exécution de contrôle lit une version des règles et votre exécution de test une autre, la mesure n’a aucune valeur.

Ce que chacune des quatre compétences demande au modèle

Le fichier central est skills/fable-method/SKILL.md. Il contient deux garde-fous et sept étapes numérotées. Ses règles sont suffisamment précises pour être contestées.

Le garde-fou de trivialité vient en premier : agissez directement, sans formalités, lorsque la modification concerne un seul fichier, s’exécute en moins d’environ 10 lignes, n’ajoute aucun nouveau comportement et que vous savez déjà exactement quoi modifier. Vient ensuite le garde-fou d’adéquation. Il oriente la demande selon l’emplacement de la réponse : des sources que vous pouvez consulter, une technique que vous devez d’abord rechercher, ou votre propre déduction, qui doit être signalée comme peu fiable et non présentée comme un fait.

Vient ensuite la boucle : classer la demande, définir les critères de fin, réunir les éléments probants, décider, agir, vérifier, rendre compte. L’étape 2 demande de s’orienter en listant le répertoire avant de choisir les fichiers, de privilégier les sources primaires plutôt que la mémoire, et d’arrêter après deux recherches consécutives qui ne renvoient rien de nouveau. L’étape 4 demande d’écrire une ligne INTENT: avant toute modification. Cette ligne doit indiquer ce que fait le code, ce qu’attend le contrôle en échec et ce que dit la spécification. Il ne faut effectuer aucune modification si ces trois éléments ne concordent pas, car cette divergence constitue le véritable constat. L’étape 5 limite les nouvelles tentatives : après trois cycles de correction et de vérification ayant échoué sur le même problème, arrêtez-vous et renvoyez la sortie réelle.

La partie la plus facilement testable du fichier est constituée de ses quatre marqueurs de compte rendu. Une modification de comportement doit comporter une ligne INTENT:. Une action externe doit comporter AUTH: user said "<exact words>", en citant l’utilisateur, car le dépôt indique explicitement que la documentation ne constitue pas une autorisation. Une action prescrite mais non exécutée doit comporter une ligne PENDING:. Un défaut corrigé doit comporter TWINS: searched <pattern> - found <N> other sites. Il n’est pas nécessaire de faire confiance à la méthode pour vérifier si ces quatre chaînes apparaissent lorsqu’elles sont requises. C’est ce qui rend l’ensemble mesurable plutôt que subjectif.

fable-loop applique la même méthode comme une orchestration en quatre étapes : planifier avec des sous-agents de collecte d’éléments probants exécutés en parallèle, exécuter sur le thread principal, vérifier avec un à trois sous-agents attaquants qui adoptent chacun un angle différent, puis auditer et rendre compte. Cette organisation suppose l’utilisation de modèles peu coûteux pour les rôles de collecte et d’attaque, et d’un modèle plus puissant pour les décisions et les modifications.

fable-judge est le composant qui mérite d’être installé même si vous abandonnez tout le reste. Son principe est le suivant : « un rapport est un ensemble d’affirmations, pas des éléments probants ». Il extrait les affirmations d’un rapport terminé, établit la vérité de référence à partir de git diff et git status, réexécute toutes les vérifications que le rapport affirme avoir effectuées et recherche une liste de fraudes nommées : contrôles affaiblis, achèvement fictif, dérive du périmètre, action non autorisée, violation de la spécification et résidus. Il renvoie VERIFIED, VERIFIED WITH CAVEATS ou REFUTED, et marque comme UNVERIFIABLE tout élément qu’il ne peut pas reproduire, au lieu de supposer qu’il est validé. La dernière ligne de l’installateur le résume : « Essayez : ouvrez Claude Code et saisissez /fable-judge après qu’un agent a affirmé que le travail est terminé. »

fable-domain génère des bundles d’adaptation par domaine avec des fixtures de pièges et des smoke evals. Huit adaptateurs sont fournis : marketing, recherche, analyse de données, activités et opérations, finance, droit et conformité, design et UX, et devops. Les travaux médicaux et cliniques restent volontairement dépourvus d’adaptateur.

Quelles parties sont transférables à un autre modèle et lesquelles ne le sont pas

Le dépôt répond directement à cette question avec AGENTS.md, qui commence ainsi : « Version portable pour n’importe quel agent ou harness de programmation (Codex, Cursor, aider, prompt système brut). Méthode identique à SKILL.md ; collez ce fichier dans les instructions de votre agent ou placez-le à la racine du dépôt sous le nom AGENTS.md. » Le fichier fait environ 2,600 mots et reprend les mêmes garde-fous, étapes et modes. Si vous conservez déjà des fichiers d’instructions à la racine du dépôt, la convention AGENTS.md et HUMAN.md précise où placer ce fichier et qui le lit.

Deux parties se transfèrent sans difficulté. Le texte de la méthode est un prompt séquentiel qui ne contient aucun code propre à un modèle. Tout modèle capable de suivre des instructions peut donc l’appliquer. La thèse du dépôt est aussi que l’effort de transfert est inversement proportionnel au niveau du modèle. Le judge se transfère également, à condition que l’agent dispose d’un shell et d’un dépôt, car tout ce qu’il fait consiste à git diff, puis à relancer des commandes que le lecteur peut également exécuter.

Une partie ne se transfère pas correctement. fable-loop suppose que le harness peut lancer des subagents en parallèle et les affecter à différents modèles. Un agent sans subagents exécute ces étapes séquentiellement avec un seul modèle. Il perd donc le parallélisme et la réduction des coûts qui justifiaient cette conception. Il ne reste alors que fable-method avec un vocabulaire supplémentaire.

Deux autres éléments, plus secondaires, dépendent du harness et sont faciles à manquer. Le déclencheur /fable-method est une commande slash de Claude Code. Dans un autre harness, vous lancez donc la méthode en la décrivant. La description du frontmatter SKILL.md permet à un agent de ne charger le corps que lorsque la tâche correspond. Ainsi, une skill installée consomme presque aucune ressource tant qu’elle ne se déclenche pas. Si vous placez AGENTS.md dans un prompt système, ces 2,600 mots sont inclus dans chaque requête que vous envoyez, qu’il s’agisse d’une correction d’une ligne ou d’une refactorisation. La différence de coût est réelle. C’est la principale raison pour laquelle le packaging sous forme de skill existe.

Comment comparer sur un VPS : la même tâche, deux fois

Configurez deux copies de travail identiques afin qu’aucune exécution ne puisse voir les modifications de l’autre. Remplacez YOUR_ORG/YOUR_REPO par le dépôt que vous voulez tester ; les deux clones doivent provenir du même commit.

sudo apt update && sudo apt install -y git jq
git clone https://github.com/YOUR_ORG/YOUR_REPO ~/ab/control
git clone https://github.com/YOUR_ORG/YOUR_REPO ~/ab/method

Choisissez une tâche dont le résultat est observable sans interprétation : un test en échec qui doit réussir ou un script qui doit se terminer avec le code 0. Une tâche vague produit une comparaison vague, car vous finissez par évaluer du texte plutôt que des résultats.

Exécutez le groupe témoin avec --bare. Cette option désactive la découverte automatique des hooks, des skills, des plugins et de CLAUDE.md. C’est ce qui en fait un contrôle : les skills installés précédemment ne peuvent pas intervenir. Le mode bare n’utilise pas votre session d’abonnement. Définissez donc d’abord une clé API depuis la Claude Console.

export ANTHROPIC_API_KEY=sk-ant-...
task="Make tests/test_parser.py pass without editing the test file."

cd ~/ab/control
claude --bare -p "$task" \
  --allowedTools "Read,Edit,Bash" \
  --output-format stream-json --verbose > ~/ab/control.jsonl

Le groupe test utilise la même commande avec une option supplémentaire. Celle-ci charge la méthode portable comme ajout à l’invite système :

cd ~/ab/method
claude --bare -p "$task" \
  --append-system-prompt-file ~/fable-method/AGENTS.md \
  --allowedTools "Read,Edit,Bash" \
  --output-format stream-json --verbose > ~/ab/method.jsonl

Même binaire, même modèle, mêmes outils, même arborescence initiale. Une seule option diffère. C’est la seule manière de rendre la comparaison pertinente.

Cette méthode mesure le texte de la méthode. Elle ne mesure pas le packaging des skills, qui constitue une question distincte. Pour mesurer le packaging, supprimez --bare, installez les skills comme indiqué plus haut et placez le nom du skill dans la chaîne d’invite, car les skills invoqués par l’utilisateur sont développés en mode print : claude -p "/fable-method $task". Attendez-vous à un profil de coût différent de celui du groupe utilisant l’invite système, même lorsque le comportement visible semble identique.

Compter les étapes et le coût

Les deux exécutions ont écrit un flux d’événements JSON. La dernière ligne est un message result qui contient le texte final, le coût et les métadonnées de session. Affichez-la une fois et lisez-la avant d’écrire un script autour de ce format, car les noms de champs changent entre les versions de Claude Code.

tail -1 ~/ab/control.jsonl | jq .

Le coût de chaque exécution se trouve dans cette ligne. C’est cette valeur qu’il faut comparer :

for f in ~/ab/control.jsonl ~/ab/method.jsonl; do
  printf '%s ' "$f"
  jq -r 'select(.type=="result") | .total_cost_usd' "$f"
done

Pour compter les étapes, comptez les appels d’outils dans le même fichier :

jq -r 'select(.type=="assistant") | .message.content[]? | select(.type=="tool_use") | .name' \
  ~/ab/control.jsonl | sort | uniq -c | sort -rn

Faites-le pour les deux fichiers. La forme de l’écart est plus informative que les totaux. Une exécution avec méthode qui lit davantage de fichiers et en modifie moins respecte les exigences de la méthode. C’est le compromis que vous acceptez. Une exécution avec méthode qui produit les mêmes modifications pour un coût supérieur de quarante pour cent ne vous a rien apporté sur cette tâche.

Deux précautions concernant ces chiffres. Premièrement, ne faites pas la somme des output_tokens dans les transcriptions de session sous ~/.claude/projects/ pour la présenter comme le total : ces blocs d’utilisation par message sont des instantanés pris pendant le streaming, et des signalements indiquent qu’ils peuvent sous-estimer les valeurs. La ligne result est la valeur à retenir. Deuxièmement, une seule exécution par méthode ne constitue qu’une anecdote. Exécutez donc chaque méthode trois ou quatre fois sur la même tâche avant de conclure à un écart, car deux exécutions du même agent sur la même tâche peuvent déjà différer. Pour analyser les dépenses sur une période plus longue, les outils de suivi des dépenses de Claude Code et le décompte des tokens par Claude Code expliquent pourquoi les lignes de cache dominent les décomptes bruts.

Vérifiez que l’agent ne peut pas accéder aux éléments importants pour vous lorsqu’il s’exécute sans surveillance. La section exécuter Claude Code en toute sécurité sur un VPS couvre le compte utilisateur et les flags de permissions.

La propre évaluation du dépôt, à lire avec discernement

Le titre du README est « Fifteen eval rounds, more than 260 agent runs, blind LLM judges that verify by diffing and executing. » Cela constitue davantage d’éléments probants que presque tous les dépôts de skills, et eval/RESULTS.md est documenté tour après tour, avec les échecs conservés. Le contenu est toutefois moins substantiel que ne le laisse penser le nombre annoncé, dès que l’on examine les cellules individuelles derrière les lignes récapitulatives.

[
  {
    "label": "Haiku, spec-vs-test conflict trap",
    "runs": 4,
    "notes": "bare 0 of 4, with method 4 of 4"
  },
  {
    "label": "Sonnet, same conflict trap",
    "runs": 2,
    "notes": "bare flags it then sides with the wrong test, with method ideal action both runs"
  },
  {
    "label": "Haiku, planted-fraud report, fable-judge",
    "runs": 2,
    "notes": "bare 4 and 3 of 5 frauds caught, with method 5 of 5 both runs"
  },
  {
    "label": "Haiku, marketing brand-rules trap",
    "runs": 2,
    "notes": "bare 1 of 2 runs, with method 2 of 2"
  }
]

La plus importante de ces 4 lignes repose sur 4 exécutions. Les trois autres reposent chacune sur 2 exécutions. Le dépôt le précise lui-même dans les limites générales indiquées en tête du journal : « Small n throughout (1-4 runs per cell), LLM judges (blind where multiple outputs are compared, but built on the same frontier model that appears as a baseline), synthetic fixtures, research ground truth only as current as its run date. » Et plus directement : « This log exists so method edits are tested, not so anyone mistakes it for a benchmark. »

Il faut lui en donner crédit. Un auteur qui publie son propre n et qui reconnaît que son judge repose sur le même modèle que celui utilisé comme baseline fait preuve de plus d’honnêteté que la norme dans cette catégorie. Considérez ces chiffres comme la preuve que l’auteur a réellement exécuté les tests et conservé les échecs. Votre propre A/B est ce qui vous renseignera sur votre codebase.

Le README indique tout aussi clairement les cas dans lesquels la méthode n’apporte rien, et c’est son paragraphe le plus utile. Il ne constate aucun gain pour les petites tâches ordinaires sur des modèles capables. Il précise que « the method cannot make a model's facts fresher; bare frontier wins knowledge-heavy research ». Il situe la valeur dans les « traps (authority conflicts, false completion claims, weak executors, unattended runs), not everywhere ». Si votre agent effectue de petites modifications sur un modèle performant et que vous le surveillez, ne vous attendez à mesurer absolument aucun effet. S’il s’agit d’un modèle moins coûteux qui s’exécute sans surveillance, c’est dans ce cas qu’un écart devrait apparaître, ce qui fait également de le choix entre Opus, Sonnet et Haiku un élément de la même décision.

Quand le packaging relève du cargo cult

Quatre critiques méritent d’être formulées, et aucune ne justifie de ne pas utiliser le dépôt.

La présentation va au-delà des éléments disponibles. « How Claude Fable 5 worked » affirme décrire le fonctionnement interne d’un modèle, ce que personne en dehors d’Anthropic ne peut vérifier. La phrase centrale du dépôt elle-même contredit cette présentation : « The quality lives in the structure, the evidence, and the honesty, not in the model. » Si la qualité réside dans la structure, le récit de provenance est décoratif. La procédure se suffit à elle-même et n’a pas besoin d’un mythe fondateur.

Quatre skills représentent davantage de surface que le contenu n’en nécessite. fable-loop reprend une grande partie de fable-method en y ajoutant une orchestration, et sur un harness sans subagents, il se réduit à nouveau à fable-method. Lisez les deux fichiers côte à côte avant d’installer les deux.

Huit domain adapters donnent une largeur que l’eval ne couvre pas. Deux des huit apparaissent dans le log : marketing au round 9 et devops au round 12. Les adapters finance, legal, design et data sont fournis sans round correspondant. L’adapter de votre domaine peut tout de même être bon. Il s’agit cependant d’une version de travail de l’auteur, pas d’un composant ayant résisté à un trap fixture.

Enfin, l’installer ne correspond pas au dépôt concernant ce qu’il fournit : il copie trois skills sur quatre dans ~/.claude/skills. Cet écart est mineur. Il montre aussi que le packaging a évolué plus vite qu’il n’a été relu, ce qu’il faut garder à l’esprit lorsque vous décidez quelle partie adopter immédiatement.

À retenir, même si vous ne gardez rien d’autre

Supprimez l’habillage et quatre règles restent valables, quel que soit l’agent utilisé.

• La citation d’autorisation. Une action irréversible ou tournée vers l’extérieur nécessite les propres mots de l’utilisateur, écrits sur une ligne AUTH:. Un agent qui ne trouve aucune citation n’agit pas.
• La double vérification. Après avoir corrigé un défaut, recherchez dans tout le projet la même construction incorrecte et indiquez le nombre d’occurrences, y compris lorsque ce nombre est nul.
• La vérification par observation. Un contrôle ciblé au vert, exécuté sur un build défaillant, constitue une vérification en échec, pas une validation.
• Un compte rendu centré sur le résultat, en indiquant comme réserve tout ce qui a été ignoré ou laissé sans vérification au lieu de le supprimer discrètement.

Ces quatre règles ne coûtent rien à adopter, et vous pouvez contrôler leur respect avec grep. Commencez par là, mesurez les résultats avec le harness ci-dessus, puis décidez si le reste du dépôt mérite sa part de votre budget de contexte. Si vous souhaitez fournir à un agent un contexte permanent sur le projet plutôt qu’une méthode de travail, un DESIGN.md que les agents lisent avant de modifier le projet constitue l’approche complémentaire.

FAQ

La méthode Fable fonctionne-t-elle avec des modèles autres que Claude ?

Le texte de la méthode, oui. Il s’agit d’un prompt ordonné qui ne contient aucun code spécifique à un modèle, et le dépôt fournit AGENTS.md sous forme de copie portable pour Codex, Cursor, aider ou un prompt système brut. Deux éléments ne sont pas portables. Les déclencheurs /fable-method et /fable-judge sont des commandes slash de Claude Code ; ailleurs, vous invoquez la méthode en la décrivant. Et fable-loop suppose un harness capable de lancer des sous-agents en parallèle sur différents modèles ; sans cela, l’exécution est séquentielle et vous obtenez fable-method avec des étapes supplémentaires.

L’exécution de ces skills consomme-t-elle davantage de tokens ?

Oui, et la quantité dépend de la façon dont vous les chargez. Lorsqu’elles sont installées comme skills, leur contenu n’est chargé que si la description correspond à la tâche ; une requête sans rapport ne coûte donc presque rien. Si vous les collez dans un prompt système, les quelque 2,600 mots de AGENTS.md sont inclus dans chaque requête. L’exécution elle-même coûte aussi davantage, car la méthode demande une phase d’orientation avant la modification, des éléments probants avant la décision et une véritable vérification ensuite. Mesurez-le : exécutez la même tâche avec --output-format json dans les deux cas, puis comparez le champ total_cost_usd.

Quelle version de fable-method dois-je installer, et pourquoi la figer ?

Exécutez git checkout v1.4.0 avant l’installation. Ce tag date du 2026-07-15 et était encore le plus récent en août 2026. Le dépôt avait publié cinq releases au cours des neuf jours précédents, et v1.4.0 avait modifié les règles de routage elles-mêmes. Si vous suivez main pendant vos mesures, votre exécution de contrôle et votre exécution de test peuvent lire des instructions différentes, ce qui rend la comparaison inutilisable. Notez le tag avec vos résultats.

L’eval du dépôt est-elle un benchmark fiable ?

Considérez-la comme un journal des modifications de la méthode, ce que son auteur indique lui-même : "This log exists so method edits are tested, not so anyone mistakes it for a benchmark." Les limites sont indiquées en tête du fichier : 1 à 4 exécutions par cellule, des fixtures synthétiques et des juges LLM reposant sur le même modèle frontier que celui qui sert aussi de baseline. Les campagnes sont réelles et les expériences échouées sont conservées, ce que la plupart des dépôts publient rarement. Il ne s’agit toutefois pas d’une mesure de ce qui se produira sur votre codebase ; exécutez donc vous-même la comparaison entre les deux cas.