Loop engineering: la evolución del prompt en Claude Code

La declaración que lo cambió todo

Boris Cherny, Head de Claude Code en Anthropic, lo dijo sin rodeos en junio de 2026:

«I don’t prompt Claude anymore. I have loops running that prompt Claude and figuring out what to do. My job is to write loops.»

Addy Osmani bautizó el concepto como loop engineering ese mismo mes. Peter Steinberger, creador del framework OpenClaw, adoptó la misma terminología. El consenso entre quienes usan Claude Code profesionalmente en 2026 apunta en la misma dirección: el prompt fue el primer paso; el loop es el siguiente.

Qué es exactamente un loop y en qué se diferencia de un prompt

La diferencia no está en lo que le pides a Claude — está en cuándo para.

Con un prompt, Claude para cuando termina de responder. Da igual si el resultado es correcto o no. Eso lo decides tú: revisas, detectas el error, escribes otro prompt, y repites el ciclo manualmente. Tú eres el bucle.

Con un loop, Claude para cuando la meta se cumple. No cuando cree que está hecho — cuando puede verificar objetivamente que el resultado cumple la condición que definiste. Si no la cumple, se corrige solo y lo vuelve a intentar. Tú diseñas el bucle; Claude lo ejecuta.

El ejemplo del vídeo lo aterriza perfectamente: pedirle a Claude un resumen de una página es una tarea. La meta — y lo que convierte eso en un loop — es: «cada dato lleva tres links, y cada link tiene que abrir a un artículo real que compruebe lo que estás diciendo.» Claude no para cuando entrega el resumen. Para cuando puede verificar que todos los links existen y llevan a fuentes reales.

/goal y /loop: los dos comandos que lo hacen posible

/goal — darle una meta, no una tarea

El comando /goal le dice a Claude Code qué significa «terminado». No qué hacer, sino cómo saber que ya lo hizo bien. Una vez definido el goal, Claude lo usa como referencia después de cada acción: ¿el estado actual cumple la condición? Si no, siguiente paso.

Según la documentación oficial de Claude Code, una buena condición de goal tiene cuatro partes: un estado final medible, la prueba de cómo el agente lo verifica, las restricciones que deben mantenerse, y un límite opcional de iteraciones o tiempo.

/goal Cada función del módulo tiene un JSDoc completo
      y ninguna función supera las 40 líneas de código

Eso es un goal bien definido. Tiene un estado final medible (JSDoc completo, 40 líneas máximo), es verificable objetivamente (Claude puede contarlo), y tiene restricciones claras. Compáralo con esto:

/goal Refactoriza el código  ← esto NO es un goal. Es una tarea vaga.

/loop — darle persistencia al goal

El comando /loop convierte el goal en un ciclo que se repite hasta que la condición se cumple. Cada iteración del loop sigue el mismo patrón:

1. Evalúa el estado actual contra la condición del goal
2. Identifica el siguiente paso necesario
3. Ejecuta ese paso
4. Verifica el resultado
5. Si la condición está cumplida: para y resume lo hecho
6. Si no: vuelve al paso 1

Usados juntos, /goal y /loop crean un agente que se dirige solo y se detiene solo. Sin ti en medio de cada iteración.

Los 4 tipos de loop

Cómo escribir una meta que funcione

Este es el punto donde la mayoría falla. No porque el loop sea difícil de configurar — sino porque la meta está mal escrita. Si Claude no puede evaluar objetivamente si la meta está cumplida, o declara éxito demasiado pronto, o no para nunca.

La estructura de una meta bien escrita tiene cuatro elementos:

• Estado final medible: algo que pueda comprobarse sin ambigüedad. Un código de salida de tests, un contador a cero, un formato validado. No: «el código está limpio». Sí: «ESLint reporta cero errores en /src».
• Cómo se verifica: qué comando, qué herramienta o qué criterio usa Claude para saber que la condición está cumplida. Si no lo defines, Claude lo decide solo — con resultados impredecibles.
• Restricciones: qué no puede tocar. Sin esto, un loop bien intencionado puede modificar archivos que no debería. «No modifiques los archivos de configuración», «no cambies los tests existentes».
• Límite de iteraciones o tiempo: un cap que detiene el loop si algo va mal. Sin límite, un loop con una meta imposible de cumplir corre indefinidamente y agota tu presupuesto de tokens.

/goal Implementa la tarea, verifica contra los tests y corrige los fallos.
      Guarda el estado en archivos en cada paso.
      Máximo 5 iteraciones.
      Para en el primer paso limpio o cuando llegues al límite — e indícame cuál.
      No toques los archivos de configuración ni los tests existentes.

Ese goal es seguro: tiene meta, verificación, restricciones y límite. Claude puede evaluarlo objetivamente. Y si algo falla, el cap evita que el loop se convierta en un gasto de tokens sin control.

Los errores más frecuentes — y los más caros

