Loop Engineering (Ingeniería de bucles)

Loop Engineering (Ingeniería de bucles) es un nuevo concepto que se difundió rápidamente en la comunidad de programación con IA en junio de 2026. Fue sistematizado por el ingeniero de Google Addy Osmani, y Boris Cherny, responsable de Claude Code en Anthropic, y el desarrollador Peter Steinberger plantearon la misma idea de forma independiente en público.

Este artículo te llevará desde cero a entender qué es Loop Engineering, sus diferencias esenciales con Prompt Engineering, los seis elementos que conforman un Agent Loop completo y cómo diseñar tu primer Loop funcional.

Proceso de evolución de la ingeniería de IA

En los últimos dos años, el enfoque del desarrollo de IA ha ido cambiando constantemente: desde investigar cómo escribir buenos prompts, pasando gradualmente a organizar el contexto (Context), orquestar herramientas y flujos (Harness), hasta construir sistemas de bucle (Loop) capaces de ejecutarse de forma autónoma y entregar resultados de forma continua.

Prompt:怎么问 AI
↓
Context:给 AI 什么信息
↓
Harness:如何组织 AI 的能力
↓
Loop:如何让 AI 持续创造结果

Etapa de ingeniería Idea central Enfoque Entrada Capacidad de IA Rol de la persona Escenario típico
Prompt Engineering (Ingeniería de prompts) Obtener mejores resultados mediante el diseño de prompts Cómo hacer preguntas Prompt / Instrucción Generación de un solo turno Preguntador Chat, escritura, generación de código
Context Engineering (Ingeniería de contexto) Organizar y proporcionar información de contexto completa Qué información dar a la IA Base de conocimiento, historial, restricciones, contexto Comprensión del contexto Organizador de información RAG, búsqueda con IA, asistentes de código
Harness Engineering (Ingeniería de orquestación) Conectar modelos, herramientas y datos para formar flujos de trabajo Cómo invocar capacidades Contexto + API + cadena de herramientas Ejecutar tareas Diseñador de sistemas Agentes, procesos automatizados, colaboración de múltiples herramientas
Loop Engineering (Ingeniería de bucles) Construir sistemas de bucle cerrado autónomos impulsados por objetivos Cómo completar objetivos de manera continua Objetivos, estado, memoria, mecanismos de verificación Planificar → Ejecutar → Verificar → Reparar → Operar de forma continua Diseñador de reglas Claude Code, programación con IA, operación automatizada, empleados de IA

El origen de Loop Engineering

La aparición de Loop Engineering tiene un hito temporal claro: junio de 2026.

Punto de inflexión: dos frases, un millón de retuits

A principios de junio de 2026, el responsable de Claude Code en AnthropicBoris Chernydijo en una conferencia pública:

"I don't prompt Claude anymore. I have loops running. They're the ones prompting Claude and figuring out what to do. My job is to write loops."
(Ya no hago prompt a Claude directamente. Tengo un conjunto de Loops en ejecución que se encargan de hacer prompt a Claude y de decidir qué hacer a continuación. Mi trabajo es escribir los Loops.)

Pocos días después, el 7 de junio de 2026, el desarrolladorPeter Steinberger—creador del proyecto de agente de IA de código abierto OpenClaw (el repositorio nuevo que más rápido acumuló estrellas en la historia de GitHub)— publicó un tuit de doce caracteres:

"You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents."
(Ya no deberías dar indicaciones manualmente al asistente de programación con IA. Deberías diseñar un Loop en el que el agente se indique a sí mismo.)

  • Prompt EngineeringEs «enseñar a la IA cómo hacerlo»
  • Loop EngineeringEs «diseñar un sistema para que la IA lo siga haciendo por sí misma»

Estas dos frases provocaron un enorme debate en la comunidad de desarrolladores de IA, porque describían con precisión una tendencia que muchos ya sentían pero que aún no tenía nombre:Ya no es un cuello de botella si el prompt está bien escrito o no; el cuello de botella es todo el sistema de ejecución que diseñas para el agente.。

