Cómo construir tu primer bucle de IA en 2026

Dos de los ingenieros de IA más senior vivos dijeron lo mismo el mes pasado.

Peter Steinberger, creador de OpenClaw, ahora en OpenAI:

"Ya no deberías hacer prompting a los agentes de código. Deberías diseñar bucles que hagan prompting a tus agentes."

Boris Cherny, líder de Claude Code en Anthropic:

"Ya no le hago prompting a Claude. Tengo bucles ejecutándose que le hacen prompting a Claude y deciden qué hacer. Mi trabajo es escribir bucles."

La mayoría de la gente leyó eso y pensó: ¿qué significa realmente?

Y más importante: ¿cómo construyo uno?

Este artículo te dice exactamente cómo.

Sin teoría sin código. Sin código sin contexto. Pasos reales. Comandos reales. Copia y ejecuta.

Slate orquestando GPT-5.6, Claude y subagentes especializados en una tarea de migración real. El modelo se volvió más inteligente. El cambio más grande es que herramientas como Slate finalmente pueden mantener esos modelos ocupados de forma continua, en lugar de esperar prompts humanos.

La forma en que la mayoría usa la IA ya está desactualizada

Escribir prompt. Esperar. Leer salida. Arreglarlo manualmente. Escribir otro prompt.

Tú eres el bucle.

Cada paso pasa por ti. La IA espera. Tú decides. La IA espera otra vez.

En el momento en que te detienes, todo se detiene.

Los constructores que se mueven más rápido en 2026 no están escribiendo mejores prompts.

Están construyendo sistemas que hacen el prompting por ellos.

El punto de apalancamiento se ha movido.

De escribir prompts → a diseñar bucles.

¿Qué cambió con GPT-5.6?

GPT-5.6 no cambia la necesidad de bucles.

Aumenta su valor.

Mientras mejor se vuelve el modelo, más caro resulta dejarlo inactivo entre prompts.

En flujos de trabajo de terminal, GPT-5.6 es notablemente mejor en:

→ entender bases de código grandes

→ mantener consistencia en la implementación

→ seguir planes de varios pasos

→ recuperarse de intentos fallidos

→ actuar como un verificador estricto

El resultado no es "mejor prompting".

Sino menos intervenciones humanas por tarea.

Qué es realmente un bucle

Definición simple:

Un prompt responde una vez y se detiene.

Un bucle sigue trabajando hasta que el trabajo está realmente hecho.

No hasta que genera una respuesta.

Hasta que alcanza un resultado verificado.

Cada agente de IA serio ejecuta el mismo ciclo subyacente:

→ Descubrir — ¿qué hay que hacer?

→ Ejecutar — hacer el trabajo

→ Verificar — ¿funcionó realmente?

→ Iterar — ¿no está listo? corregir y repetir

→ Detener — condición cumplida, o límite duro alcanzado

Claude Code. Cursor. Codex.

Por debajo, todos ejecutan este bucle.

La diferencia entre un prompt y un bucle no es el modelo.

Es si algo verifica el trabajo y sigue hasta que pase.

La prueba de 4 condiciones — ejecuta esto antes de construir cualquier cosa

La mayoría de los bucles fallan aquí.

Un bucle justifica su costo de configuración solo cuando las 4 condiciones son verdaderas.

Falla una y el bucle cuesta más de lo que devuelve.

1. La tarea se repite. Al menos semanalmente. Una tarea única sigue siendo mejor atendida con un buen prompt.

2. La verificación está automatizada. Algo debe reprobar el trabajo sin que tú estés presente. Tests. Linters. Builds. Type checks. Sin puerta = el agente se califica su propia tarea.

3. Tu presupuesto de tokens puede absorber el desperdicio. Los bucles releen el contexto completo en cada iteración. Reintentan, exploran, queman tokens sin importar si la ejecución produce algo. Este es el costo que nadie menciona.

4. "Terminado" es objetivo. Un test que pasa o falla. Un build que compila o no. No "cuando se vea bien". Si terminado requiere una opinión humana, mantenlo manual.

Pasa las 4 → construye el bucle.

Falla cualquiera → usa un prompt en su lugar.

La versión honesta: la mayoría de los desarrolladores aún no necesitan bucles pesados. Lo que todos pueden usar es un bucle simple. Construiremos uno en breve.

