Cómo crear tu primer bucle de IA en 2026

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

Peter Steinberger, creador de OpenClaw, ahora en OpenAI:

"Ya no deberías escribir prompts para agentes de codificación. Deberías diseñar bucles que le hagan prompts a tus agentes."

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

"Ya no le hago prompts a Claude. Tengo bucles ejecutándose que le hacen prompts 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 pueden mantener esos modelos ocupados de forma continua en lugar de esperar indicaciones humanas.

La forma en que la mayoría de la gente usa la IA ya está obsoleta

Escribe prompt. Espera. Lee la salida. Corrígelo manualmente. Escribe 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 desarrolladores que avanzan más rápido en 2026 no están escribiendo mejores prompts.

Están construyendo sistemas que hacen los prompts 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.

Cuanto mejor es el modelo, más caro se vuelve dejarlo inactivo entre prompts.

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

→ entender bases de código grandes

→ mantener la consistencia de la implementación

→ seguir planes de varios pasos

→ recuperarse de intentos fallidos

→ actuar como verificador estricto

El resultado no es "mejores prompts".

Son 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.

Todo agente de IA serio ejecuta el mismo ciclo subyacente:

→ Descubrir — ¿qué hay que hacer?

→ Ejecutar — hacer el trabajo

→ Verificar — ¿realmente funcionó?

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

→ Detenerse — condición cumplida, o límite máximo alcanzado

Claude Code. Cursor. Codex.

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 las 4 condiciones: ejecuta esto antes de construir nada

La mayoría de los bucles fallan aquí.

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

Si falta una, el bucle cuesta más de lo que devuelve.

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

2. La verificación está automatizada. Algo debe reprobar el trabajo sin que tú estés en la sala. Pruebas. Linters. Compilaciones. Verificaciones de tipos. Sin compuerta = 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. Una prueba que pasa o falla. Una compilación que compila o no. No "cuando se ve bien". Si "terminado" requiere una opinión humana, mantenlo manual.

Si cumples las 4 → construye el bucle.

Si fallas alguna → usa un prompt en su lugar.

La versión honesta: la mayoría de los desarrolladores todavía 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 con IA construido exactamente para esto: ejecutar tareas largas, paralelas y de múltiples 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 adecuado 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 /path/to/your/project
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 la API Express
8- src/services/ — Lógica de negocio
9- src/db/ — Modelos de base de datos (PostgreSQL vía Prisma)
10- tests/ — Suite de pruebas Jest
11
12## Comandos clave
13- npm test — ejecutar la suite completa de pruebas
14- npm run build — compilar TypeScript
15- npm run lint — verificación ESLint
16- npm run typecheck — tsc --noEmit
17
18## Reglas
19- Nunca modifiques src/billing/ o src/auth/ sin aprobación humana
20- Siempre ejecuta las pruebas antes de marcar cualquier tarea como completada
21- Usa 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 necesitas pegarlo cada sesión.

Agrega los directorios de tu espacio de trabajo dentro de Slate:

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

O haz referencia a archivos específicos usando menciones @:

1Revisa @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 activado hasta que confíes en él)

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

Para ejecuciones de CI o automatización donde no quieres prompts:

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

Paso 3 — Tu primera tarea (todavía no un bucle)

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

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

Dale a Slate una tarea real:

1Revisa 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 cómo trabaja Slate. Hará:

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

Esto ya es un minibucle: verifica su propia salida antes de terminar.

Para una tarea más larga:

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

Slate devuelve un plan. Iteras 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 en cada sesión.