Posteriormente, Addy Osmani publicó un extenso artículo en Substack en el que nombró y sistematizó formalmente esta práctica comoLoop Engineering, convirtiéndola en una disciplina de ingeniería independiente.

Contexto: la evolución en tres generaciones de las herramientas de programación con IA

Loop Engineering no surgió de la nada; es el resultado natural de la evolución de las capacidades de las herramientas de programación con IA.

EtapaHerramienta representativaForma de trabajoCuello de botella
Primera generación: autocompletadoVersiones iniciales de GitHub CopilotCompleta la línea o función actual; el humano toma todas las decisionesSolo puede asistir, no es autónomo
Segunda generación: conversacionalChatGPT、Claude.aiUna pregunta, una respuesta; el humano avanza manualmente cada pasoEl humano se convierte en el cuello de botella; la velocidad está limitada por la velocidad al teclear
Tercera generación: bucle autónomo del agenteClaude Code、OpenAI Codex AgentEl agente planifica, ejecuta y verifica de forma autónoma, iterando en bucle hasta completar la tareaCómo diseñar un sistema que permita que el Loop funcione de manera fiable

La aparición de las herramientas de tercera generación significa que la competencia central de los ingenieros ha pasado de saber escribir prompts a saber diseñar Loops.


Qué es Loop Engineering

Loop Engineering es la práctica de ingeniería de diseñar, operar y mejorar continuamente bucles de retroalimentación que permiten a los agentes de programación con IA completar de forma autónoma la planificación, ejecutar modificaciones de código, observar los resultados y realizar tareas a lo largo de múltiples iteraciones.

En una frase:

Loop Engineering es lo que te transforma de «la persona que hace prompt al agente» en «el ingeniero que diseña el sistema que hace prompt al agente».

Qué es un Loop (bucle)

Un Loop es un sistema recursivo orientado a objetivos: defines un propósito y el agente itera sin parar hasta que el trabajo está realmente terminado.

Cada agente ya tiene incorporado un «bucle interno» al ejecutar tareas: Percibir (Perceive) → Razonar (Reason) → Actuar (Act) → Observar (Observe), y luego se repite el ciclo.

Loop Engineering trabaja en el nivelsuperior:

jerárquico de este bucle interno.Quién impulsaQué hace
Bucle interno (integrado en el agente)El propio agenteLeer archivo → modificar código → ejecutar pruebas → leer errores → volver a modificar
Bucle externo (diseñado por ti)El sistema que tú diseñasDescubrir tareas según el plan → asignar Agente → verificar resultados → registrar estado → iniciar siguiente ronda

Ya no te sientas junto al Agente dando una instrucción para cada paso. Estás diseñando un sistema externo que conduce el bucle interno por ti, mientras tú te ocupas de tareas que requieren mayor criterio.

Diferencias entre Loop Engineering y Prompt Engineering

DimensiónPrompt EngineeringLoop Engineering
Objeto de optimizaciónUna sola instrucción escrita por ti manualmenteEl sistema completo que decide automáticamente “qué indicar, cuándo indicar y si el resultado es aceptable”
Unidad de trabajoUn turno de conversación que introduces manualmenteUn flujo de trabajo completo y automático que abarca múltiples turnos
Métrica de éxitoCalidad de la primera respuestaCalidad del resultado final
Modo de falloEl modelo da una respuesta deficienteEl bucle del sistema está mal diseñado: el ciclo se detiene demasiado pronto, ignora señales de error, no puede verificar la finalización
Perspectiva sobre el AgenteUna herramienta que sostienesUn proceso de larga ejecución que tú coordinas

Prompt Engineering no ha muerto. Un bucle está compuesto por múltiples prompts; un prompt mal redactado dentro del bucle solo producirá trabajo deficiente a mayor velocidad. Loop Engineering es una capa por encima de Prompt Engineering, no su reemplazo.

La pila tecnológica completa de tres capas:

CapaQué optimizaUnidad de trabajo
Prompt EngineeringCómo redactar una instrucciónUna conversación que introduces manualmente
Context EngineeringQué contenido poner en la ventana de contexto: documentos, historial, definiciones de herramientasCondiciones del entorno alrededor de una respuesta
Loop EngineeringSistema autoejecutable que decide qué indicar, cuándo indicar y si el resultado es aceptableFlujo de trabajo automático que abarca múltiples bucles internos