Instalar Slate

Slate es un agente de codificación de IA construido exactamente para esto — ejecutar tareas largas, paralelas y de varios pasos en tu terminal.

Construido por RandomLabs. El primer agente construido específicamente para orquestación de enjambres.

Lo que lo diferencia de Claude Code o Cursor:

→ Selecciona automáticamente el modelo correcto para cada paso. Planifica con Claude, busca con otro, ejecuta con Codex — Slate decide.

→ Ejecuta subagentes paralelos simultáneamente en tu base de código

→ Gestiona su propio contexto en sesiones largas de varias horas

→ Trabaja junto a ti — no solo para ti

Instálalo en una línea:

1npm i -g @randomlabs/slate

Navega a tu proyecto e inícialo:

1cd /ruta/a/tu/proyecto
2slate

Eso abre la TUI de Slate — una interfaz de terminal donde le das tareas y ves cómo trabaja.

Paso 1 — Configura tu espacio de trabajo

Antes de que Slate pueda ejecutar bucles en tu proyecto, necesita entender tu base de código.

Crea un archivo AGENTS.md en la raíz de tu proyecto. Este es el contexto que Slate lee al inicio de cada sesión.

1# AGENTS.md
2
3## Qué hace esta base de código
4[Descripción de un párrafo del proyecto]
5
6## Arquitectura
7- src/api/ — Rutas de Express API
8- src/services/ — Lógica de negocio
9- src/db/ — Modelos de base de datos (PostgreSQL vía Prisma)
10- tests/ — Suite de tests Jest
11
12## Comandos clave
13- npm test — ejecutar la suite completa de tests
14- npm run build — compilación TypeScript
15- npm run lint — verificación ESLint
16- npm run typecheck — tsc --noEmit
17
18## Reglas
19- Nunca modificar src/billing/ o src/auth/ sin aprobación humana
20- Siempre ejecutar tests antes de marcar cualquier tarea como completa
21- Usar el patrón de manejo de errores existente en src/utils/errors.ts
22
23## Entorno
24- .env.slate contiene todas las variables de entorno que Slate necesita

Slate lee este archivo automáticamente al inicio — no es necesario pegarlo cada sesión.

Agrega tus directorios de trabajo dentro de Slate:

1/workspace add ./src
2/workspace add ./tests
3/workspace list

O referencia archivos específicos en línea usando menciones @:

1Por favor revisa @src/api/routes.ts y sugiere mejoras

Paso 2 — Configura Slate

Crea slate.json en la raíz de tu proyecto para controlar cómo se comporta Slate.

1{
2  "$schema": "https://randomlabs.ai/config.json",
3  "permission": {
4    "*": "allow",
5    "bash": "ask"
6  },
7  "models": {
8    "main": { "default": "anthropic/claude-opus-4.6" },
9    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
10    "search": { "default": "anthropic/claude-haiku-4.5" },
11    "reasoning": { "default": "openai/gpt-5.6" }
12  }
13}

Qué hace esto:

→ "*": "allow" — Slate puede leer y escribir archivos sin preguntar cada vez

→ "bash": "ask" — Slate pregunta antes de ejecutar comandos de shell (mantén esto activo hasta que confíes en él)

→ Configuración de modelos — modelo barato y rápido para búsqueda, modelo caro para razonamiento principal

Para ejecuciones de CI o automatización donde quieras cero interrupciones:

1slate run "Ejecuta la suite de tests y arregla cualquier fallo" --dangerously-skip-permissions --output-format stream-json

Paso 3 — Tu primera tarea (aún no un bucle)

Antes de construir un bucle, haz que una ejecución manual única sea confiable.

Este es el paso más omitido. Y la razón por la que la mayoría de los bucles fallan en producción.

Dale a Slate una tarea real:

1Por favor revisa la arquitectura de toda mi base de código.
2Crea un ARCH.md con:
3- estructura actual
4- dependencias entre módulos
5- 3 cosas para mejorar
6Mira primero @src/, luego @tests/

Observa a Slate trabajar. Hará:

1. Buscar en tus archivos
2. Construir comprensión de la arquitectura
3. Redactar el ARCH.md
4. Revisarlo contra tu solicitud antes de detenerse