EscrÍbelo una vez. Slate lo 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# Skill de CI Triage
7
8## Qué hago
9Cuando falla una ejecución de CI:
101. Leo la salida de las pruebas
112. Clasifico el fallo: problema de entorno / prueba inestable / error real / cambio de dependencia / infraestructura
123. Redacto correcciones para errores y problemas de dependencias
134. Escalo problemas de entorno e infraestructura a humanos
14
15## Reglas de clasificación
16- entorno: secreto faltante, variable de entorno incorrecta → marcar para humano
17- inestable: pasa al reintentar sin cambio de código → reintentar una vez, luego registrar issue
18- error: fallo determinista relacionado con un commit reciente → redactar corrección
19- dependencia: fallo relacionado con un cambio de versión → redactar PR de reversión
20- infra: timeout, OOM, problema del runner → escalar inmediatamente
21
22## Patrones de corrección
23- Fallos en pruebas de autenticación → verificar primero src/auth/middleware.ts
24- Fallos en pruebas de base de datos → verificar que la migración se ejecutó en el entorno de CI
25- Fallos en pruebas E2E → verificar selectores de UI contra la última instantánea
26
27## Nunca hacer
28- Deshabilitar pruebas fallidas
29- Modificar la configuración de CI sin preguntar
30- Tocar src/billing/ o src/payments/
31
32## Estado
33Actualiza 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 las pruebas fallidas 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# Estado del Bucle — 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 — pruebas 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## Escalado a humanos
15- src/billing/refund.ts — pruebas fallando de 3 maneras, causa raíz poco clara
16- ci/staging-runner — timeouts de infraestructura, no es un problema de código
17
18## Lecciones aprendidas
19- 2026-06-27: PowerShell tiene un problema TLS 1.2 en este runner de Windows. Usa bash.
20- 2026-06-26: tests/e2e/checkout requiere el secreto del webhook de Stripe en env. Saltar 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 desde donde se detuvo 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é se ha intentado ya.
2
3Ejecuta la skill de CI triage en todas las pruebas fallidas de la última compilación.
4
5Para cada fallo:
6- Clasifícalo usando las reglas de la skill ci-triage
7- Redacta una corrección para errores y problemas de dependencias
8- Escala problemas de entorno e infraestructura
9
10Ejecuta las correcciones. Verifica si las pruebas pasan.
11Si las pruebas pasan → abre un PR.
12Si las pruebas siguen fallando → registra en STATE.md y detente.
13
14Actualiza STATE.md con todo lo hecho en esta ejecución.
15
16Parada máxima: 8 intentos como máximo. Al alcanzar el límite, informa 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 headless/CI (automatizado)

Ejecuta de forma no interactiva en una acción de GitHub o cron:

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 que se escala.