El ciclo central del Loop

La estructura básica de un Agent Loop consta de cinco fases que se conectan de extremo a extremo e iteran continuamente.

FaseNombre en inglésQué haceFuente típica de señales
IntenciónIntentDefine el resultado objetivo: cómo es el éxito, cuáles son las restriccionesDesarrollador o sistema externo (Issue, informe de CI)
ContextoContextRecopila código relevante, documentación, registros de errores, convencionesRepositorio de código, salida de pruebas, historial de conversaciones
AcciónActionEditar archivos, ejecutar comandos, invocar herramientas, redactar solucionesEjecutado autónomamente por el Agente
ObservaciónObservationObtener resultados de pruebas, errores de compilación, salida en tiempo de ejecución, diff de códigoFramework de pruebas, verificación de tipos, CI, revisión humana
AjusteAdjustmentActualiza el plan según las observaciones; repite el bucle hasta que la tarea se complete o quede bloqueadaSiguiente ronda del bucle interno

El poder del Loop no reside en ningún paso individual, sino en elbucle cerrado. Un fallo de prueba no es solo un mensaje de error; es nuevo contexto. Un error de tipo no es solo un bloqueo; es una señal sobre una suposición incorrecta. Un comentario de Code Review no es solo retroalimentación; es una nueva observación que impulsa la siguiente acción.


Los seis elementos constitutivos

Un Loop que funcione verdaderamente de forma autónoma necesita cinco componentes centrales, más un sistema de memoria que lo recorra todo; todos son imprescindibles.

Elemento 1: Disparadores automáticos (Automations)

El disparador automático es el corazón del Loop. Sin disparo automático, el Loop no es más que “una operación que hiciste una vez”, no un ciclo en el verdadero sentido.

El disparador define:¿Cuándo? ¿Qué hacer?

En Claude Code, usa el/loopcomando para crear un Loop con activación programada:

Ejemplo

# Ejecutar a las 9 a. m. de cada día laborable: leer los fallos de CI y los Issues del día anterior,
# escribir los hallazgos en TODO.md y redactar un plan de corrección para los problemas marcados como quick-win
/loop "Read yesterday's CI failures and open issues, write findings \
      to TODO.md, and draft fixes for anything labeled quick-win"
\
       --schedule "0 9 * * 1-5"

# /goal: ejecutar hasta que se cumpla una condición verificable
# El siguiente comando se ejecutará continuamente hasta que todas las pruebas del módulo de autenticación pasen y el lint esté limpio
/goal "All tests in test/auth pass and lint is clean"

En OpenAI Codex, Automations tiene un panel de interfaz dedicado. Puedes configurar el proyecto, el prompt, la cadencia (cadence) y si se ejecuta en un checkout local o en un Worktree en segundo plano. Las ejecuciones con hallazgos entran en la bandeja de entrada de Triage; las que no encuentran nada se archivan automáticamente.

Advertencia de costo de tokens:Un Loop programado con subagentes de verificación consume tokens en cada activación, y el consumo varía notablemente según la complejidad de la tarea. Se recomienda empezar con una cadencia más lenta (por ejemplo, una vez al día), observar los costos durante unos días y luego aumentar la frecuencia.

Elemento 2: Aislamiento en paralelo (Worktrees)

Cuando ejecutas varios agentes a la vez, los conflictos de archivos son el punto más problemático. Dos agentes escribiendo el mismo archivo al mismo tiempo es como dos ingenieros enviando cambios a la misma línea de código: el resultado es desastroso.

Git WorktreeLa solución es: proporcionar a cada Agente un directorio de trabajo independiente, operando cada uno en su propia rama, compartiendo el mismo historial de Git, pero con cambios de archivos totalmente aislados.

Ejemplo

# Crear worktree manualmente (Claude Code y Codex ambos admiten gestión automática)
git worktree add ../agent-fix-auth feature/fix-auth-tests
git worktree add ../agent-upgrade-deps feature/upgrade-axios