Esto ya es un mini-bucle — verifica su propia salida antes de terminar.

Para una tarea más larga:

1Oye Slate, investiga mi base de código para el flujo de autenticación,
2luego haz un plan para agregar soporte OAuth2.
3Asegúrate de mirar @src/auth/ y @src/api/routes.ts

Slate devuelve un plan. Tú iteres sobre él:

1No, no agregues una nueva clase de proveedor de autenticación.
2Haz que siga el mismo patrón que el ApiKeyAuth existente en src/auth/api-key.ts

Aprueba el plan. Slate ejecuta de forma autónoma.

Paso 4 — Crea una Skill (haz que el bucle sea reutilizable)

Una Skill es cómo dejas de reexplicar tu proyecto cada sesión.

Escríbela una vez. Slate la lee en cada ejecución relevante.

Crea la estructura de carpetas:

1mkdir -p .slate/skills/ci-triage
2touch .slate/skills/ci-triage/SKILL.md

Escribe la skill:

1---
2name: "ci-triage"
3description: "Clasificar fallos de CI por causa raíz y redactar correcciones para los fáciles."
4---
5
6# CI Triage Skill
7
8## Qué hago
9Cuando falla una ejecución de CI, yo:
101. Leo la salida de los tests
112. Clasifico el fallo: problema de entorno / test inestable / bug real / cambio de dependencia / infra
123. Redacto correcciones para bugs y problemas de dependencia
134. Escalo problemas de entorno e infra a humanos
14
15## Reglas de clasificación
16- env: secreto faltante, variable de entorno incorrecta → marcar para humano
17- flake: pasa al reintentar sin cambio de código → reintentar una vez, luego crear issue
18- bug: fallo determinista vinculado a un commit reciente → redactar corrección
19- dependency: fallo vinculado a un cambio de versión → redactar PR de reversión
20- infra: timeout, OOM, problema de runner → escalar de inmediato
21
22## Patrones de corrección
23- Fallos de tests de autenticación → revisar src/auth/middleware.ts primero
24- Fallos de tests de base de datos → verificar que la migración se ejecutó en el entorno de CI
25- Fallos de E2E → verificar selectores de UI contra la última snapshot
26
27## Nunca hacer
28- Deshabilitar tests que fallan
29- Modificar la configuración de CI sin preguntar
30- Tocar src/billing/ o src/payments/
31
32## Estado
33Actualizar STATE.md después de cada ejecución:
34- Archivos revisados
35- Clasificaciones realizadas
36- PRs abiertos
37- Elementos escalados

Lista las skills disponibles dentro de Slate:

1/skills

Activa una manualmente:

1@ci-triage por favor clasifica los tests fallidos de hoy

O Slate activa skills automáticamente cuando decide que son relevantes para la tarea actual.

Paso 5 — Agrega estado (la memoria del bucle)

El agente olvida.

El archivo, no.

Crea STATE.md en la raíz de tu proyecto:

1# Loop State — CI Triage
2
3## Última ejecución
42026-06-28 03:30 UTC — 7 fallos clasificados, 3 correcciones redactadas, 4 escalados
5
6## En progreso
7- claude/fix-auth-token-refresh — tests pasando localmente, esperando CI
8- claude/fix-flaky-payment-webhook — patrón de reintento aplicado, monitoreando
9
10## Completado
11- claude/bump-axios-1.7.4 → fusionado (CI verde)
12- claude/lint-fix-pass-june-28 → fusionado
13
14## Escalados a humanos
15- src/billing/refund.ts — tests fallando de 3 maneras, causa raíz no clara
16- ci/staging-runner — timeouts de infra, no es un problema de código
17
18## Lecciones aprendidas
19- 2026-06-27: PowerShell tiene un problema de TLS 1.2 en este runner de Windows. Usar bash.
20- 2026-06-26: tests/e2e/checkout requiere secreto de webhook de Stripe en env. Omitir si falta.

Dile a Slate que lo use al inicio de cada sesión agregándolo a AGENTS.md:

1## Inicio de sesión
2Siempre leer STATE.md primero. Continuar donde terminó la última ejecución.
3Actualizar STATE.md al final de cada ejecución con lo que se hizo y lo que sigue.

Sin estado: cada ejecución comienza desde cero.

