Habilidad de Bucles Autónomos
Nota de compatibilidad (v1.8.0):
autonomous-loopsse conserva por una versión. El nombre canónico ahora escontinuous-agent-loop. Las nuevas guías sobre bucles deben redactarse allí, mientras que esta habilidad permanece disponible para evitar romper flujos de trabajo existentes.
Patrones, arquitecturas e implementaciones de referencia para ejecutar Claude Code de forma autónoma en bucles. Abarca desde simples pipelines claude -p hasta orquestación DAG completa basada en RFC para múltiples agentes.
Cuándo Usarlo
- Configurar flujos de trabajo de desarrollo autónomos que se ejecuten sin intervención humana
- Elegir la arquitectura de bucle adecuada para tu problema (simple vs complejo)
- Construir pipelines de desarrollo continuo al estilo CI/CD
- Ejecutar agentes paralelos con coordinación de fusiones
- Implementar persistencia de contexto en iteraciones de bucle
- Agregar controles de calidad y pasos de limpieza a flujos de trabajo autónomos
Espectro de Patrones de Bucle
De lo más simple a lo más sofisticado:
| Patrón | Complejidad | Mejor Para |
|---|---|---|
| Pipeline Secuencial | Baja | Pasos de desarrollo diarios, flujos de trabajo scripteados |
| REPL NanoClaw | Baja | Sesiones interactivas persistentes |
| Bucle Agéntico Infinito | Media | Generación de contenido en paralelo, trabajo guiado por especificaciones |
| Bucle Continuo de PR de Claude | Media | Proyectos iterativos de varios días con compuertas CI |
| Patrón De-Sloppify | Complemento | Limpieza de calidad después de cualquier paso de Implementador |
| Ralphinho / DAG Guiado por RFC | Alta | Funcionalidades grandes, trabajo paralelo de múltiples unidades con cola de fusión |
1. Pipeline Secuencial (claude -p)
El bucle más simple. Divide el desarrollo diario en una secuencia de llamadas no interactivas claude -p. Cada llamada es un paso enfocado con un prompt claro.
Idea Central
Si no puedes resolver un bucle como este, significa que ni siquiera puedes dirigir el LLM para arreglar tu código en modo interactivo.
La bandera claude -p ejecuta Claude Code de forma no interactiva con un prompt y sale al terminar. Encadena llamadas para construir un pipeline:
#!/bin/bash
# daily-dev.sh — Pipeline secuencial para una rama de funcionalidad
set -e
# Paso 1: Implementar la funcionalidad
claude -p "Lee la especificación en docs/auth-spec.md. Implementa el inicio de sesión OAuth2 en src/auth/. Escribe pruebas primero (TDD). NO crees ningún archivo de documentación nuevo."
# Paso 2: De-sloppify (paso de limpieza)
claude -p "Revisa todos los archivos modificados por el commit anterior. Elimina cualquier prueba de tipo innecesaria, comprobaciones excesivamente defensivas o pruebas de características del lenguaje (por ejemplo, probar que los genéricos de TypeScript funcionan). Mantén las pruebas de lógica de negocio reales. Ejecuta la suite de pruebas después de la limpieza."
# Paso 3: Verificar
claude -p "Ejecuta la compilación completa, el linting, la verificación de tipos y la suite de pruebas. Corrige cualquier fallo. No agregues nuevas funcionalidades."
# Paso 4: Commit
claude -p "Crea un commit convencional para todos los cambios preparados. Usa 'feat: add OAuth2 login flow' como mensaje."
Principios Clave de Diseño
- Cada paso está aislado — Una ventana de contexto nueva por cada llamada
claude -psignifica que no hay contaminación de contexto entre pasos. - El orden importa — Los pasos se ejecutan secuencialmente. Cada uno se basa en el estado del sistema de archivos que dejó el anterior.
- Las instrucciones negativas son peligrosas — No digas "no pruebes los sistemas de tipos". En su lugar, agrega un paso de limpieza separado (consulta el Patrón De-Sloppify).
- Los códigos de salida se propagan —
set -edetiene el pipeline ante un fallo.
Variaciones
Con enrutamiento de modelo:
# Investigación con Opus (razonamiento profundo)
claude -p --model opus "Analiza la arquitectura del código base y escribe un plan para agregar almacenamiento en caché..."
# Implementación con Sonnet (rápido, capaz)
claude -p "Implementa la capa de almacenamiento en caché según el plan en docs/caching-plan.md..."
# Revisión con Opus (exhaustivo)
claude -p --model opus "Revisa todos los cambios en busca de problemas de seguridad, condiciones de carrera y casos extremos..."
Con contexto del entorno:
# Pasa contexto a través de archivos, no de la longitud del prompt
echo "Áreas de enfoque: módulo de autenticación, limitación de tasa de API" > .claude-context.md
claude -p "Lee .claude-context.md para conocer las prioridades. Trabaja en ellas en orden."
rm .claude-context.md
Con restricciones de --allowedTools:
# Paso de análisis de solo lectura
claude -p --allowedTools "Read,Grep,Glob" "Audita este código base en busca de vulnerabilidades de seguridad..."
# Paso de implementación de solo escritura
claude -p --allowedTools "Read,Write,Edit,Bash" "Implementa las correcciones de security-audit.md..."
2. REPL NanoClaw
El bucle persistente integrado de ECC. Un REPL consciente de la sesión que llama a claude -p de forma síncrona con el historial completo de la conversación.
# Iniciar la sesión predeterminada
node scripts/claw.js
# Sesión nombrada con contexto de habilidad
CLAW_SESSION=my-project CLAW_SKILLS=tdd-workflow,security-review node scripts/claw.js
Cómo Funciona
- Carga el historial de la conversación desde
~/.claude/claw/{session}.md - Cada mensaje del usuario se envía a
claude -pcon el historial completo como contexto - Las respuestas se agregan al archivo de sesión (Markdown como base de datos)
- Las sesiones persisten entre reinicios
Cuándo NanoClaw vs Pipeline Secuencial
| Caso de Uso | NanoClaw | Pipeline Secuencial |
|---|---|---|
| Exploración interactiva | Sí | No |
| Automatización scripteada | No | Sí |
| Persistencia de sesión | Integrada | Manual |
| Acumulación de contexto | Crece por turno | Nuevo cada paso |
| Integración CI/CD | Pobre | Excelente |
Consulta la documentación del comando /claw para obtener más detalles.
3. Bucle Agéntico Infinito
Un sistema de dos prompts que orquesta sub-agentes paralelos para la generación impulsada por especificaciones. Desarrollado por disler (crédito: @disler).
Arquitectura: Sistema de Dos Prompts
PROMPT 1 (Orquestador) PROMPT 2 (Sub-Agentes)
┌─────────────────────┐ ┌──────────────────────┐
│ Analizar archivo de especificación | ┌─────────────┐│
│ Escanear directorio de salida │ │ ││
│ Planificar iteración │ despliega ││
│ Asignar direcciones creativas │──────────── ││
│ Gestionar oleadas │ N agentes ││
└─────────────────────┘ └──────────────────────┘
El Patrón
- Análisis de Especificación — El orquestador lee un archivo de especificación (Markdown) que define qué generar
- Reconocimiento de Directorio — Escanea la salida existente para encontrar el número de iteración más alto
- Despliegue Paralelo — Lanza N sub-agentes, cada uno con:
- La especificación completa
- Una dirección creativa única
- Un número de iteración específico (sin conflictos)
- Una instantánea de las iteraciones existentes (para unicidad)
- Gestión de Oleadas — Para el modo infinito, despliega oleadas de 3-5 agentes hasta que se agote el contexto
Implementación a través de Comandos de Claude Code
Crea .claude/commands/infinite.md:
Analiza los siguientes argumentos de $ARGUMENTS:
1. spec_file — ruta al markdown de especificación
2. output_dir — donde se guardan las iteraciones
3. count — entero 1-N o "infinite"
FASE 1: Lee y comprende profundamente la especificación.
FASE 2: Lista output_dir, encuentra el número de iteración más alto. Comienza en N+1.
FASE 3: Planifica direcciones creativas — cada agente recibe un tema/enfoque DIFERENTE.
FASE 4: Despliega sub-agentes en paralelo (herramienta Task). Cada uno recibe:
- Texto completo de la especificación
- Instantánea del directorio actual
- Su número de iteración asignado
- Su dirección creativa única
FASE 5 (modo infinito): Bucle en oleadas de 3-5 hasta que el contexto sea bajo.
Invocación:
/project:infinite specs/component-spec.md src/ 5
/project:infinite specs/component-spec.md src/ infinite
Estrategia de Lotes
| Conteo | Estrategia |
|---|---|
| 1-5 | Todos los agentes simultáneamente |
| 6-20 | Lotes de 5 |
| infinito | Oleadas de 3-5, sofisticación progresiva |
Idea Clave: Unicidad mediante Asignación
No confíes en que los agentes se diferencien por sí mismos. El orquestador asigna a cada agente una dirección creativa y un número de iteración específicos. Esto evita conceptos duplicados entre agentes paralelos.
4. Bucle Continuo de PR de Claude
Un script de shell de nivel de producción que ejecuta Claude Code en un bucle continuo, creando PRs, esperando CI y fusionando automáticamente. Creado por AnandChowdhary (crédito: @AnandChowdhary).
Bucle Central
┌─────────────────────────────────────────────────────┐
│ ITERACIÓN CONTINUA DE CLAUDE │
│ │
│ 1. Crear rama (continuous-claude/iteracion-N) │
│ 2. Ejecutar claude -p con prompt mejorado │
│ 3. (Opcional) Paso de revisor — claude -p separado │
│ 4. Hacer commit de cambios (claude genera mensaje) │
│ 5. Hacer push + crear PR (gh pr create) │
│ 6. Esperar verificaciones CI (poll gh pr checks) │
│ 7. ¿Fallo de CI? → Paso de corrección automática │
│ 8. Fusionar PR (squash/merge/rebase) │
│ 9. Volver a main → repetir │
│ │
│ Limitar por: --max-runs N | --max-cost $X │
│ --max-duration 2h | señal de finalización │
└─────────────────────────────────────────────────────┘
Instalación
Advertencia: Instala continuous-claude desde su repositorio después de revisar el código. No canalices scripts externos directamente a bash.
Uso
# Básico: 10 iteraciones
continuous-claude --prompt "Agrega pruebas unitarias para todas las funciones no probadas" --max-runs 10
# Limitado por costo
continuous-claude --prompt "Corrige todos los errores de linter" --max-cost 5.00
# Limitado por tiempo
continuous-claude --prompt "Mejora la cobertura de pruebas" --max-duration 8h
# Con paso de revisión de código
continuous-claude \
--prompt "Agrega funcionalidad de autenticación" \
--max-runs 10 \
--review-prompt "Ejecuta npm test && npm run lint, corrige cualquier fallo"
# Paralelo mediante worktrees
continuous-claude --prompt "Agrega pruebas" --max-runs 5 --worktree tests-worker &
continuous-claude --prompt "Refactoriza código" --max-runs 5 --worktree refactor-worker &
wait
Contexto entre Iteraciones: SHARED_TASK_NOTES.md
La innovación crítica: un archivo SHARED_TASK_NOTES.md persiste entre iteraciones:
## Progreso
- [x] Pruebas agregadas para el módulo de autenticación (iteración 1)
- [x] Caso extremo corregido en la renovación del token (iteración 2)
- [ ] Aún falta: pruebas de limitación de tasa, pruebas de límites de error
## Próximos Pasos
- Enfocarse en el módulo de limitación de tasa a continuación
- La configuración simulada (mock) en tests/helpers.ts se puede reutilizar
Claude lee este archivo al inicio de la iteración y lo actualiza al final. Esto supera la brecha de contexto entre invocaciones independientes de claude -p.
Recuperación de Fallos de CI
Cuando fallan las verificaciones de PR, Continuous Claude automáticamente:
- Obtiene el ID de la ejecución fallida mediante
gh run list - Genera un nuevo
claude -pcon contexto de corrección de CI - Claude inspecciona los registros mediante
gh run view, corrige el código, hace commit y push - Vuelve a esperar las verificaciones (hasta
--ci-retry-maxintentos)
Señal de Finalización
Claude puede indicar "He terminado" generando una frase mágica:
continuous-claude \
--prompt "Corrige todos los errores en el rastreador de incidencias" \
--completion-signal "CONTINUOUS_CLAUDE_PROJECT_COMPLETE" \
--completion-threshold 3 # Se detiene después de 3 señales consecutivas
Tres iteraciones consecutivas que señalen finalización detienen el bucle, evitando ejecuciones desperdiciadas en trabajo terminado.
Configuración Clave
| Bandera | Propósito |
|---|---|
--max-runs N | Detenerse después de N iteraciones exitosas |
--max-cost $X | Detenerse después de gastar $X |
--max-duration 2h | Detenerse después del tiempo transcurrido |
--merge-strategy squash | squash, merge, o rebase |
--worktree <nombre> | Ejecución paralela mediante git worktrees |
--disable-commits | Modo de prueba (sin operaciones git) |
--review-prompt "..." | Agregar paso de revisor por iteración |
--ci-retry-max N | Corregir fallos de CI automáticamente (predeterminado: 1) |
5. El Patrón De-Sloppify
Un patrón complementario para cualquier bucle. Agrega un paso dedicado de limpieza/refactorización después de cada paso de Implementador.
El Problema
Cuando le pides a un LLM que implemente con TDD, toma "escribe pruebas" demasiado al pie de la letra:
- Pruebas que verifican que el sistema de tipos de TypeScript funciona (probar
typeof x === 'string') - Comprobaciones en tiempo de ejecución excesivamente defensivas para cosas que el sistema de tipos ya garantiza
- Pruebas para el comportamiento del framework en lugar de la lógica de negocio
- Manejo de errores excesivo que oscurece el código real
¿Por Qué No Instrucciones Negativas?
Agregar "no pruebes los sistemas de tipos" o "no agregues comprobaciones innecesarias" al prompt del Implementador tiene efectos secundarios:
- El modelo se vuelve reticente a TODAS las pruebas
- Omite pruebas legítimas de casos extremos
- La calidad se degrada de manera impredecible
La Solución: Paso Separado
En lugar de restringir al Implementador, déjalo ser exhaustivo. Luego agrega un agente de limpieza enfocado:
# Paso 1: Implementar (déjalo ser exhaustivo)
claude -p "Implementa la funcionalidad con TDD completo. Sé exhaustivo con las pruebas."
# Paso 2: De-sloppify (contexto separado, limpieza enfocada)
claude -p "Revisa todos los cambios en el árbol de trabajo. Elimina:
- Pruebas que verifican el comportamiento del lenguaje/framework en lugar de la lógica de negocio
- Comprobaciones de tipo redundantes que el sistema de tipos ya exige
- Manejo de errores demasiado defensivo para estados imposibles
- Sentencias console.log
- Código comentado
Mantén todas las pruebas de lógica de negocio. Ejecuta la suite de pruebas después de la limpieza para asegurarte de que nada se rompa."
En un Contexto de Bucle
for feature in "${features[@]}"; do
# Implementar
claude -p "Implementa $feature con TDD."
# De-sloppify
claude -p "Paso de limpieza: revisa cambios, elimina excesos de pruebas/código, ejecuta pruebas."
# Verificar
claude -p "Ejecuta compilación + linting + pruebas. Corrige cualquier fallo."
# Commit
claude -p "Haz commit con mensaje: feat: add $feature"
done
Idea Clave
En lugar de agregar instrucciones negativas que tienen efectos secundarios en la calidad, agrega un paso de des-sloppify separado. Dos agentes enfocados superan a un agente restringido.
6. Ralphinho / DAG Guiado por RFC
El patrón más sofisticado. Un pipeline de múltiples agentes guiado por RFC, t
…
[truncado para traducción]