# En Claude Code, configurar aislamiento de worktree para los subagentes
# Añadir en el frontmatter de .claude/agents/reviewer.md:
# isolation: worktree → cada Agente obtiene un checkout independiente y se limpia automáticamente al terminar

Worktree elimina los conflictos mecánicos de archivos, pero no elimina elcuello de botella de la revisión. La velocidad con la que procesas y apruebas los cambios de código es el límite real que determina cuántos Agentes puedes ejecutar en paralelo, no la cantidad de Worktrees que la herramienta pueda abrir.

Elemento 3: Archivos de habilidades (Skills)

Skills (archivos de habilidades) resuelven un costo que se desperdicia cada vez:Cada nueva conversación, el Agente tiene que deducir desde cero las convenciones de tu proyecto。

Un Skill es una carpeta que contiene unSKILL.mdarchivo que documenta convenciones del proyecto, pasos de compilación, y conocimiento como “no hacemos esto por aquel incidente”. El Agente carga el Skill al inicio de cada sesión, en lugar de adivinar de nuevo cada vez.

Ejemplo

<!-- Ruta del archivo: .claude/skills/project-conventions/SKILL.md -->
---
name
: project-conventions
description
: Convenciones de codificación del proyecto y pasos de construcción. Cualquier tarea que implique modificación de código debe cargar esta skill.
---

## Pila tecnológica
- Backend: Node.js20 + TypeScript 5.4 + Fastify
- Base de datos: PostgreSQL16, ORM usa Drizzle
- Pruebas: Vitest; los archivos de prueba van en __tests__/ al mismo nivel que src/

## Comandos de construcción
- Instalar dependencias: pnpm install
- Ejecutar pruebas: pnpm test
- Verificación de tipos: pnpm typecheck
- Generar artefactos de compilación: pnpm build

## Convenciones principales
- Todas las consultas a la base de datos deben pasar por las funciones encapsuladas en src/db/queries/; prohibido escribir SQL directamente en la capa de negocio
- Los errores deben usar uniformemente la clase AppError (src/errors/AppError.ts); prohibido lanzar strings sueltos
- Nombres de archivos de rutas de API:{resource}.routes.ts, colocados en src/routes/
- Toda API nueva debe actualizar también docs/api.md

## Prohibiciones
- No modificar directamente los archivos de migración históricos en el directorio migrations/
- No incluir claves reales en el archivo .env; usar .env.example como marcador de posición

Elemento 4: Conectores (Connectors / MCP)

Un Loop que solo puede ver el sistema de archivos local puede hacer muy poco. Los conectores (basados en MCP – Model Context Protocol) permiten al Agente leer el seguimiento de Issues, consultar bases de datos, llamar APIs y enviar mensajes en Slack.

Esta es la diferencia clave entre “el Agente dice aquí está la solución” y “el Loop abre automáticamente un PR, vincula el Ticket y notifica al canal cuando el CI pasa”.

Claude Code y OpenAI Codex son compatibles de forma nativa con el protocolo MCP, por lo que un conector escrito para una herramienta suele funcionar en ambas.

Ejemplo: Configurar conectores MCP en Claude Code

// Ruta del archivo: .claude/mcp.json
// Configurar el conector MCP para que el agente pueda operar GitHub y enviar notificaciones de Slack
{
  "connectors": [
    {
      "name": "github",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    {
      "name": "slack",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}"
      }
    }
  ]
}

Conectar un conector al agente significa que este puede tomar acciones reales en un entorno real. Se debe configurar el principio de mínimo privilegio para cada conector, y las operaciones de alto riesgo (empujar código, fusionar PR, enviar notificaciones externas) deben requerir aprobación humana y no ejecutarse de forma totalmente automática.

Elemento 5: Subagentes (Sub-Agents)

Una de las decisiones de arquitectura más importantes en el Loop:Separar el agente que escribe código del agente que revisa el código。

El modelo que escribió el código tiende a ser demasiado indulgente al calificar su propio trabajo. Un revisor independiente con instrucciones diferentes —a veces incluso usando un modelo distinto— puede detectar los problemas que el primer agente pasó por alto al justificarse a sí mismo.