Paso 7 — Agrega subagentes (la división hacedor-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 demasiado generoso como calificador.

En Slate, puedes establecer 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:

1Corrige las pruebas 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 de la prueba:
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 hacedor.

Esta división es por lo que 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
11FINAL 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 ESTRICTAS:
36- Nunca toques src/billing/ sin aprobación humana
37- Siempre ejecuta pruebas después de cada migración de ruta
38- Detente 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 un solo golpe de tecla:

1{
2  "command": {
3    "triage": {
4      "description": "Ejecutar bucle de CI triage",
5      "template": "Lee STATE.md. Ejecuta la skill ci-triage en todas las pruebas fallidas. Actualiza STATE.md al terminar.",
6      "agent": "build"
7    },
8    "review": {
9      "description": "Revisar un archivo para verificar su corrección",
10      "template": "Revisa @$ARGUMENTS para verificar corrección, casos límite 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 pruebas. 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: CI failure triage (el que construimos)

Cuándo: cada fallo de CI Qué: clasificar → corregir los fáciles → escalar los difíciles → abrir PRs Estado: STATE.md Puerta: las pruebas 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: Informe matutino

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

1# loop.md para informe 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 borrador o revisión
6- Issues de GitHub abiertos o actualizados en las últimas 24h
7
8Escribe un informe 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 en menos de 120 palabras. Publícalo en el canal de Slack de #engineering.
14EOF
15
16# ejecutar en un horario 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 mayor (ruptura) o menor/patch (seguro)
82. Para menor/patch: actualiza el paquete, ejecuta npm test
93. Si las pruebas pasan: abre un PR
104. Si las pruebas fallan: registra en STATE.md como "necesita revisión humana"
115. Para cambios mayores: escalar siempre a humanos
12
13Reglas estrictas:
14- Nunca actualices más de 5 paquetes en un solo bucle
15- Nunca actualices paquetes en la sección "peer dependencies"
16- Siempre ejecuta la suite completa de pruebas después de cada actualización, no solo las pruebas relacionadas
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 un trabajo a medias.

Sale temprano. El bucle sigue gastando. Silenciosamente.

Solución: condición de parada estricta verificada por un modelo nuevo.

1CONDICIÓN DE PARADA: Todas las pruebas en tests/auth/ pasan Y lint devuelve 0.
2Verificar usando una ejecución de verificación separada, no el propio juicio del agente.
3Límite máximo: 8 iteraciones. Al alcanzar el límite: informar estado y detenerse.

Deriva del objetivo

En sesiones largas, las restricciones iniciales desaparecen.

"Nunca toques src/billing/" del mensaje 3 se pierde para el mensaje 47.

Solución: agrega un VISION.md que Slate relee al inicio de cada sesión.

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

Sesgo autopreferencial

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

Solución: verificador subagente sin acceso al razonamiento del hacedor.

Dile a Slate explícitamente:

1El agente verificador NO debe ver el trabajo del agente de implementación.
2Solo debe ver: los requisitos originales de la prueba y la salida de la prueba.
3Si las pruebas pasan → aprobar. Si las pruebas fallan → rechazar. Sin opinión de otro tipo.

Pereza agentiva

El bucle llama a una tarea "suficientemente hecha" cuando está parcialmente completa.

Especialmente con criterios de éxito vagos.

Solución: condición de parada objetiva únicamente.

1TERMINADO CUANDO: npm test devuelve código de salida 0 Y npm run lint devuelve código de salida 0.
2No cuando "las pruebas se ven bien". No cuando "la mayoría de las pruebas 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 que Slate sea diferente de otros agentes en la práctica.

Encolar mensajes mientras trabaja

Slate está ejecutando una tarea larga. Piensas en algo importante.

Presiona Tab para encolar el mensaje; se ejecuta después de que termine la tarea actual, 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 mitad de la implementación de 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 inmediatamente]
5
6Slate: Entendido, cambiando enfoque para usar BaseError...

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

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

1!npm test          # ejecuta pruebas y envía la salida a Slate
2!git diff HEAD     # verifica qué cambió
3!git status        # ve el estado actual

Slate lee la salida y la usa en su próxima 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 /path/to/project

Ú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 visión general 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 escrito para tu primera tarea repetitiva
6□ STATE.md creado y referenciado en AGENTS.md
7□ loop.md escrito con condición de parada explícita
8□ Límite máximo de iteraciones (8 como máximo para empezar)
9□ El verificador NO es el mismo agente que el hacedor
10□ Compuerta de revisión humana para cualquier acción irreversible (PRs, despliegues)

Marca cada casilla antes de programar cualquier cosa.

Si saltas una, el bucle falla silenciosamente o te factura sin nada.

Para más inspiración sobre bucles

Una vez que entiendes el patrón, el cuello de botella pasa de «cómo construyo un bucle» a «qué bucle debería 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 funcionando en un solo lugar, dejas de pensar en instrucciones únicas.

La incómoda verdad

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

Uno lo usa para avanzar más rápido en el 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 instrucciones — 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 la instrucción más ingeniosa.

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

El resumen en 60 segundos

Qué es un bucle:

→ Instrucción = pregunta. Bucle = trabajo.

→ Descubrir → Ejecutar → Verificar → Iterar → Detener

La prueba de las 4 condiciones:

→ La tarea se repite / Verificación automatizada / Presupuesto absorbe desperdicio / Hecho es objetivo

Los 5 pasos de configuración:

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

Luego empaquétalo:

→ Archivo de cola loop.md o ejecución headless de Slate en CI

Los modos de fallo:

→ Ralph Wiggum (sale temprano) / Desviación de objetivo (olvida restricciones) / Sesgo autopreferencial (creador = verificador) / Pereza agentiva (suficiente 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 esto te fue útil:

→ Comparte esto con cada constructor que conozcas

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

→ Guarda esto en favoritos — solo la lista de verificación de configuración vale la pena

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