Con estado: cada ejecución se reanuda y se acumula sobre la anterior.

Paso 6 — Construye el bucle real

Ahora tienes:

→ Espacio de trabajo configurado (AGENTS.md)

→ Configuración establecida (slate.json)

→ Una ejecución manual confiable comprobada

→ Una skill escrita (ci-triage)

→ Archivo de estado creado (STATE.md)

Es hora de envolverlo en un bucle real.

Opción A: Bucle de archivo de cola (el más simple)

Crea loop.md:

1Lee STATE.md para entender qué ya se intentó.
2
3Ejecuta la skill de CI triage en todos los tests fallidos del último build.
4
5Para cada fallo:
6- Clasifícalo usando las reglas de la skill ci-triage
7- Redacta una corrección para bugs y problemas de dependencia
8- Escala problemas de entorno e infra
9
10Ejecuta las correcciones. Verifica si los tests pasan.
11Si los tests pasan → abre un PR.
12Si los tests aún fallan → registra en STATE.md y detente.
13
14Actualiza STATE.md con todo lo hecho en esta ejecución.
15
16Parada dura: 8 intentos como máximo. Al llegar al límite, reporta el estado actual.

Ejecútalo:

1slate --queue loop.md

Slate lee el archivo de cola y ejecuta cada bloque como un mensaje encolado.

Opción B: Bucle sin cabeza/CI (automatizado)

Ejecuta de forma no interactiva en una GitHub Action o cron job:

1slate run "$(cat loop.md)" --output-format stream-json --dangerously-skip-permissions

En un flujo de trabajo de GitHub Actions:

1name: CI Triage Loop
2on:
3  workflow_run:
4    workflows: ["CI"]
5    types: [completed]
6
7jobs:
8  triage:
9    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
10    runs-on: ubuntu-latest
11    steps:
12      - uses: actions/checkout@v4
13
14      - name: Instalar Slate
15        run: npm i -g @randomlabs/slate
16
17      - name: Ejecutar bucle de triage
18        env:
19          SLATE_API_KEY: ${{ secrets.SLATE_API_KEY }}
20        run: |
21          slate run "$(cat loop.md)" \
22            --output-format stream-json \
23            --dangerously-skip-permissions \
24            --workspace ./src \
25            --workspace ./tests

Ahora cada fallo de CI activa automáticamente el bucle de triage.

No se necesita humano hasta la escalación.

Paso 7 — Agrega subagentes (la división creador-verificador)

La mejora estructural más importante para cualquier bucle.

Nunca dejes que el mismo agente califique su propia tarea.

El modelo que escribió la corrección es un calificador demasiado generoso.

En Slate, puedes configurar diferentes modelos para diferentes roles:

1{
2  "models": {
3    "main": { "default": "anthropic/claude-opus-4.6" },
4    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
5    "search": { "default": "anthropic/claude-haiku-4.5" }
6  }
7}

Luego escribe tu tarea para que Slate use esta división de forma natural:

1Por favor corrige los tests de autenticación que fallan.
2
3Paso 1: Haz que un agente de búsqueda explore src/auth/ para entender la implementación actual.
4Paso 2: Haz que un agente separado implemente la corrección basándose en lo encontrado.
5Paso 3: Haz que un tercer agente verifique la corrección contra los requisitos originales del test —
6        este agente NO debe haber visto la implementación.
7Paso 4: Solo abre el PR si el verificador lo aprueba.

Slate orquesta los subagentes automáticamente.

El agente de búsqueda usa un modelo rápido y barato. El agente de implementación usa un modelo más fuerte. El verificador usa un modelo estricto sin acceso al razonamiento del creador.

Esta división es por qué Slate puede ejecutar 5 subagentes paralelos en una sola tarea — cada uno especializado, cada uno aislado.

Paso 8 — El patrón de bucle con estado (para tareas de larga duración)

Para tareas que se ejecutan durante horas o días, usa este patrón en tu prompt de tarea:

