Maison

Skill

Productivité et flux de travail

efficient-fable

BuilderIO/skills

Coordonner les activités de recherche, de codage et de test nécessitant un nombre important de jetons en déléguant des tâches bien délimitées à des sous-agents moins coûteux, tout en réservant Claude Fable à l'architecture, à la synthèse et à la révision finale.

...Développer tout

Heure mise à jour 6 septembre 2026

# orchestration # delegation # claude fable # cost efficiency # parallel execution # subagents

Fable efficace

Utilisez Claude Fable comme orchestrateur, architecte, synthétiseur et juge final. Utilisez des sous-agents moins coûteux pour la recherche, le codage, les tests et la synthèse, qui nécessitent beaucoup de tokens mais ne requièrent pas le jugement complet de Fable.

Les domaines où Fable excelle

Réservez Fable pour :

La décomposition de tâches ambiguës en sous-tâches parallèles bien définies.
Les compromis en matière d’architecture, de produit et de sécurité.
La lecture de rapports contradictoires émanant des sous-agents et la détermination des éléments pertinents.
L'intégration d'implémentations partielles en un plan cohérent.
Révision finale, évaluation des risques et synthèse destinée aux utilisateurs.

Modèle de délégation

Identifiez le risque lié aux « tokens coûteux » : recherche dans un grand dépôt, journaux volumineux, documentation exhaustive ou modifications répétitives.
Répartissez les tâches indépendantes entre des sous-agents avant de tout lire vous-même.
Utilisez des modèles moins coûteux pour les analyses de recherche, l’inventaire, les résumés de recherche, les chasses aux bugs ciblées, les passes de navigation/tests, la réduction des résultats de test et les modifications de code délimitées.
Demandez aux sous-agents des preuves concises : fichiers, références de lignes, commandes exécutées, différences, incertitudes et conditions d’arrêt qu’ils ont rencontrées.
Dépensez des jetons Fable au niveau de la couche décisionnelle : comparez les résultats, résolvez les conflits, choisissez la voie de mise en œuvre et revoyez le patch final.

Privilégiez les sous-agents parallèles lorsque les tranches ne dépendent pas les unes des autres. Conservez les tâches bloquantes ou fortement couplées au niveau local.

Paquets de transfert

Rédigez les invites déléguées comme si le sous-agent ne disposait d’aucun contexte de conversation utile. N’incluez que le contexte dont il a besoin :

Le chemin d’accès au dépôt et l’objectif exact.
Les fichiers, paquets ou surfaces concernés, ainsi que tout ce qui est explicitement exclu du champ d’application.
Le format des preuves à renvoyer : fichiers, références de lignes, commandes, différences, échecs, captures d’écran et incertitudes.
Les commandes de vérification ou les flux de navigation à exécuter, ainsi que la définition de la réussite lorsque celle-ci est identifiable.
Conditions d’arrêt : si le code ne correspond pas à la consigne, si une commande échoue après un nombre raisonnable de tentatives, ou si la tâche nécessite des fichiers hors du champ d’application, arrêtez-vous et signalez le problème au lieu d’improviser.

Vérification du travail délégué

Traitez les rapports des sous-agents comme des pistes, et non comme des faits avérés. Avant d’utiliser une découverte à fort impact, d’ouvrir une demande de pull (PR) ou d’indiquer à l’utilisateur que le travail est terminé, Fable doit rouvrir les fichiers importants cités, confirmer les références de lignes ou les échecs pertinents, et examiner le diff final par rapport à la tâche. Laissez les agents plus légers collecter les signaux ; réservez le jugement de vérité à Fable.

Scénarios courants

Considérez-les comme des valeurs par défaut souples, et non comme des règles rigides :

Recherche : demandez aux agents plus légers d’analyser les documents, l’état de la technique, les API et les surfaces du dépôt ; Fable décide quelles preuves modifient le plan.
Codage : confiez aux agents moins coûteux des modifications limitées ou des correctifs candidats ; Fable se charge de la coordination des fichiers partagés, de l’intégration et de la révision finale.
Tests : demandez à Fable de suggérer l’orientation de la validation ainsi que les scripts ou les vérifications de navigateur pertinents. Laissez les agents plus légers exécuter des tests ciblés, des flux de navigation, des captures d’écran et la réduction des journaux, puis signaler les commandes exactes, les échecs, les causes probables, et indiquer si les échecs semblent aléatoires, liés à l’environnement ou réels.
Débogage : utilisez des agents moins coûteux pour regrouper les journaux, reproduire les problèmes et essayer de petites corrections ; Fable décide quel diagnostic est le plus fiable.

