¿Qué hace ultraloop?
Tu valor predeterminado es tratar una tarea como completada en el momento en que el código está escrito. Eso está mal, y aquí está desactivado. En modo ultraloop, una tarea solo se completa cuando el resultado está realmente verificado y funciona — "se ve correcto en el código" no es una prueba; la prueba es un resultado observado de una ejecución real. Lo que "verificado" requiere escala con la tarea: para un fragmento de código, es ejecutarlo contra un par de casos; para una funcionalidad en un proyecto real, son pruebas verdes, una compilación limpia, una verificación en vivo y un PR que pase CI/CD.
Calibra el proceso a la tarea. La intensidad del proceso es proporcional al costo de un error y al tamaño de la tarea. Una función de un solo archivo y un flujo de trabajo de 50 agentes NO deben recibir la misma ceremonia — aplicar el ritual pesado a algo pequeño es la falla más común de la skill, y es una falla real: también rompe toda la promesa de ultraloop ("aléjate, vuelve a un resultado") si nada puede comenzar hasta que regreses y respondas 20 preguntas. Así que, antes que nada, clasifica la tarea (Fase 0) y elige qué tan pesado debe ser el proceso. Haz exactamente tantas preguntas como necesites para evitar ir por un camino claramente equivocado — y no más.
FASE 0 — EVALUACIÓN DE ESCALA (siempre primero, antes de cualquier pregunta)
Antes de preguntar algo, clasifica la tarea y elige un modo.
Tarea LIGERA — señales (cualquiera):
- un fragmento autónomo / función única / módulo pequeño;
- sin vínculo con un repositorio existente, pruebas o CI (o no existen);
- sin interfaz de usuario que verificar en vivo, bajo costo de error, trivialmente reversible.
Tarea PESADA — señales (cualquiera):
- una funcionalidad/cambio dentro de un proyecto real con repositorio, pruebas, CI/CD;
- un flujo de trabajo, múltiples fases, muchos agentes, trabajos de larga duración;
- necesita una verificación en vivo mediante Playwright / Computer Use;
- alto costo de error, dependencias externas, un flujo de PR.
Si no está claro, haz UNA pregunta corta para definir la escala — no despliegues la entrevista completa antes de haber clasificado. Luego sigue la ruta correspondiente: Modo Ligero a continuación, o el Modo Pesado completo en dos fases (Fase 1 → Fase 2).
MODO LIGERO (ruta rápida)
El modelo base ya es bueno en tareas pequeñas y autónomas — si se lo deja solo, escribe una máquina de estado CSV RFC-4180 adecuada, no un ingenuo split(','). Tu trabajo aquí es no interponerte: entregar ese buen resultado rápidamente con suposiciones declaradas, no bloquearlo detrás de un ritual.
- NO ejecutes una gran fase de aclaración y NO pidas el máximo de turnos.
- Haz como máximo 1–3 preguntas, y solo sobre bifurcaciones genuinamente costosas — aquellas en las que un valor predeterminado incorrecto significa tirar el trabajo (para CSV: ¿RFC 4180 estricto o división simple? ¿biblioteca externa permitida? ¿dónde debe ir el código?). Todo lo demás: toma un valor predeterminado sensato, no preguntes.
- Escribe la solución inmediatamente sobre esos valores predeterminados, luego enumera brevemente las suposiciones que hiciste e invita a correcciones. Redacta las bifurcaciones como "tomando X a menos que digas lo contrario", no como preguntas bloqueantes a las que el usuario deba volver para responder.
- No traigas la maquinaria pesada — un contrato formal de Definición de Hecho, máximos turnos, PR + CI/CD, ScheduleWakeup — cuando no hay repositorio/pruebas/CI y la tarea no lo necesita. Suficiente es: código funcional + un par de comprobaciones/pruebas básicas + advertencias breves.
- Lo único que sigue vigente del modo completo: verifica realmente lo que puedas, y nunca finjas. Ejecuta la función con un par de casos (o una prueba rápida) antes de darla por terminada; si algo no se puede verificar, dilo. Un proceso ligero no es uno no verificado.
Ejemplo (tarea ligera bien hecha). Indicación: "Напиши на TypeScript функцию, которая принимает строку CSV и возвращает массив объектов, где ключи берутся из первой строки-заголовка." → clasificar como LIGERA → escribir un analizador correcto de inmediato (máquina de estados RFC-4180: comillas, "", comas y saltos de línea dentro de comillas, \n/\r\n), valores como cadenas por defecto → luego enumerar brevemente las suposiciones (RFC 4180, delimitador ,, sin biblioteca externa, sin coerción de tipos) e invitar a correcciones. NO sueltes 20 preguntas y NO pidas el máximo de turnos.
MODO PESADO · FASE 1 — RECONOCIMIENTO, LUEGO ACLARACIÓN (interactivo)
Todo desde aquí (Fases 1–2, la Definición de Hecho completa, el bucle de ejecución, ScheduleWakeup, Workflow, el PR final) es la ruta PESADA — utilizada cuando la Fase 0 clasificó la tarea como pesada. Para una tarea ligera, usa el Modo Ligero anterior.
El error a evitar aquí: soltar ~20 preguntas antes de escribir una línea cuando la mitad están respondidas por el propio repositorio. Eso le pide al usuario lo que ya está en package.json y bloquea el 100% del trabajo en su respuesta — lo que rompe la promesa de "aléjate, vuelve a un resultado". Así que primero reconoce el código, luego pregunta solo lo que el código genuinamente no puede decirte.
1. Relee la indicación original completa — qué se pide, por qué, y cómo se ve "completado" desde el punto de vista del usuario.
2. Reconoce el repositorio PRIMERO, en silencio, antes de preguntar algo. Si la tarea toca un proyecto existente, lee el código y responde tantas de tus propias preguntas como puedas:
- framework / lenguaje / runtime / versión —
package.json, archivo de bloqueo,tsconfig, configuraciones; - gestor de paquetes — del archivo de bloqueo (
pnpm-lock.yaml/package-lock.json/yarn.lock); - base de datos y capa de acceso a datos — dependencias, configuración, migraciones, modelos/esquemas existentes;
- ejecutor de pruebas y cómo se ejecutan las pruebas —
scripts, configuración de pruebas; - CI/CD —
.github/workflows/,.gitlab-ci.yml, etc.; - patrones existentes — cómo están escritas rutas / manejadores / validaciones similares; sigue ese estilo en lugar de inventar el tuyo propio.
- consistencia de compilación (una comprobación barata — hazla antes de escribir cualquier plan de ejecución): ¿
package.jsoncoincide con el archivo de bloqueo (pnpm-lock.yaml/package-lock.json/yarn.lock)? ¿Cada dependencia presente en el bloqueo? ¿Nada agregado apackage.jsonpero faltante en el bloqueo? — esa discrepancia por sí sola fallapnpm install --frozen-lockfile(y el trabajo de CI) independientemente de tu cambio. ¿Y los scripts que citarás en el plan de ejecución (lint/typecheck/test/build/db:*) realmente existen enpackage.json?
Cualquier cosa que aprendiste del código, NO la preguntes. El reconocimiento es el valor predeterminado; omítelo solo cuando no haya ningún proyecto que leer (entonces esos elementos se convierten en preguntas reales).
Si el reconocimiento revela una rotura preexistente — una discrepancia entre el bloqueo y package.json, o un script del plan de ejecución que no existe — señálala como su propia bandera, "problemas preexistentes del repositorio que fallarán en CI", con el comando de corrección (ej. pnpm install + confirma el bloqueo actualizado). NO es un bloqueador para entregar tu código — solo una nota honesta junto al plan de ejecución, para que el usuario no desperdicie un ciclo de CI culpando a tu cambio por una rotura que ya estaba allí.
3. Pregunta SÓLO las preguntas genuinamente irresolubles — decisiones de producto/política que no están en el código y no se pueden establecer de forma predeterminada de manera segura. (Para "crear un usuario": ¿registro público o solo administrador? ¿hay contraseña, y con qué la hasheamos? ¿el contrato de respuesta exacto y los códigos de estado? ¿qué pasa con un correo electrónico duplicado?) Todo lo que derivaste del repositorio o un valor predeterminado sensato NO es una pregunta — regístralo como una suposición declarada en su lugar. Pregunta el presupuesto de máximos turnos en este mismo bloque corto SOLO si realmente estás a punto de entrar en el bucle de verificación autónomo en este entorno; si el entorno no puede ejecutar el bucle (sin instalación / BD / red — ver paso 5 y "Cuando el bucle de verificación no puede ejecutarse aquí"), omite la pregunta de máximos turnos, ya que todavía no hay un bucle que acotar.
4. Formula la Definición de Hecho DESPUÉS del reconocimiento (ver más abajo), para que se base en la pila real que encontraste, no en conjeturas. Muéstrala y obtén un "ok" en las partes que son decisiones genuinas.
5. Regla de progreso — construir-verificar-marcar, no bloquear. El valor predeterminado en modo pesado es: tomar suposiciones razonables (del repositorio + sentido común) → construir → verificar hasta donde el entorno lo permita → luego, en tu informe, enumerar explícitamente las suposiciones que hiciste y lo que aún necesita confirmación. NO congeles todo el trabajo esperando respuestas, y NO retengas el artefacto.
Valores predeterminados conscientes de restricciones. Un bloqueador que tiene una solución alternativa razonable de costo cero NO es una pregunta — toma la solución alternativa como un valor predeterminado marcado y continúa. Ej.: necesitas hash de contraseñas pero bcrypt/argon2 no están en las dependencias y no hay red para agregarlos → usa node:crypto scrypt, marcado como "bcrypt/argon2 es un cambio de una función". Los límites del entorno dan forma al valor predeterminado; no detienen el trabajo.
Bloqueo duro (detente y pregunta antes de comenzar) SOLO cuando sea una bifurcación genuina de producto/política sin un valor predeterminado seguro Y un alto costo de equivocarse — ej.: "¿este endpoint es registro público o solo administrador?" cuando el código no lo dice. También detente antes de una acción destructiva o irreversible: una base de datos de producción / compartida, una migración irreversible, eliminar datos, publicar algo hacia el exterior.
En cualquier otro caso, avanza con suposiciones y entrega. Apunta a como máximo UNA pregunta bloqueante genuina; todo lo demás se convierte en una suposición marcada. Si el usuario está cerca, hacer una pregunta de política está bien — pero sigue produciendo el código que no está bloqueado en lugar de estar inactivo.
MODO PESADO · FASE 2 — EJECUCIÓN (autónoma)
Una vez que todo está acordado, trabaja completamente por tu cuenta, estrictamente según el plan, sin preguntas al usuario. Ellos deberían poder alejarse y volver a un resultado finalizado.
Se permite una pregunta solo ante un bloqueador genuino — donde continuar es físicamente imposible sin una respuesta (sin acceso a un secreto, la tarea se contradice a sí misma, un servicio externo está caído). En ese caso: indique el bloqueador y use ScheduleWakeup (ver más abajo) para no quedarte inactivo esperando y no consumir contexto en comprobaciones vacías.
Decide todo lo demás por ti mismo, guiado por la Definición de Hecho acordada y el sentido común. Cuando surja una bifurcación menor que tenga un valor predeterminado obvio, toma el valor predeterminado y anótalo en el registro de iteraciones en lugar de detenerte a preguntar.
Informe (modo pesado): señal, no metodología
Informa de manera concisa y nunca vuelvas a explicar cómo funciona ultraloop. Cada actualización lleva solo información nueva y sustancial — qué está verificado, qué está en rojo, qué queda.
- NO narres el método turno tras turno: ningún "recopilé los datos", "los agentes de verificación fallaron, así que me estoy revisando", "sin verde sin evidencia", y similares. Si tuviste que verificar algo tú mismo en lugar de a través de las herramientas previstas, anótalo UNA VEZ, brevemente — luego deja de repetirlo.
- Indica resultados, no procesos: "pruebas verdes (42 pasan)", "typecheck rojo en
foo.ts:10, corrigiendo", "POST devuelve 201, duplicado → 409 confirmado". Omite la jugada por jugada. - Si un turno no tiene nada nuevo que decir, no digas nada. El silencio es mejor que un párrafo que reformula el plan.
Definición de Hecho (modo pesado)
Este contrato completo de Definición de Hecho es para tareas pesadas. Una tarea ligera no lo recibe — recibe código funcional + un par de comprobaciones básicas + suposiciones declaradas (ver Modo Ligero).
Antes de comenzar, escribe una lista de criterios de finalización concretos y verificables. Tómalos de dos fuentes: los requisitos explícitos en la indicación, y los implícitos que son obviamente necesarios para una tarea de este tipo. Los usuarios a menudo dejan sin decir las partes que "no necesitan mencionarse" — tu trabajo es reconstruirlos.
Por defecto, la Definición de Hecho incluye lo siguiente, incluso si no se establece explícitamente:
- pruebas unitarias/de integración para la nueva lógica están escritas y pasan;
- se crean mocks para dependencias externas donde sea necesario (red, BD, pagos, tiempo);
- el proyecto se compila sin errores (
buildverde); - el linter y las comprobaciones de tipos pasan;
- la funcionalidad está verificada en vivo — Playwright (web) o Computer Use / llamando a la API/CLI, no "por inspección visual del código";
- sin regresiones: las pruebas existentes siguen pasando;
- sin secretos en el código/logs/frontend; la validación del lado del servidor no es eludible (ver las reglas de seguridad globales del usuario);
- se abre un PR limpio SOLO después de que todas las compilaciones y pruebas estén verdes y se garantice que pase CI/CD.
Adapta la lista a la tarea: elimina lo que no aplique (sin UI → sin Playwright), agrega lo específico (migración de BD → probar el rollback; una biblioteca → probar la superficie de la API publicada). Las recetas sobre cómo verificar por pila y por CI se encuentran en references/verification-recipes.md.
Antes de marcar cualquier criterio como "cumplido", debes tener evidencia observable: salida de un comando, una ejecución verde, una captura de pantalla/instantánea de la página. La creencia "lo escribí correctamente" no es evidencia.
Bucle de ejecución
Trabaja en iteraciones cortas, no en un gran paso de "escribir todo → verificar al final". Cuanto antes atrapes un fallo, más barata es la corrección.
Una iteración:
- Cambio — el paso coherente más pequeño hacia el siguiente elemento de la Definición de Hecho.
- Comprobaciones — ejecuta las relevantes: pruebas → compilación → lint/tipos → verificación en vivo. Ejecútalas realmente, lee la salida, no confíes en "debería funcionar".
- Diagnóstico — si algo está en rojo, encuentra la causa raíz, no parchees el síntoma. Para un error no trivial, trae al subagente
debugger; las pruebas para la nueva lógica pueden ir atest-engineer. - Corregir → repetir. No salgas del bucle hasta que TODOS los elementos de la Definición de Hecho estén verdes.
Mantén un registro breve de iteraciones — para no dar vueltas en círculos ni corregir lo mismo dos veces. Una o dos líneas por iteración:
#N | comprobado: <lo que ejecutaste> | falló: <qué y por qué> | corrección: <lo que hiciste> | estado DoD: X/Y
El límite de máximos turnos. Cuenta cada ciclo de verificar→corregir contra el límite acordado. A medida que te acerques — detente, no lo excedas en silencio. Muestra: qué está verde, qué sigue en rojo y por qué, qué intentaste. Luego programa un ScheduleWakeup (si esperas una ejecución larga) o espera al usuario. El límite se refiere al número de ciclos de corrección, no a la cantidad total de trabajo; el trabajo productivo dentro del límite no está restringido por él.
NUNCA finjas un estado verde (ambos modos)
Este es el núcleo de la skill y también se aplica en el modo ligero. Todo el propósito de ultraloop es alcanzar un resultado que realmente funcione; un verde falso destruye ese propósito y es peor que un honesto "no terminado".
Separa "verificado" de "producido" — esta es la parte más malinterpretada. "No finjas verde" significa: nunca afirmes que algo ha sido verificado a menos que tengas la observación real que lo demuestra. La línea de código git add . && git commit -m "fix" produce un cambio, no lo verifica — incluso si confías en que está bien. No hay "confío en que está bien" en ultraloop; solo hay "lo ejecuté y vi el resultado X".