1Estás ejecutando un bucle de múltiples sesiones.
2
3OBJETIVO: Migrar todas las rutas de Express al nuevo patrón ApiError.
4Rastrea el progreso en STATE.md.
5
6INICIO DE CADA SESIÓN:
71. Lee STATE.md
82. Encuentra el primer elemento incompleto en "Rutas restantes"
93. Haz solo ese elemento
10
11FIN DE CADA SESIÓN:
121. Mueve los elementos completados a "Rutas hechas" en STATE.md
132. Registra cualquier bloqueo en "Bloqueos"
143. Actualiza la marca de tiempo de "Última ejecución"
154. Detente limpiamente
16
17Formato de STATE.md:
18---
19## Rutas hechas
20- [x] /api/users (2026-06-27)
21- [x] /api/auth/login (2026-06-28)
22
23## Rutas restantes
24- [ ] /api/payments/checkout
25- [ ] /api/payments/refund
26- [ ] /api/admin/users
27
28## Bloqueos
29- /api/payments/refund — requiere revisión humana (toca lógica de facturación)
30
31## Última ejecución
322026-06-28 14:30 UTC
33---
34
35REGLAS DURAS:
36- Nunca tocar src/billing/ sin aprobación humana
37- Siempre ejecutar tests después de cada migración de ruta
38- Detenerse después de completar UNA ruta por sesión

Ejecuta esto cada mañana:

1slate --continue "$(cat loop.md)"

--continue retoma la sesión más reciente en lugar de empezar de nuevo.

Cada día, una ruta más. STATE.md lo rastrea todo.

El bucle se reanuda exactamente donde se detuvo.

Paso 9 — Comandos personalizados para tus bucles más usados

Agrega comandos de barra personalizados a slate.json para que tus bucles estén siempre a una tecla de distancia:

1{
2  "command": {
3    "triage": {
4      "description": "Ejecutar bucle de triage de CI",
5      "template": "Lee STATE.md. Ejecuta la skill ci-triage en todos los tests fallidos. Actualiza STATE.md al terminar.",
6      "agent": "build"
7    },
8    "review": {
9      "description": "Revisar un archivo para verificar corrección",
10      "template": "Revisa @$ARGUMENTS en busca de corrección, casos extremos y consistencia con el código circundante."
11    },
12    "migrate": {
13      "description": "Migrar una ruta al patrón ApiError",
14      "template": "Lee STATE.md. Migra la siguiente ruta incompleta al patrón ApiError. Ejecuta tests. Actualiza STATE.md."
15    }
16  }
17}

Ahora dentro de Slate:

1/triage
2/review src/api/payments.ts
3/migrate

Cada uno ejecuta tu prompt de bucle preescrito al instante.

3 bucles completos que puedes ejecutar hoy

Bucle 1: Triage de fallos de CI (el que construimos)

Cuándo: cada fallo de CI Qué: clasificar → corregir fáciles → escalar difíciles → abrir PRs Estado: STATE.md Puerta: tests pasan Tiempo de configuración: 30 minutos

1# disparador
2slate run "$(cat loop.md)" --dangerously-skip-permissions --output-format stream-json
3
4# o en GitHub Actions — ver Paso 6 arriba

Bucle 2: Resumen matutino

Cuándo: 7am cada día laborable (cron job) Qué: escanear últimas 24h de commits, PRs y issues abiertos → escribir un resumen de 5 viñetas → publicar en Slack

1# loop.md para resumen matutino
2cat > morning-brief-loop.md << 'EOF'
3Lee las últimas 24 horas de:
4- git log --since="24 hours ago" --oneline
5- PRs abiertos en draft o revisión
6- Issues de GitHub abiertos o actualizados en las últimas 24h
7
8Escribe un resumen matutino:
9- 3 cosas más importantes que sucedieron
10- 2 cosas que necesitan atención hoy
11- 1 cosa en riesgo de bloquear a alguien
12
13Mantenlo por debajo de 120 palabras. Publícalo en el canal de #engineering de Slack.
14EOF
15
16# ejecutar con cron
170 7 * * 1-5 slate run "$(cat morning-brief-loop.md)" --dangerously-skip-permissions

Bucle 3: Bucle de actualización de dependencias

Cuándo: cada lunes Qué: escanear paquetes desactualizados → probar compatibilidad → abrir PRs para actualizaciones seguras

