Lar

Skill

Produtividade e fluxo de trabalho

efficient-fable

BuilderIO/skills

Coordenar pesquisas, programação e testes que exigem grande uso de tokens, delegando tarefas delimitadas a subagentes mais econômicos, enquanto se reserva o Claude Fable para a arquitetura, a síntese e a revisão final.

...Expandir tudo

Tempo atualizado 6 de Setembro de 2026

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

Fable Eficiente

Utilize o Claude Fable como orquestrador, arquiteto, sintetizador e juiz final. Utilize subagentes mais baratos para pesquisas com grande volume de tokens, programação, testes e resumos que não exijam o julgamento completo do Fable.

Onde o Fable se destaca

Reserve o Fable para:

Decompor tarefas ambíguas em partes paralelas bem definidas.
Compromissos entre arquitetura, produto e segurança.
Analisar relatórios conflitantes de subagentes e decidir o que é relevante.
Integrar implementações parciais em um plano coerente.
Revisão final, avaliação de riscos e síntese voltada para o usuário.

Padrão de delegação

Identifique o risco de uso excessivo de tokens: grandes pesquisas no repositório, logs extensos, documentação abrangente ou edições repetitivas.
Divida o trabalho independente entre subagentes antes de ler tudo sozinho.
Use modelos mais econômicos para varreduras de pesquisa, inventário, resumos de busca, caça a bugs específica, passagens de navegador/teste, redução de resultados de teste e edições de código delimitadas.
Solicite aos subagentes evidências concisas: arquivos, referências de linha, comandos executados, diferenças, incertezas e condições de parada que eles encontraram.
Gaste tokens do Fable na camada de decisão: compare resultados, resolva conflitos, escolha o caminho de implementação e revise o patch final.

Dê preferência a subagentes paralelos quando as fatias não dependerem umas das outras. Mantenha o trabalho bloqueante ou altamente acoplado em nível local.

Pacotes de transferência

Escreva prompts delegados como se o subagente não tivesse nenhum contexto útil de conversa. Inclua apenas o contexto de que ele precisa:

O caminho do repositório e o objetivo exato.
Os arquivos, pacotes ou superfícies no escopo e tudo o que estiver explicitamente fora do escopo.
O formato de evidência a ser retornado: arquivos, referências de linha, comandos, comparações, falhas, capturas de tela e incertezas.
Os comandos de verificação ou fluxos do navegador a serem executados, além de como o sucesso deve ser, quando isso for determinável.
Condições de interrupção: se o código não corresponder ao prompt, um comando falhar após uma tentativa razoável ou a tarefa precisar de arquivos fora do escopo, interrompa e relate, em vez de improvisar.

Avaliação do Trabalho Delegado

Trate os relatórios dos subagentes como pistas, não como fatos. Antes de usar uma descoberta de alto impacto, abrir um PR ou informar ao usuário que o trabalho está concluído, o Fable deve reabrir os arquivos importantes citados, confirmar as referências de linha ou falhas relevantes e revisar o diff final em relação à tarefa. Deixe que os agentes mais leves coletem sinais; mantenha o julgamento da veracidade com o Fable.

Cenários comuns

Trate isso como padrões flexíveis, não como regras rígidas:

Pesquisa: peça aos agentes mais leves que analisem documentos, estado da arte, APIs e superfícies do repositório; o Fable decide quais evidências alteram o plano.
Programação: atribua aos agentes mais simples edições delimitadas ou patches candidatos; o Fable é responsável pela coordenação de arquivos compartilhados, integração e revisão final.
Testes: peça ao Fable para sugerir a direção da validação e os scripts ou verificações no navegador que sejam relevantes. Deixe que os agentes mais leves executem testes direcionados, fluxos no navegador, capturas de tela e redução de logs; em seguida, relatem comandos exatos, falhas, causas prováveis e se as falhas parecem esporádicas, relacionadas ao ambiente ou reais.
Depuração: use agentes mais baratos para agrupar logs, reproduzir problemas e tentar pequenas correções; o Fable decide qual diagnóstico é mais confiável.

Se uma tarefa for pequena ou se a própria validação exigir um julgamento delicado, mantenha-a com o Fable.

Diagrama

Use assets/fable-orchestrator.excalidraw quando uma explicação visual ajudar.

Afirmações

Para trabalhos com base de código extensa, é razoável descrever isso como até 3 a 5 vezes mais econômico e 2 a 4 vezes mais rápido quando partes independentes de pesquisa, codificação ou testes podem ser executadas em paralelo. Trate essas estimativas como dependentes da carga de trabalho, e não como garantias.

Bom texto de lançamento:

Torne o Claude Fable mais eficiente usando subagentes mais econômicos para pesquisa, programação e testes com grande volume de tokens, reservando o Fable para julgamento, arquitetura, síntese e revisão final.

Ver no 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.