Habilidad de Bucles Autónomos
Nota de compatibilidad (v1.8.0):
autonomous-loopsse conserva por una versión. El nombre canónico de la habilidad ahora escontinuous-agent-loop. Las nuevas guías de 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. Cubre desde tuberías claude -p simples hasta orquestación DAG multiagente basada en RFC.
Cuándo Usar
- Configurar flujos de trabajo de desarrollo autónomos que se ejecutan sin intervención humana
- Elegir la arquitectura de bucle adecuada para tu problema (simple vs complejo)
- Construir tuberías de desarrollo continuo al estilo CI/CD
- Ejecutar agentes paralelos con coordinación de fusiones
- Implementar persistencia de contexto entre iteraciones del bucle
- Agregar puertas de calidad y pasos de limpieza a flujos de trabajo autónomos
Espectro de Patrones de Bucle
Del más simple al más sofisticado:
| Patrón | Complejidad | Mejor Para |
|---|---|---|
| Tubería Secuencial | Baja | Pasos diarios de desarrollo, flujos de trabajo con script |
| REPL NanoClaw | Baja | Sesiones interactivas persistentes |
| Bucle Agéntico Infinito | Media | Generación paralela de contenido, trabajo guiado por especificaciones |
| Bucle Continuo de PRs de Claude | Media | Proyectos iterativos de varios días con puertas CI |
| Patrón de Desloppificación | Complemento | Limpieza de calidad después de cualquier paso de Implementación |
| Ralphinho / DAG basado en RFC | Alta | Funcionalidades grandes, trabajo paralelo multiunidad con cola de fusión |
1. Tubería 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 hacer que el LLM arregle tu código en modo interactivo.
La bandera claude -p ejecuta Claude Code de forma no interactiva con un prompt y sale cuando termina. Encadena llamadas para construir una tubería:
#!/bin/bash
# daily-dev.sh — Tubería 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: Desloppificar (paso de limpieza)
claude -p "Revisa todos los archivos modificados por el commit anterior. Elimina pruebas de tipo innecesarias, 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 el conjunto de pruebas después de la limpieza."
# Paso 3: Verificar
claude -p "Ejecuta la compilación completa, lint, verificación de tipos y conjunto 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 llamada
claude -psignifica que no hay fuga de contexto entre pasos. - El orden importa — Los pasos se ejecutan secuencialmente. Cada uno se basa en el estado del sistema de archivos dejado por 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 Desloppificación).
- Los códigos de salida se propagan —
set -edetiene la tubería en caso de fallo.
Variaciones
Con enrutamiento de modelos:
# 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 (minucioso)
claude -p --model opus "Revisa todos los cambios en busca de problemas de seguridad, condiciones de carrera y casos límite..."
Con contexto de 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 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 incorporado 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 con nombre 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 la sesión (Markdown como base de datos)
- Las sesiones persisten entre reinicios
Cuándo NanoClaw vs Tubería Secuencial
| Caso de Uso | NanoClaw | Tubería Secuencial |
|---|---|---|
| Exploración interactiva | Sí | No |
| Automatización con script | No | Sí |
| Persistencia de sesión | Incorporada | Manual |
| Acumulación de contexto | Crece por turno | Fresco cada paso |
| Integración CI/CD | Pobre | Excelente |
Consulta la documentación del comando /claw para obtener detalles completos.
3. Bucle Agéntico Infinito
Un sistema de dos prompts que orquesta subagentes paralelos para generación impulsada por especificaciones. Desarrollado por disler (crédito: @disler).
Arquitectura: Sistema de Dos Prompts
PROMPT 1 (Orquestador) PROMPT 2 (Subagentes)
┌─────────────────────┐ ┌──────────────────────┐
│ Analizar archivo de │ │ Recibir contexto │
│ especificación │ │ completo │
│ Escanear directorio │ despliega │ Leer número asignado │
│ de salida │────────────│ Seguir especificación │
│ Planificar iteración │ N agentes │ exactamente │
│ Asignar direcciones │ │ Generar salida única │
│ creativas │ │ Guardar en directorio │
│ Gestionar oleadas │ │ de salida │
└─────────────────────┘ └──────────────────────┘
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 subagentes, 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 modo infinito, despliega oleadas de 3-5 agentes hasta que el contexto se agote
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 archivo de especificación en markdown
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 subagentes 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): Buclea en oleadas de 3-5 hasta que el contexto sea bajo.
Invoca:
/project:infinite specs/component-spec.md src/ 5
/project:infinite specs/component-spec.md src/ infinite
Estrategia de Lotes
| Cuenta | Estrategia |
|---|---|
| 1-5 | Todos los agentes simultáneamente |
| 6-20 | Lotes de 5 |
| infinite | 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 específica y un número de iteración. Esto evita conceptos duplicados entre agentes paralelos.
4. Bucle Continuo de PRs de Claude
Un script de shell de nivel de producción que ejecuta Claude Code en un bucle continuo, creando PRs, esperando a CI y fusionando automáticamente. Creado por AnandChowdhary (crédito: @AnandChowdhary).
Bucle Central
┌─────────────────────────────────────────────────────┐
│ ITERACIÓN CONTINUA DE CLAUDE │
│ │
│ 1. Crear rama (continuous-claude/iteración-N) │
│ 2. Ejecutar claude -p con prompt mejorado │
│ 3. (Opcional) Paso de revisor — claude -p separado │
│ 4. Commit de cambios (claude genera mensaje) │
│ 5. Empujar + crear PR (gh pr create) │
│ 6. Esperar verificaciones CI (poll gh pr checks) │
│ 7. ¿Fallo de CI? → Paso de autocorrección (claude -p) │
│ 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] Agregadas pruebas para el módulo de autenticación (iteración 1)
- [x] Corregido caso límite en actualización de token (iteración 2)
- [ ] Aún falta: pruebas de limitación de tasa, pruebas de límites de errores
## Próximos Pasos
- Enfocarse en el módulo de limitación de tasa a continuación
- La configuración simulada en tests/helpers.ts se puede reutilizar
Claude lee este archivo al inicio de la iteración y lo actualiza al final. Esto cierra 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, empuja - Vuelve a esperar las verificaciones (hasta
--ci-retry-maxintentos)
Señal de Finalización
Claude puede señalar "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
| Banderas | Propósito |
|---|---|
--max-runs N | Detener después de N iteraciones exitosas |
--max-cost $X | Detener después de gastar $X |
--max-duration 2h | Detener después de 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 | Autocorrección de fallos de CI (predeterminado: 1) |
5. Patrón de Desloppificación
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 literalmente:
- Pruebas que verifican el funcionamiento del sistema de tipos de TypeScript (probar
typeof x === 'string') - Comprobaciones defensivas excesivas para cosas que el sistema de tipos ya garantiza
- Pruebas para el comportamiento del framework en lugar de la lógica de negocio
- Manejo excesivo de errores 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 vacilante con TODAS las pruebas
- Omite casos de prueba límite legítimos
- La calidad se degrada de manera impredecible
La Solución: Paso Separado
En lugar de restringir al Implementador, déjalo ser minucioso. Luego agrega un agente de limpieza enfocado:
# Paso 1: Implementar (déjalo ser minucioso)
claude -p "Implementa la funcionalidad con TDD completo. Sé minucioso con las pruebas."
# Paso 2: Desloppificar (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 aplica
- Manejo de errores excesivamente defensivo para estados imposibles
- Sentencias console.log
- Código comentado
Mantén todas las pruebas de lógica de negocio. Ejecuta el conjunto 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."
# Desloppificar
claude -p "Paso de limpieza: revisa cambios, elimina slop de pruebas/código, ejecuta pruebas."
# Verificar
claude -p "Ejecuta compilación + lint + pruebas. Corrige cualquier fallo."
# Commit
claude -p "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 desloppificación separado. Dos agentes enfocados superan a un agente restringido.
6. Ralphinho / DAG basado en RFC o Orquestación DAG
El patrón más sofisticado. Una tubería multiagente impulsada por RFC...