1cat > deps-loop.md << 'EOF'
2Lee STATE.md.
3
4Ejecuta: npm outdated
5
6Para cada paquete desactualizado:
71. Verifica si el cambio de versión es major (ruptura) o minor/patch (seguro)
82. Para minor/patch: actualiza el paquete, ejecuta npm test
93. Si los tests pasan: abre un PR
104. Si los tests fallan: registra en STATE.md como "necesita revisión humana"
115. Para cambios major: siempre escalar a humanos
12
13Reglas duras:
14- Nunca actualizar más de 5 paquetes en un solo bucle
15- Nunca actualizar paquetes en la sección "peer dependencies"
16- Siempre ejecutar la suite completa de tests después de cada actualización, no solo los tests relacionados
17
18Actualiza STATE.md con lo que se actualizó y lo que se escaló.
19EOF
20
21# ejecutar cada lunes
220 9 * * 1 slate run "$(cat deps-loop.md)" --dangerously-skip-permissions

Los modos de fallo que cuestan dinero

Conócelos antes de programar cualquier cosa.

El bucle Ralph Wiggum

El agente declara terminado en un trabajo a medio hacer.

Sale temprano. El bucle sigue gastando. Silenciosamente.

Corrección: condición de parada dura verificada por un modelo fresco.

1CONDICIÓN DE PARADA: Todos los tests en tests/auth/ pasan Y lint devuelve 0.
2Verificar usando una ejecución de verificación separada, no el juicio del propio agente.
3Límite duro: 8 iteraciones. Al límite: reportar estado y detenerse.

Deriva del objetivo

En sesiones largas, las restricciones iniciales desaparecen.

"Nunca tocar src/billing/" del mensaje 3 se ha ido para el mensaje 47.

Corrección: agrega un VISION.md que Slate relea al inicio de cada sesión.

1# VISION.md — Leer al inicio de cada sesión
2
3## Objetivo central
4Migrar todas las rutas de Express al patrón ApiError.
5
6## Restricciones duras (nunca violar)
7- Nunca tocar src/billing/ sin aprobación humana
8- Nunca deshabilitar tests que fallan
9- Siempre ejecutar la suite completa de tests antes de abrir cualquier PR
10
11## Prioridad actual
12Rutas en src/api/payments/ — manejar con cuidado adicional

Sesgo de autopreferencia

El creador califica su propia tarea. Siempre se aprueba a sí mismo.

Corrección: subagente verificador con cero acceso al razonamiento del creador.

Dile a Slate explícitamente:

1El agente verificador NO debe ver el trabajo del agente implementador.
2Solo debe ver: los requisitos originales del test y la salida del test.
3Si los tests pasan → aprobar. Si los tests fallan → rechazar. Sin opinión de otro modo.

Pereza agentiva

El bucle llama a una tarea "suficientemente hecha" con una finalización parcial.

Especialmente en criterios de éxito vagos.

Corrección: condición de parada objetiva solamente.

1TERMINADO CUANDO: npm test devuelve código de salida 0 Y npm run lint devuelve código de salida 0.
2No cuando "los tests se ven bien". No cuando "la mayoría de los tests pasan".
3Código de salida 0 en ambos comandos. Esa es la única condición de terminado.

Los trucos específicos de Slate que importan

Algunas cosas que hacen a Slate diferente de otros agentes en la práctica.

Encolar mensajes mientras trabaja

Slate está ejecutando una tarea larga. Se te ocurre algo importante.

Presiona Tab para encolar el mensaje — se ejecuta después de que la tarea actual termine, sin interrumpirla.

1[Slate está trabajando en la tarea de migración...]
2
3Tú: En realidad, asegúrate de que el nuevo patrón también maneje el caso donde userId es null
4[Tab — encolado]
5
6[Slate termina el paso actual, luego lee tu mensaje encolado]

Dirigir a mitad de ejecución

Si Slate va en la dirección equivocada, no tienes que detenerlo:

1[Slate está a medio camino de implementar la corrección...]
2
3Tú: Espera — no agregues una nueva clase para esto. Usa el BaseError existente en src/utils/errors.ts
4[Enter — dirige de inmediato]
5
6Slate: Entendido, cambiando el enfoque para usar BaseError...

Usa /enter-mode-next para alternar entre modos de dirigir / encolar / interrumpir.Comandos de shell directamente

Ejecuta comandos dentro de la sesión de Slate sin cambiar a otra terminal:

