Communitygithub.com

joey114132/fable-workflow-skill

Fable Workflow — une compétence portable pour agents Claude Code / Cursor qui force tout modèle (Opus, Sonnet, Haiku, Fable) à trouver les inconnues avant de construire, pas après.

Qu'est-ce que fable-workflow-skill ?

Fable Workflow est une compétence pour agents IA (Claude Code, Cursor) conçue pour les modèles puissants (dits « Mithril-class »). Elle résout le problème fondamental suivant : même le modèle le plus capable peut produire des résultats déviants si la « carte » mentale de l'utilisateur (le plan, le prompt) ne correspond pas au « territoire » réel (le code, les contraintes). La compétence formalise un cycle en cinq étapes : (1) utiliser des outils (scripts, Bash) plutôt que la mémoire pour les tâches précises, (2) identifier explicitement toutes les inconnues (connues-inconnues, inconnues-inconnues) avant de coder, (3) construire en journalisant chaque écart, (4) vérifier en exécutant réellement le résultat (pas seulement en raisonnant), et (5) rester dans la boucle en interrogeant l'utilisateur sur les changements. Elle inclut des hooks optionnels (via `FABLE_STRICT=1`) qui bloquent une fin de tâche infondée, un module de décomposition des objectifs (`scripts/goals.py`), et des variantes allégées pour petits modèles. La valeur est front-loaded : le gain principal vient de la phase pré-construction (découverte des inconnues et propositions de variantes), et la vérification par exécution est obligatoire pour éviter de confondre un bon raisonnement avec une réponse correcte.

Compatible avec✓Claude Code~Codex CLI✓Cursor✓Antigravity
npx skills add joey114132/fable-workflow-skill

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Fable Workflow

Une méthode de travail pour les modèles capables (classe « Mithril »). Le modèle est assez puissant pour parcourir un vaste espace de solutions par lui-même — le goulot d'étranglement n'est donc plus sa capacité, mais le fait que la carte de l'humain corresponde au territoire avant que le modèle ne se mette en mouvement. Cette compétence comble cet écart.

Les modèles de prompts se trouvent dans prompts.md — lisez-le quand vous avez besoin du libellé exact. Installée comme plugin Claude Code, des hooks optionnels imposent cela — une porte de vérification Stop qui bloque un « terminé » sans fondement (opt-in via FABLE_STRICT=1). Voir hooks/. Travail multi-étapes → la porte d'achèvement (scripts/goals.py, voir completion-gate.md) décompose en objectifs et refuse un « terminé » sans fondement.

L'idée centrale

La carte n'est pas le territoire. Le plan / spec / prompt dans votre tête est la carte. Le vrai code source et les contraintes sont le territoire. Chaque endroit où le modèle rencontre un territoire que la carte ne couvre pas est une inconnue — un point de décision non spécifié. Un modèle capable en rencontre BEAUCOUP parce qu'il explore largement. Laissé à lui-même, il devine silencieusement ; chaque devinette silencieuse est un endroit où le résultat peut dévier de ce que l'utilisateur voulait. Donc : révélez d'abord les inconnues, décidez-les explicitement, puis construisez. Cela vaut dans tous les domaines — une question de recherche vague, un brief de design ambigu, ou une analyse sous-spécifiée cachent tous les mêmes décisions non spécifiées.

La boucle

1. Débrider — utilisez les outils, pas la mémoire

Les modèles capables deviennent plus intelligents de manière irrégulière : une question qu'ils ratent de mémoire, ils la réussissent en écrivant un script (ex. « quels noms de Pokémon se terminent par 'aw' ? » → récupérer la liste, la filtrer). Donc pour toute tâche d'énumération / comptage / recherche / chaîne précise, utilisez un outil (Bash, un script, une recherche) plutôt que de répondre de mémoire. Préférez un petit jeu d'instructions avec contexte plutôt qu'une longue liste de contraintes « ne faites pas » — les contraignent un modèle qui est plus imaginatif que les exemples que vous lui donneriez.

2. Trouver les inconnues — avant d'écrire le vrai code