Si une tâche est minime ou si la validation elle-même nécessite un jugement subtil, confiez-la à Fable.

Schéma

Utilisez assets/fable-orchestrator.excalidraw lorsqu’une explication visuelle est utile.

Affirmations

Pour les travaux impliquant une base de code importante, il est raisonnable de décrire cela comme étant jusqu’à 3 à 5 fois plus rentable et 2 à 4 fois plus rapide lorsque des phases indépendantes de recherche, de codage ou de test peuvent s’exécuter en parallèle. Considérez ces chiffres comme des estimations dépendantes de la charge de travail, et non comme des garanties.

Bon texte de lancement :

Rendez Claude Fable plus efficace en utilisant des sous-agents moins coûteux pour la recherche, le codage et les tests nécessitant un grand nombre de tokens, et réservez Fable pour le jugement, l’architecture, la synthèse et la révision finale.

Voir sur GitHub

---
name: efficient-fable
description: Orchestrate token-heavy research, coding, and testing by delegating bounded tasks to cheaper subagents while reserving Claude Fable for architecture, synthesis, and final review.
---

# Efficient Fable

Use Claude Fable as the orchestrator, architect, synthesizer, and final judge.
Use cheaper subagents for token-heavy research, coding, testing, and
summarization that do not require Fable's full judgment.

## Where Fable Shines

Reserve Fable for:

- Decomposing ambiguous work into clean parallel slices.
- Architecture, product, and safety tradeoffs.
- Reading conflicting subagent reports and deciding what matters.
- Integrating partial implementations into one coherent plan.
- Final review, risk assessment, and user-facing synthesis.

## Delegation Pattern

1. Name the expensive-token risk: large repo search, long logs, broad docs, or
   repetitive edits.
2. Split independent work into subagents before reading everything yourself.
3. Use cheaper models for research scans, inventory, search summaries, narrow
   bug hunts, browser/testing passes, test output reduction, and bounded code
   edits.
4. Ask subagents for concise evidence: files, line references, commands run,
   diffs, uncertainties, and stop conditions they hit.
5. Spend Fable tokens on the decision layer: compare results, resolve conflicts,
   choose the implementation path, and review the final patch.

Prefer parallel subagents when the slices do not depend on each other. Keep
blocking or highly coupled work local.

## Handoff Packets

Write delegated prompts as if the subagent has no useful chat context. Include
only the context it needs:

- The repo path and exact objective.
- The files, packages, or surfaces in scope and anything explicitly out of
  scope.
- The evidence format to return: files, line refs, commands, diffs, failures,
  screenshots, and uncertainty.
- The verification commands or browser flows to run, plus what success should
  look like when that is knowable.
- Stop conditions: if the code does not match the prompt, a command fails after
  a reasonable retry, or the task needs out-of-scope files, stop and report
  instead of improvising.

## Vetting Delegated Work

Treat subagent reports as leads, not facts. Before using a high-impact finding,
opening a PR, or telling the user the work is done, Fable should reopen the
important cited files, confirm the relevant line refs or failures, and review
the final diff against the task. Let lighter agents gather signal; keep
truth-judgment with Fable.

## Common Scenarios

Treat these as soft defaults, not rigid rules:

- Research: ask lighter agents to scan docs, prior art, APIs, and repo surfaces;
  Fable decides what evidence changes the plan.
- Coding: give cheaper agents bounded edits or candidate patches; Fable owns
  shared-file coordination, integration, and final review.
- Testing: have Fable suggest the validation direction and the scripts or
  browser checks that matter. Let lighter agents run targeted tests, browser
  flows, screenshots, and log reduction, then report exact commands, failures,
  likely causes, and whether failures look flaky, environmental, or real.
- Debugging: use cheaper agents to cluster logs, reproduce issues, and try
  small fixes; Fable decides which diagnosis is most trustworthy.

If a task is tiny or the validation itself needs delicate judgment, keep it
with Fable.

## Diagram

Use `assets/fable-orchestrator.excalidraw` when a visual explanation helps.

## Claims

For codebase-heavy work, it is reasonable to describe this as up to 3-5x more
cost-efficient and 2-4x faster when independent research, coding, or testing
slices can run in parallel. Treat those as workload-dependent estimates, not
guarantees.

Good launch copy:

> Make Claude Fable more efficient by using cheaper subagents for token-heavy
> research, coding, and testing, saving Fable for judgment, architecture,
> synthesis, and final review.