1!npm test          # ejecutar tests y enviar salida a Slate
2!git diff HEAD     # verificar qué cambió
3!git status        # ver estado actual

Slate lee la salida y la usa en su siguiente acción.

Modo servidor para configuraciones de equipo

Ejecuta Slate como servidor y conéctate desde múltiples terminales:

1# Terminal 1 — iniciar servidor
2slate serve --port 7777
3
4# Terminal 2 — conectar TUI
5slate attach http://localhost:7777 --dir /ruta/al/proyecto

Útil para programación en pareja con Slate o ejecutarlo en una máquina remota.

La lista de verificación completa de configuración

Antes de ejecutar tu primer bucle real:

1□ npm i -g @randomlabs/slate instalado
2□ AGENTS.md creado con descripción del proyecto, comandos, reglas
3□ slate.json creado con permisos y configuración de modelos
4□ Una ejecución manual completada y verificada como confiable
5□ SKILL.md escrita para tu primera tarea repetida
6□ STATE.md creado y referenciado en AGENTS.md
7□ loop.md escrito con condición de parada explícita
8□ Límite duro en iteraciones (8 como máximo para empezar)
9□ El verificador NO es el mismo agente que el creador
10□ Puerta de revisión humana en cualquier acción irreversible (PRs, despliegues)

Marca cada casilla antes de programar cualquier cosa.

Salta una y el bucle o falla silenciosamente o te factura por nada.

Para más inspiración de bucles

Una vez que entiendes el patrón, el cuello de botella se desplaza de "cómo construyo un bucle" a "qué bucle debo construir a continuación".

La Forward Future Loop Library en signals.forwardfuture.com/loop-library es un buen lugar para explorar bucles reales en funcionamiento en distintas categorías: contenido, ingeniería, operaciones, investigación.

Cuando ves 20 bucles funcionales en un solo lugar, dejas de pensar en prompts únicos.

La verdad incómoda

Dos creadores pueden ejecutar exactamente el mismo bucle y obtener resultados opuestos.

Uno lo usa para avanzar más rápido en un trabajo que ya comprende profundamente.

El otro lo usa para evitar entender el trabajo por completo.

El bucle no sabe la diferencia.

Tú sí.

Diseñar bucles es más difícil que la ingeniería de prompts, no más fácil.

El punto no es que el trabajo se haya vuelto más fácil.

El punto de apalancamiento se movió.

Construye el bucle.

Pero constrúyelo como alguien que planea seguir siendo el ingeniero.

No solo la persona que presiona "iniciar".

Y el nuevo GPT-5.6 no reemplaza este principio. Si acaso, lo refuerza.

La frontera ya no es quién escribe el prompt más ingenioso.

Es quién diseña los mejores sistemas en torno a modelos cada vez más capaces.

El resumen en 60 segundos

Qué es un bucle:

→ Prompt = pregunta. Bucle = trabajo.

→ Descubrir → Ejecutar → Verificar → Iterar → Detener

La prueba de las 4 condiciones:

→ La tarea se repite / Verificación automatizada / El presupuesto absorbe desperdicios / "Hecho" es objetivo

Los 5 pasos de configuración:

→ AGENTS.md → slate.json → una ejecución manual → SKILL.md → STATE.md

Luego, envuélvelo:

→ archivo de cola loop.md O ejecución headless de slate en CI

Los modos de falla:

→ Ralph Wiggum (sale temprano) / Deriva de objetivo (olvida restricciones) / Sesgo de autopreferencia (creador = verificador) / Pereza agentiva (suficientemente hecho)

La ventaja de Slate:

→ Selección automática de modelo por paso → Subagentes paralelos con aislamiento → Gestión de sesiones largas → Tu bucle, tu diseño

Si te fue útil:

→ Republícalo para compartirlo con todos los creadores que conozcas

→ Sigue a @sairahul1 para más sistemas como este

→ Marca esto como favorito — solo la lista de verificación de configuración vale la pena guardarla

Suscríbete a theaibuilders.co para más artículos interesantes como este

Escribo sobre IA, creación de productos y sistemas que funcionan mientras duermes.

Herramientas mencionadas:

→ Documentación de Slate: docs.randomlabs.ai

→ Forward Future Loop Library: signals.forwardfuture.com/loop-library