Classez le problème en : connus-connus (vous les écrirez dans le prompt), connus-inconnus (vous savez que vous n'avez pas décidé), inconnus-connus (si évidents que vous ne les avez pas dits — vous les reconnaîtrez en les voyant), inconnus-inconnus (jamais envisagés). Utilisez ces manœuvres pour faire remonter la ligne du bas à la lumière (prompts.md contient des versions copier-coller) :

  • Passe angles morts — « fais une passe angles morts sur ce module/domaine ; liste mes inconnus-inconnus et où sont les pièges. » Pointez-le vers des git diffs, Slack, des docs pour le contexte. Idéal pour les nouvelles codebases et les nouveaux domaines.
  • Interviewez-moi — faites-vous interviewer par le modèle, en priorisant les questions qui changeraient l'architecture. Donnez-lui du contexte sur vous et l'étape à laquelle vous êtes.
  • Variantes pour décisions subjectives — pour tout ce qui est « je le reconnaîtrai en le voyant » (design, format de sortie, forme de l'API), demandez N options délibérément différentes pour réagir, pas une seule.
  • Références comme cartes — au lieu d'écrire toute la spec, donnez-lui un exemple de code ou une maquette qui représente la cible (« lis ceci, puis construis dans son esprit »). Une deuxième carte vaut mieux que de la prose.

3. Construire — mais journaliser les écarts

Pendant la construction, journalisez chaque inconnue rencontrée et le choix fait (une liste « hypothèses / notes d'implémentation »). C'est votre piste d'audit de là où la carte et le territoire ont divergé.

4. Vérifier — rendez-le réel, ne vous contentez pas de l'affirmer

Avant de déclarer terminé, exécutez le résultat — un bon raisonnement ne garantit pas une bonne réponse. Code : exécutez-le, ou écrivez la plus petite vérification qui échoue si la logique casse, et regardez la sortie. Recherche/analyse : testez l'affirmation clé contre une source. Design/écriture : mettez-le devant le vrai contexte. C'est l'étape qui transforme un bon plan en un résultat correct. Quand la vérification échoue, ne réessayez pas en une seule fois — entrez dans une boucle de correction bornée (tentative → vérification → diagnostic → répéter) avec des conditions d'arrêt explicites. Voir loop-engineering.md.

5. Rester dans la boucle — continuez à posséder le travail

Avant de merger/PR, faites-vous interroger par le modèle sur ce qui a changé, afin de pouvoir réellement représenter le travail. Construire est maintenant bon marché ; générer de la valeur reste la partie difficile — rester dans la boucle est la façon de continuer à diriger vers la valeur au lieu de simplement livrer du mouvement.

Règles

  • Spec vague ou territoire inconnu → faites l'étape 2 avant l'étape 3. N'implémentez pas la première interprétation en silence.
  • Énumération / comptage / recherche précise → scriptez-le, ne le rappelez pas.
  • Décision subjective → proposez des variantes, ne choisissez pas une seule en espérant.
  • Terminez toujours une construction par une liste d'hypothèses journalisée et (interactivement) un interrogatoire.
  • Vérifiez le résultat, ne l'affirmez pas — exécutez / vérifiez / testez la sortie avant de déclarer terminé. Un bon plan n'est pas une réponse correcte (voir Pièges).
  • One-shot / autonome (impossible de demander) ? Révélez quand même les inconnues sous forme de liste écrite, choisissez des valeurs par défaut sensées, et journalisez-les — la révélation est le but, pas la demande.

Pièges

  • La valeur de la compétence est front-loaded, et facile à sauter. Le bénéfice est dans la phase pré-construction (inconnues, variantes). Sous pression temporelle, les modèles sautent directement au code — c'est exactement là que l'écart carte/territoire mord. Si vous avez sauté l'étape 2, vous n'avez pas utilisé la compétence.
  • « Révéler les inconnues » ≠ « poser 20 questions et stagner. » Priorisez les quelques inconnues qui changeraient l'architecture ou la réponse. Les questions triviales gaspillent la boucle.
  • Ne pas sur-appliquer aux tâches triviales. Un changement d'une ligne ou une correction évidente n'a pas besoin de passe angles morts. YAGNI s'applique aussi au processus — c'est pour le travail non trivial.
  • Les variantes doivent être vraiment différentes, pas trois nuances de la même idée. Trois options quasi identiques ne donnent rien à réagir à l'humain.
  • Journaliser les hypothèses n'est pas une couverture facultative. C'est l'artefact qui permet à l'humain d'attraper une mauvaise supposition avant qu'elle ne soit livrée. Une hypothèse non journalisée est un pari silencieux.
  • Un plan révélé n'est pas une réponse vérifiée. La vraie limite de la méthode : elle améliore de manière fiable le raisonnement, mais raisonnement ≠ résultat correct — surtout pour le code. Ne vous arrêtez pas à une belle liste d'INCONNUES et une prose confiante ; l'étape 4 (vérification) est obligatoire — exécutez la sortie.
  • Une boucle de correction a besoin de sorties. Réessayer une étape qui échoue sans nouvelle hypothèse, ou boucler après une inconnue découverte, est un blocage — pas un progrès. Limitez les itérations, exigez un signal qui bouge à chaque tour, et passez à l'humain quand c'est bloqué (loop-engineering.md).
  • Les modèles faibles/petits (≤ ~8B) ont besoin de la variante allégée. Le prompt complet « révélez toutes les inconnues, puis dérivez le code » encombre la capacité d'un petit modèle et dégrade son implémentation — il raisonne plus mais code moins bien. Pour ceux-ci, limitez les inconnues à 2–3 et ancrez avec une référence à adapter plutôt qu'à dériver (voir prompts.md → Petits modèles / locaux). Les modèles capables/de raisonnement n'en ont pas besoin.

Skills associés