Este patrón de "creador-revisor" (Maker-Checker) también se aplica a la condición de detención del Loop: el comando de Claude Code/goalDespués de cada iteración, el comando utiliza un modelo separado para determinar si está "completado", en lugar de permitir que el modelo que realizó el trabajo lo determine.

Ejemplo: Definir un subagente verificador

<!-- Ruta del archivo: .claude/agents/spec-reviewer.md -->
---
name
: spec-reviewer
description
: Realizar una revisión adversarial de los cambios de código completados, verificando que cumplan con las especificaciones y los requisitos de prueba.
model
: opus            # Usar un modelo más potente como verificador
isolation
: worktree    # Realizar la comprobación de forma independiente para evitar contaminar el área de trabajo del creador
---

Eres un revisor de código adversarial. Tu trabajo no es aprobar, sino cuestionar.

Cuando recibas un diff, debes:
1. Ejecutar la suite de pruebas completa (pnpm test) y registrar los fallos
2. Ejecutar la comprobación de tipos (pnpm typecheck)
3. Comparar el diff con las especificaciones del proyecto en SKILL.md
4. Verificar que los cambios de comportamiento visibles para el usuario coincidan con los requisitos originales

Solo cuando todas las pruebas pasen, la comprobación de tipos esté limpia y no haya violaciones de especificaciones, se debe generar APPROVED.
De lo contrario, genera una razón de rechazo concreta; no des evaluaciones vagas.

Elemento 6: Memoria persistente (Memory)

La memoria es el pilar central de todo Loop que pueda ejecutarse de forma continua a través de conversaciones.

El modelo olvida por completo entre conversaciones. Sin memoria externa, cada vez que se activa el Loop el agente empieza desde cero, sin saber qué se hizo ayer, qué correcciones ya se fusionaron o qué tareas siguen abiertas.

La solución es extremadamente simple:Escribir el estado en un archivo y colocar ese archivo en el repositorio. El repositorio recuerda, aunque el modelo no recuerde.

Ejemplo: Archivo de estado del Loop

<!-- Ruta del archivo: TODO.md (el archivo de estado del Loop, que se envía junto con el código) -->
# Estado de las tareas del Loop

Última actualización:2026-06-1409:03 UTC (actualizado por el Loop automático)

