Communitygithub.com

joey114132/fable-workflow-skill

Fable Workflow: una skill portable para Claude Code / Cursor que obliga a cualquier modelo (Opus, Sonnet, Haiku, Fable) a descubrir las incógnitas antes de construir, no después.

¿Qué es fable-workflow-skill?

Fable Workflow es una skill de agente portable diseñada para modelos de capacidad alta ('clase Mithril') como Opus, Sonnet, Haiku y Fable, compatible con Claude Code y Cursor. Su propósito principal es cerrar la brecha entre lo que el desarrollador imagina (el mapa) y el código o sistema real (el territorio) antes de comenzar a construir. La skill estructura el trabajo en un ciclo de cinco pasos: 1) Desencadenar al modelo para que use herramientas en lugar de memoria; 2) Encontrar las incógnitas clasificándolas en conocidas, desconocidas conocidas y desconocidas desconocidas mediante técnicas como el pase de puntos ciegos, las entrevistas interactivas y las variantes de diseño; 3) Construir registrando cada desviación en una lista de asunciones; 4) Verificar el resultado ejecutándolo en lugar de solo afirmarlo; 5) Mantenerse en el ciclo con un cuestionario final. Incluye reglas estrictas, advertencias sobre trampas comunes y soporte para modelos pequeños con una variante ligera. Puede integrarse mediante hooks opcionales que bloquean respuestas sin verificación (con la variable de entorno FABLE_STRICT=1).

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

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Fable Workflow

Un método de trabajo para modelos capaces ("clase Mithril"). El modelo es lo suficientemente potente para recorrer un espacio de soluciones enorme por sí solo; por lo tanto, el cuello de botella ya no es su capacidad, sino si el mapa del humano coincide con el territorio antes de que el modelo comience a moverse. Esta skill cierra esa brecha.

Las plantillas de prompts viven en prompts.md — léelo cuando necesites la redacción exacta. Instalado como complemento de Claude Code, los hooks opcionales hacen cumplir esto — una puerta de verificación Stop que bloquea un "hecho" sin fundamento (opt-in mediante FABLE_STRICT=1). Ver hooks/. Trabajo de varios pasos → la puerta de finalización (scripts/goals.py, ver completion-gate.md) descompone en objetivos y rechaza un "hecho" sin fundamento.

La idea central

El mapa no es el territorio. El plan/especificación/prompt en tu cabeza es el mapa. El código base real y las restricciones son el territorio. Cada lugar donde el modelo choca con el territorio que el mapa no cubría es una incógnita — un punto de decisión no especificado. Un modelo capaz encuentra MUCHAS de ellas porque explora ampliamente. Si se deja solo, adivina en silencio; cada adivinanza silenciosa es un lugar donde el resultado puede desviarse de lo que el usuario quería. Por lo tanto: primero descubre las incógnitas, decídelas explícitamente, luego construye. Esto se aplica en cualquier ámbito — una pregunta de investigación vaga, un resumen de diseño ambiguo o un análisis poco especificado esconden las mismas decisiones no especificadas.

El ciclo

1. Desencadenar — alcanza las herramientas, no la memoria

Los modelos capaces se vuelven más inteligentes de formas desiguales: una pregunta que fallan desde la memoria la resuelven escribiendo un script (p. ej., "¿qué nombres de Pokémon terminan en 'aw'?" → obtener la lista, filtrarla). Así que en cualquier tarea de enumeración / conteo / búsqueda / cadena precisa, usa una herramienta (Bash, un script, una búsqueda) en lugar de responder desde la memoria. Prefiere un conjunto de instrucciones más pequeño con contexto a una larga lista de restricciones "no hagas" — las restricciones limitan a un modelo que es más imaginativo que los ejemplos que le darías.

2. Encontrar las incógnitas — antes de escribir lo real

Clasifica el problema en: conocidas-conocidas (las escribirás en el prompt), conocidas-desconocidas (sabes que no has decidido), desconocidas-conocidas (tan obvias que no lo dijiste — las reconocerás cuando las veas), desconocidas-desconocidas (nunca consideradas). Usa estos movimientos para sacar la fila inferior a la luz (prompts.md tiene versiones para copiar y pegar):

  • Pase de puntos ciegos — "haz un pase de puntos ciegos en este módulo/dominio; enumera mis desconocidas-desconocidas y dónde están los problemas." Apúntalo a diffs de git, Slack, documentación como contexto. Genial para bases de código nuevas y campos nuevos.
  • Entrevístame — haz que el modelo te entreviste, priorizando preguntas que cambiarían la arquitectura. Dale contexto sobre ti y la etapa en la que te encuentras.
  • Variantes para decisiones subjetivas — para cualquier cosa "lo sabré cuando lo vea" (diseño, formato de salida, forma de la API), pide N opciones deliberadamente diferentes para reaccionar, no una sola.
  • Referencias como mapas — en lugar de escribir toda la especificación, entrégale código de ejemplo o un mockup que represente el objetivo ("lee esto, luego construye en su espíritu"). Un segundo mapa es mejor que la prosa.

