Hogar

Skill

Productividad y flujo de trabajo

efficient-fable

BuilderIO/skills

Coordina las tareas de investigación, programación y pruebas que requieren un uso intensivo de tokens delegando tareas delimitadas a subagentes más económicos, mientras se reserva a Claude Fable para la arquitectura, la síntesis y la revisión final.

...Expandir todo

Tiempo actualizado 6 de septiembre de 2026

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

Fable eficiente

Utiliza a Claude Fable como coordinador, arquitecto, sintetizador y juez final. Utiliza subagentes más económicos para tareas de investigación, programación, pruebas y resumen que requieran un gran volumen de tokens y que no necesiten el criterio completo de Fable.

Dónde destaca Fable

Reserva a Fable para:

Descomponer tareas ambiguas en partes paralelas bien definidas.
Las decisiones sobre arquitectura, producto y seguridad.
Leer informes contradictorios de subagentes y decidir qué es lo importante.
Integrar implementaciones parciales en un plan coherente.
Revisión final, evaluación de riesgos y síntesis orientada al usuario.

Patrón de delegación

Identifica el riesgo de «token costoso»: búsquedas extensas en el repositorio, registros largos, documentación extensa o ediciones repetitivas.
Divide el trabajo independiente en subagentes antes de leerlo todo tú mismo.
Utiliza modelos más económicos para análisis de investigación, inventario, resúmenes de búsqueda, búsquedas específicas de errores, pasadas de navegador/pruebas, reducción de resultados de pruebas y ediciones de código limitadas.
Pide a los subagentes pruebas concisas: archivos, referencias de líneas, comandos ejecutados, diferencias, incertidumbres y condiciones de parada con las que se hayan encontrado.
Gasta tokens de Fable en la capa de decisión: compara resultados, resuelve conflictos, elige la vía de implementación y revisa el parche final.

Da preferencia a los subagentes paralelos cuando las partes no dependan unas de otras. Mantén el trabajo bloqueante o altamente acoplado a nivel local.

Paquetes de traspaso

Escribe las indicaciones delegadas como si el subagente no dispusiera de ningún contexto de chat útil. Incluye solo el contexto que necesita:

La ruta del repositorio y el objetivo exacto.
Los archivos, paquetes o superficies incluidos en el ámbito y cualquier elemento que quede explícitamente fuera de él.
El formato de evidencia que se debe devolver: archivos, referencias de línea, comandos, diferencias, fallos, capturas de pantalla e incertidumbre.
Los comandos de verificación o los flujos del navegador que se deben ejecutar, además de cómo debería ser el resultado satisfactorio cuando sea posible determinarlo.
Condiciones de detención: si el código no coincide con la indicación, un comando falla tras un número razonable de reintentos, o la tarea requiere archivos fuera del ámbito, detente e informa en lugar de improvisar.

Revisión del trabajo delegado

Trata los informes de los subagentes como pistas, no como hechos. Antes de utilizar un hallazgo de gran impacto, abrir una solicitud de incorporación de cambios (PR) o comunicar al usuario que el trabajo está terminado, Fable debe volver a abrir los archivos importantes citados, confirmar las referencias de línea o los fallos pertinentes y revisar la comparación final con respecto a la tarea. Deja que los agentes más ligeros recopilen información; reserva el juicio sobre la veracidad a Fable.

Escenarios habituales

Trátalos como valores predeterminados flexibles, no como reglas rígidas:

Investigación: pide a los agentes más ligeros que analicen documentos, estado de la técnica, API y superficies del repositorio; Fable decide qué pruebas modifican el plan.
Programación: asigna a los agentes más económicos ediciones limitadas o parches candidatos; Fable se encarga de la coordinación de archivos compartidos, la integración y la revisión final.
Pruebas: haz que Fable sugiera la dirección de la validación y los scripts o comprobaciones del navegador que sean relevantes. Deja que los agentes más ligeros ejecuten pruebas específicas, flujos de navegación, capturas de pantalla y reducción de registros, y luego informen de los comandos exactos, los fallos, las causas probables y si los fallos parecen esporádicos, debidos al entorno o reales.
Depuración: utiliza agentes más económicos para agrupar registros, reproducir problemas e intentar pequeñas correcciones; Fable decide qué diagnóstico es más fiable.

Si una tarea es muy sencilla o la propia validación requiere un criterio delicado, déjala en manos de Fable.

Diagrama

Utiliza assets/fable-orchestrator.excalidraw cuando una explicación visual resulte útil.

Afirmaciones

Para trabajos con una base de código extensa, es razonable describir esto como hasta 3-5 veces más rentable y 2-4 veces más rápido cuando las partes independientes de investigación, programación o pruebas pueden ejecutarse en paralelo. Trata estas cifras como estimaciones dependientes de la carga de trabajo, no como garantías.

Buen texto de lanzamiento:

Haz que Claude Fable sea más eficiente utilizando subagentes más económicos para la investigación, la programación y las pruebas que requieren un gran número de tokens, y reserva Fable para la toma de decisiones, la arquitectura, la síntesis y la revisión final.

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