• Meta vaga o no verificable: el error más frecuente y el más caro. Si la condición de éxito no es objetivamente comprobable, Claude puede declarar éxito cuando en realidad no lo ha logrado — o iterar indefinidamente porque no sabe cuándo parar. La solución es siempre la misma: convierte la meta en algo que pueda medirse con un comando o un criterio explícito.
• No contextualizar a Claude antes de arrancar el loop: si Claude no conoce la estructura del proyecto, las convenciones de nombres o la arquitectura antes de que el loop empiece, hará suposiciones. Algunas serán incorrectas. Corregirlas a mitad de un loop es disruptivo y costoso. Dedica unos turnos a orientar a Claude — muéstrale los archivos relevantes, explícale las convenciones — y luego arranca el loop.
• Loop demasiado rápido para lo que verifica: un loop con intervalo de 30 segundos que ejecuta una suite de tests completa puede solaparse con sí mismo o agotar los límites de la API. El intervalo del loop debe ser mayor que el tiempo real que tarda cada ciclo en completarse.
• Sin límite de iteraciones: cualquier loop sin cap puede convertirse en un bucle infinito si la meta es inalcanzable o si aparece un error que el agente no puede resolver. Siempre define un número máximo de iteraciones y un comportamiento claro cuando se alcanza ese límite.
• Permisos demasiado amplios desde el inicio: la recomendación de quienes usan loops en producción es empezar en modo lectura. Que el agente primero resuma lo que haría sin hacer nada. Cuando confíes en que el comportamiento es el correcto, amplía los permisos. Un loop con permisos de escritura desde el primer día puede causar cambios irreversibles antes de que detectes que algo está mal.

Tu primer loop: ejemplo paso a paso

El caso más sencillo para empezar es un loop de goal sobre un proceso de verificación que ya tienes: tests, linting o validación de formato. Si Claude puede ejecutar el verificador y leer su output, puedes construir el loop.

Paso 1 — Orienta a Claude antes de arrancar
Muéstrale los archivos relevantes. Explícale las convenciones.
Confirma que entiende el proyecto.
 
Paso 2 — Define la meta con los 4 elementos
/goal [estado final medible]
      [cómo se verifica]
      [qué no puede tocar]
      [máximo N iteraciones]
 
Paso 3 — Arranca el loop
/loop [ejecuta el verificador, corrige lo que falle,
       vuelve a verificar, para cuando todo esté limpio]
 
Paso 4 — Lee solo el resultado final
No el proceso. Solo el estado final y el resumen de lo que hizo.

Los loops más potentes añaden sobre esto dos capas: un agente separado que verifica el trabajo del agente que lo hace (maker y checker), y memoria persistente en un archivo de estado que sobrevive entre sesiones. Pero para el primer loop, la versión mínima es suficiente para ver el cambio de paradigma en acción.

Para procesos de automatización empresarial que requieren coordinación entre varios agentes en paralelo, el protocolo A2A (Agent-to-Agent) define cómo esos agentes se comunican y delegan tareas entre ellos. Y una vez que tienes loops corriendo en producción, los AI Evals son el sistema que confirma que siguen funcionando correctamente semanas después del despliegue.

Preguntas frecuentes sobre loops en Claude Code

• ¿Los loops de Claude Code son solo para desarrolladores?

  No necesariamente, aunque los comandos /goal y /loop en Claude Code requieren tener la aplicación instalada y cierta familiaridad con el terminal. El concepto de loop — dar una meta verificable en lugar de una tarea — aplica también a flujos de automatización empresarial construidos sobre Claude sin Claude Code. La lógica es la misma: el agente no para cuando entrega algo, para cuando la condición de éxito se cumple. Las plataformas de automatización como n8n o Make pueden implementar ese patrón sin necesidad de Claude Code directamente.

• ¿Cuánto cuesta en tokens dejar un loop corriendo?

  Depende del número de iteraciones, la longitud del contexto en cada ciclo y el modelo usado. Un loop sin límite de iteraciones sobre una meta mal definida puede consumir un presupuesto de tokens en minutos. La regla práctica es siempre definir un cap de iteraciones antes de arrancar cualquier loop, especialmente si es la primera vez que lo usas sobre ese proceso. Claude Code permite configurar límites de tokens y de tiempo en los loops para evitar gastos no controlados.

• ¿Qué diferencia hay entre loop engineering y prompt engineering?

  El prompt engineering optimiza cómo le pides algo a Claude para obtener la mejor respuesta posible en un único intercambio. El loop engineering diseña el sistema que rodea a Claude: el goal que define el éxito, el mecanismo de verificación, los límites de seguridad, la memoria entre sesiones y los permisos del agente. Son complementarios: necesitas buenos prompts dentro de los loops, pero el loop engineering opera a un nivel superior — diseña el proceso, no la pregunta.

• ¿Se puede usar /goal sin /loop?

  Sí. /goal sin /loop le da a Claude una referencia persistente de qué significa «terminado» durante una sesión de trabajo manual. Claude evaluará cada acción contra el goal pero no iterará automáticamente — tú sigues controlando el ritmo. Es un punto intermedio útil para familiarizarse con el concepto antes de delegar el ciclo completo al loop. Muchos usuarios empiezan con /goal solo y añaden /loop cuando ya confían en que el goal está bien definido.

• ¿Qué es el patrón maker/checker en loops?

  Es la práctica de usar dos agentes independientes en el mismo loop: uno que hace el trabajo (maker) y otro que lo verifica (checker). El problema que resuelve es el sesgo de confirmación: un único modelo tiende a aprobar su propio trabajo incluso cuando tiene errores. Un agente separado que evalúa el output del primero detecta fallos que el maker no detectaría. Es el patrón más robusto para loops en producción, aunque también el más complejo de configurar. Para empezar, un loop con un solo agente y una condición de verificación objetiva es suficiente.