3. Construir — pero registra las desviaciones

Mientras construyes, registra cada incógnita que encuentre y la decisión que tomó (una lista de "suposiciones / notas de implementación"). Esa es tu pista de auditoría de dónde divergieron el mapa y el territorio.

4. Verificar — hazlo real, no solo lo afirmes

Antes de darlo por terminado, ejecuta el resultado — un buen razonamiento no garantiza una buena respuesta. Código: ejecútalo, o escribe la verificación más pequeña que falle si la lógica se rompe, y mira la salida. Investigación/análisis: prueba la afirmación clave contra una fuente. Diseño/escritura: ponlo frente al contexto real. Este es el paso que convierte un plan sólido en un resultado correcto. Cuando la verificación falla, no intentes de nuevo con un solo disparo — entra en un bucle de corrección acotado (intentar → verificar → diagnosticar → repetir) con condiciones de parada explícitas. Ver loop-engineering.md.

5. Mantenerse en el ciclo — sigue siendo el dueño

Antes de fusionar/PR, haz que el modelo te examine sobre lo que cambió, para que puedas representar realmente el trabajo. Construir ahora es barato; generar valor sigue siendo la parte difícil — mantenerse en el ciclo es cómo sigues dirigiendo hacia el valor en lugar de solo enviar movimiento.

Reglas

  • Especificación vaga o territorio desconocido → haz el paso 2 antes del paso 3. No implementes la primera interpretación en silencio.
  • Enumeración / conteo / búsqueda precisa → escríbelo como script, no lo recuerdes.
  • Decisión subjetiva/de gusto → ofrece variantes, no elijas una y esperes.
  • Siempre termina una construcción con una lista de suposiciones registrada y (interactivamente) un examen de vuelta.
  • Verifica el resultado, no lo afirmes — ejecuta / verifica / maneja la salida antes de darlo por terminado. Un buen plan no es una respuesta correcta (ver Trampas).
  • ¿Un solo disparo / autónomo (no puedes preguntar)? Sigue sacando las incógnitas como una lista escrita, elige valores predeterminados sensatos y regístralas — lo importante es sacarlas a la luz, no preguntar.

Trampas

  • El valor de la skill está al inicio, y es fácil saltárselo. La recompensa está en la fase previa a la construcción (incógnitas, variantes). Bajo presión de tiempo, los modelos saltan directamente al código — es exactamente cuando la brecha mapa/territorio muerde. Si te saltaste el paso 2, no usaste la skill.
  • "Descubrir incógnitas" ≠ "hacer 20 preguntas y estancarse." Prioriza las pocas incógnitas que cambiarían la arquitectura o la respuesta. Las preguntas triviales desperdician el ciclo.
  • No lo apliques en exceso a tareas triviales. Un cambio de una línea o una corrección obvia no necesita un pase de puntos ciegos. YAGNI también se aplica al proceso — esto es para trabajo no trivial.
  • Las variantes deben ser genuinamente diferentes, no tres tonos de la misma idea. Tres opciones casi idénticas no le dan al humano nada para reaccionar.
  • Registrar suposiciones no es una cobertura opcional. Es el artefacto que permite al humano detectar una suposición incorrecta antes de que se envíe. Una suposición no registrada es una apuesta silenciosa.
  • Un plan descubierto no es una respuesta verificada. El límite real del método: mejora de manera confiable el razonamiento, pero el razonamiento ≠ un resultado correcto — especialmente para código. No te detengas en una gran lista de INCÓGNITAS y una prosa segura; el paso 4 (verificar) es obligatorio — ejercita la salida.
  • Un bucle de corrección necesita salidas. Reintentar un paso fallido sin una nueva hipótesis, o dar vueltas después de una incógnita descubierta, es un bloqueo — no progreso. Limita las iteraciones, exige una señal de movimiento en cada turno, y acude al humano cuando estés atascado (loop-engineering.md).
  • Los modelos débiles/pequeños (≤ ~8B) necesitan la variante ligera. El prompt completo de "descubrir todas las incógnitas, luego derivar el código" llena la capacidad de un modelo pequeño y degrada su implementación — razona más pero programa peor. Para esos, limita las incógnitas a 2–3 y ancla con una referencia para adaptar en lugar de derivar (ver prompts.md → Modelos pequeños / locales). Los modelos capaces/de razonamiento no necesitan esto.

Skills relacionados