## En curso
- [ ]Test inestable en test/auth/login.spec.ts (CI Run#4821, falló 3 veces)
- Hipótesis: fuga de estado de sesión entre pruebas concurrentes
- Probado: aislar la conexión de la base de datos de prueba → sin efecto
- Siguiente paso: revisar la lógica de limpieza en beforeEach

## Pendiente
- [ ]Actualizar axios a1.7.x (vulnerabilidad de seguridad CVE-2026-xxxxx)
- [ ]Actualización de la documentación de la API (PR#308 quedó desactualizada respecto al código después de fusionarse)

## Completado
- [x]Corregido el error causado por nombres de empresa con comillas simples en el módulo de facturación500Error (PR#312, fusionado)
- [x]Actualizar la versión de Node.js a20.x(PR #307, fusionado)

Cinco patrones comunes de Loop

Diferentes tipos de tareas de trabajo requieren diferentes señales de retroalimentación y condiciones de detención, por lo que se han desarrollado varios patrones clásicos de Loop.

PatrónSeñal de observación principalCondición de detenciónEscenario típico
Loop impulsado por pruebasPruebas que pasan / fallanTodas las pruebas objetivo pasanCorrección de errores, pruebas de regresión, lógica de transformación de datos
Loop impulsado por el compiladorLista de errores de tipo y errores de compilaciónCero errores en la comprobación de tiposMigración de TypeScript, actualización de dependencias, refactorización
Loop impulsado por revisiónComentarios de revisión humanaTodos los comentarios se procesan o se ignoran con una justificación documentadaSeguimiento mecánico de las revisiones de PR
Loop de depuración en tiempo de ejecuciónRegistros, trazas de pila, respuestas HTTPProblema reproducible → formular hipótesis → verificar la correcciónErrores de producción, problemas de rendimiento, anomalías de interfaz
Loop de iteración de productoCapturas de pantalla, inspecciones de navegador, informes de accesibilidadAlineación con el diseño, comportamiento responsivo correcto, sin violaciones de especificacionesPáginas de aterrizaje, ajustes de UI, componentes de marketing

Construye tu primer Loop

No intentes construir desde el principio un Loop complejo totalmente automático, con múltiples agentes y fusión automática de PR. Comienza con un Loop mínimo viable, comprende su comportamiento y luego expándelo gradualmente.

Paso 1: Comienza con una tarea acotada

Cuanto más acotada sea la tarea, más claro tendrá el agente qué archivos son importantes y qué señales de verificación son relevantes.

Definición de tarea deficienteDefinición de tarea buena
"Optimizar el rendimiento del panel""Reducir el tiempo de carga inicial del panel en un 30% retrasando la carga de gráficos no críticos, manteniendo al mismo tiempo el funcionamiento de los filtros existentes"
"Arreglar el problema de checkout""Corregir la prueba de cálculo de impuestos que falla en test/checkout/tax.spec.ts"
"Mejorar la página de configuración""Corregir el problema de diseño del botón de eliminación de cuenta que se corta en dispositivos móviles (ancho de 375px)"

Paso 2: Indica claramente el método de verificación

El Loop necesita saber qué significa "completado". Si conoces el comando de verificación, inclúyelo directamente en las instrucciones.

Ejemplo: Instrucción de Loop con condiciones de verificación

# Mal: no hay condición de verificación, el agente no sabe cuándo detenerse
/goal "Fix the auth bug"

# Bien: hay un comando de verificación concreto y criterios de éxito
/goal "Fix the session leak causing flaky tests in test/auth/login.spec.ts.
       Success condition: run 'pnpm test test/auth/login.spec.ts' 5 times
       consecutively with zero failures. Do not touch other test files."

Paso 3: Establece mecanismos de seguridad

Antes de que el Loop pueda abrir PR automáticamente, haz que solo escriba archivos y no realice ninguna operación externa; tú revisas el diff y decides si hacer commit.

Ejemplo: Loop de clasificación de fallos de CI diario (versión mínima segura)

# Este es el primer Loop recomendado:
# - Solo operaciones de lectura (leer registros de CI, leer Issues)
# - Solo escribir TODO.md (no tocar otros archivos)
# - No abrir PR ni fusionar código
# - Cada mañana revisas TODO.md y decides manualmente el siguiente paso

/loop "Read yesterday's CI failure logs and GitHub Issues labeled 'bug'.
       Categorize findings by likely cause.
       Write a summary with prioritized action items to TODO.md.
       Do NOT edit any source files. Do NOT open any PRs."
\
       --schedule "0 8 * * 1-5"

Este Loop mínimo ya es muy valioso: cada mañana organiza la lista de problemas del día anterior, y cuando llegas a la oficina abres TODO.md y sabes qué hacer hoy, en lugar de pasar media hora revisando los registros de CI. Es el mejor punto de partida para entender el comportamiento del Loop, con un riesgo casi nulo.

Paso 4: Aumenta gradualmente el grado de autonomía

FaseLo que el Loop puede hacerLo que hace el humano
Fase 1 (solo lectura)Detectar problemas, clasificar tareas, escribir el archivo de estadoRevisar TODO.md y decidir manualmente el orden de procesamiento
Fase 2 (borrador)Redactar propuestas de corrección, ejecutar pruebas, escribir en la ramaRevisar el diff y ejecutar git push manualmente
Fase 3 (semiatomática)Abrir un Draft PR, ejecutar CI, notificar a SlackRevisar el PR y hacer clic manualmente en Merge
Fase 4 (totalmente automática)Dos agentes: creador + revisor, fusión automática después de que CI paseIntervención humana en casos excepcionales, auditoría periódica del historial de fusiones

Tres grandes riesgos de Loop Engineering

El Loop cambia la forma de trabajar, pero no elimina la responsabilidad del ingeniero. Hay tres problemas que se vuelven más graves a medida que el Loop mejora, y no más fáciles.

Riesgo 1: La verificación sigue siendo tu responsabilidad

Un Loop que se ejecuta sin supervisión también es un Loop que produce errores sin supervisión. Configurar un sub-agente verificador es un buen método para reducir el riesgo, pero "pasó la verificación" es una declaración, no una prueba.

No importa cuán confiable sea el Loop, la revisión humana del código fusionado no puede desaparecer.

Riesgo 2: La deuda de comprensión (Comprehension Debt) se acumula más rápido

Cuanto más rápido el Loop produce código, menor es la proporción de código que realmente comprendes. Este no es un problema exclusivo de la programación con IA, pero el Loop lo acelera.

El único antídoto es:Leer el código producido por el Loop. No dejes de entender qué está haciendo solo porque el Loop funciona sin problemas.

Riesgo 3: Rendición cognitiva (Cognitive Surrender)

Cuando el Loop funciona automáticamente, aceptar cualquier resultado que devuelva es la opción más cómoda. Este es el peligro más latente de la Ingeniería de Loops.

Dos personas pueden construir exactamente el mismo Loop y obtener resultados completamente opuestos: uno lo usa para avanzar más rápido sobre la base de una comprensión profunda, el otro lo usa para evitar el trabajo de comprensión en sí. El Loop no conoce la diferencia. Tú sí.

Cuatro tipos de modos de fallo del Loop y métodos para abordarlos:

Modo de falloManifestaciónCausa raízSolución
Marcha en vacío (Thrashing)El Agent modifica el código repetidamente, pero no convergeEl objetivo no es claro, o la señal de verificación tiene ruido, o el alcance de cada modificación es demasiado grandeReduce el alcance del objetivo, disminuye el tamaño de cada diff, usa comandos de verificación más confiables
Sobreajuste a las pruebasTodas las pruebas pasan, pero la funcionalidad en realidad es incorrectaLa cobertura de pruebas es demasiado estrecha, no se verifican escenarios reales de usuarioCombina pruebas automáticas y comprobaciones de aceptación humana, añade pruebas de extremo a extremo
Deriva de contextoEl Agent continúa trabajando basándose en suposiciones obsoletas, ignorando los cambios que surgenNo se actualiza el contexto después de observaciones claveVuelve a recopilar el contexto después de observaciones importantes, no trates el plan inicial como sagrado
Autonomía inseguraEl Agent ejecuta operaciones destructivas sin autorizaciónEl alcance de permisos es demasiado amplio, no hay condiciones claras de detenciónPrincipio de mínimo privilegio, las operaciones de alto riesgo deben requerir aprobación humana, establece reglas claras de detención

Resumen de mejores prácticas

Los siguientes son los principios centrales para construir un Loop confiable, cada uno corresponde a un tipo común de fallo.

PrincipioPráctica concreta
Empieza con tareas estrechasDefine solo un objetivo con límites claros cada vez; un objetivo amplio impide que el Agent determine qué archivos y qué señales de verificación son relevantes
Dile al Agent cómo verificarEscribe directamente el comando de verificación en las instrucciones (pnpm test test/auth), escenarios de aceptación o endpoints de API, para que "completado" sea medible
Prefiere cambios pequeños y reversiblesExige al Agent hacer la modificación coherente más pequeña, ejecuta la verificación y luego expande; las reescrituras especulativas a gran escala dificultan determinar qué suposición falló
Respeta los patrones de código existentesHaz que el Agent revise primero las implementaciones adyacentes, reutilice los componentes existentes, siga la nomenclatura existente y evite introducir abstracciones nuevas innecesarias
Los humanos mantienen el asiento del juicioEl Agent maneja la recopilación de evidencia y las correcciones mecánicas; el juicio de producto, las decisiones de arquitectura y la revisión final quedan reservados para los humanos
Consolida Loops reutilizablesCuando un Loop funciona bien, consolídalo como un archivo de Skill o un desencadenante estandarizado, para reducir el costo de repetición en el futuro
Otras extensiones