Loops: haz que la IA trabaje sola, sin vigilarla a cada paso

Hasta ahora le has hablado a la IA turno por turno: le pides algo, revisas, le pides lo siguiente. Un loop es distinto — armas un sistema que le pide a la IA lo que falta, revisa el resultado y decide solo cuándo terminó. Aquí aprendes el framework y lo construyes con DeepSeek, el modelo de IA más barato del mercado (desde $0.14 USD por millón de palabras procesadas).

Promptear es pedirle a la IA una cosa a la vez y supervisar cada paso: tú eres el motor y el cuello de botella. Un loop cambia el rol: dejas de ejecutar cada turno y pasas a definir la meta, dejar que la IA trabaje sola varias vueltas, y verificar solo cuándo terminó de verdad.

Boris Cherny, el creador de Claude Code (el asistente de programación de Anthropic), lo resumió así en junio de 2026: "Ya no le hago prompts a la IA. Tengo loops corriendo — mi trabajo es escribir loops." El apalancamiento no es que la IA piense mejor: es que tú dejas de ser el cuello de botella de cada paso.

Cualquier loop bien diseñado — lo llames como lo llames — tiene estas cinco piezas. Si falta una, el loop falla de forma predecible (casi siempre por la última: nadie define cuándo parar).

Antes de construir, decide qué tipo de loop necesitas — cambia todo el diseño:

Regla rápida: si puedes terminar la frase "esto para cuando ___" con algo comprobable, es acotado. Si la frase es "cada ___ revisa ___", es de vigilancia.

Si la misma IA que hizo el trabajo es la que decide "quedó bien", va a decir que sí casi siempre — no porque mienta, sino porque optimiza lo que tú le pediste medir, no la realidad (los expertos lo llaman Ley de Goodhart). La corrección es simple: separar quien produce (maker) de quien revisa (auditor).

Con DeepSeek lo logras con dos llamadas separadas: una que produce el trabajo, y otra — con un prompt distinto, que nunca ve cómo se hizo el trabajo — que solo revisa si cumple la meta. Si puedes, usa un segundo modelo para el auditor (por ejemplo ChatGPT o Gemini); si no, dos llamadas a DeepSeek con roles claramente separados ya es mucho mejor que una sola IA aprobándose a sí misma.

DeepSeek lanzó en abril de 2026 su nueva generación V4 — según sus propias pruebas, compite con Opus 4.6 a una fracción del costo. Vive en dos versiones: deepseek-v4-flash (rápida y barata) y deepseek-v4-pro (su inteligencia más potente). No necesitas ninguna herramienta nueva: construyes el loop con un script simple en el mismo servidor donde ya instalaste Claude Code, programado con cron (el reloj del servidor que ya usa tu sistema).

a) Consigue tu clave de API

• Entra a platform.deepseek.com, crea tu cuenta y ve a la sección API Keys.
• Genera una clave nueva y guárdala — solo se muestra una vez.
• Carga saldo mínimo (unos $5 USD alcanzan para cientos de vueltas de prueba).

b) Elige el modelo

Los nombres antiguos deepseek-chat y deepseek-reasoner dejan de funcionar el 24 de julio de 2026 — usa siempre uno de estos dos:

Tareas repetitivas y de alto volumen: redactar, clasificar, revisar.
Precio: ~$0.14 USD por millón de palabras de entrada, $0.28 de salida.
Ideal para: la mayoría de tus loops — es el que usarás casi siempre.

Tareas que exigen más razonamiento: analizar, decidir, redactar con matices.
Precio: ~$0.44 USD por millón de palabras de entrada, $0.87 de salida.
Ideal para: el AUDITOR de tu loop, o cuando v4-flash se equivoca seguido.

c) El script que hace el trabajo (maker + auditor)

Entra a la terminal de tu servidor y crea una carpeta para tu loop:

$ mkdir -p ~/loops/mi-loop && cd ~/loops/mi-loop
$ sudo apt install -y jq   # para leer la respuesta de la API
$ nano run-loop.sh

Pega este script — es tu loop completo: llama al maker (produce), luego al auditor (revisa, sin haber visto cómo se hizo), y solo marca la tarea como hecha si el auditor aprueba:

#!/bin/bash
cd ~/loops/mi-loop
API_KEY="tu_clave_aqui"
MODELO="deepseek-v4-flash"
MAX_ITER=25
# --- freno de emergencia: crea un archivo llamado STOP para detener todo ---
[ -f STOP ] && { echo "Detenido por freno de emergencia"; exit 0; }
# --- tope de vueltas ---
ITER=$(cat iter.txt 2>/dev/null || echo 0)
[ "$ITER" -ge "$MAX_ITER" ] && { echo "Tope de vueltas alcanzado, revisa a mano"; exit 0; }
# --- toma la primera tarea pendiente del archivo tareas.txt ---
TAREA=$(grep -m1 "^pendiente:" tareas.txt | sed 's/^pendiente: //')
[ -z "$TAREA" ] && { echo "No hay tareas pendientes"; exit 0; }
# --- MAKER: produce el trabajo ---
RESPUESTA=$(curl -s https://api.deepseek.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" -H "Content-Type: application/json" \
  -d "{\"model\":\"$MODELO\",\"messages\":[{\"role\":\"system\",\"content\":\"Escribe lo que se te pide, directo y claro.\"},{\"role\":\"user\",\"content\":\"$TAREA\"}]}" \
  | jq -r '.choices[0].message.content')
# --- AUDITOR: revisa SIN saber cómo se hizo, con SUS PROPIOS criterios ---
VEREDICTO=$(curl -s https://api.deepseek.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" -H "Content-Type: application/json" \
  -d "{\"model\":\"$MODELO\",\"messages\":[{\"role\":\"system\",\"content\":\"Responde SOLO 'SI' o 'NO': ¿este texto cumple lo pedido, es correcto y no inventa nada? Texto:\"},{\"role\":\"user\",\"content\":\"$RESPUESTA\"}]}" \
  | jq -r '.choices[0].message.content')
# --- decide y guarda el estado ---
if echo "$VEREDICTO" | grep -qi "^SI"; then
  echo "$(date) HECHO: $TAREA -> $RESPUESTA" >> progreso.log
  sed -i "0,/^pendiente: $TAREA/{s/^pendiente:/hecho:/}" tareas.txt
else
  echo "$(date) RECHAZADO: $TAREA -> $VEREDICTO" >> progreso.log
fi
echo $((ITER+1)) > iter.txt

Guarda (Ctrl+O, Enter, Ctrl+X en nano) y dale permiso de ejecución:

$ chmod +x run-loop.sh
$ nano tareas.txt   # escribe una tarea por línea, así: pendiente: redacta un correo de bienvenida

d) El estado — dónde vive la memoria entre vueltas

Todo queda en tu propio servidor, en la misma carpeta: tareas.txt (qué falta y qué ya está hecho), progreso.log (el historial de cada vuelta) e iter.txt (el contador de vueltas). Puedes leerlos en cualquier momento con cat progreso.log — esa es tu forma de comprobar que el loop de verdad avanza.

e) El disparador — prográmalo con cron

Para que corra solo cada cierto tiempo (por ejemplo, cada 10 minutos, una tarea por vuelta, hasta que se acaben o llegue al tope):

$ crontab -e
# agrega esta línea al final del archivo y guarda:
*/10 * * * * ~/loops/mi-loop/run-loop.sh

Un loop mal cuidado puede seguir gastando y produciendo basura sin que te des cuenta — el fallo más peligroso es que parezca que sigue funcionando. Antes de dejarlo corriendo sin supervisión:

• Tope de vueltas — el script ya trae MAX_ITER=25. No lo subas hasta haber revisado progreso.log a mano.
• Tope de gasto — con estos precios, 25 vueltas cuestan centavos, pero revisa tu saldo en platform.deepseek.com cada tanto y pon una alerta de saldo bajo si la plataforma lo permite.
• Freno de emergencia — crea un archivo llamado STOP en la carpeta del loop (touch STOP) y se detiene solo en la siguiente vuelta. Bórralo para reanudar.
• Detector de estancamiento — si ves la misma tarea "RECHAZADO" varias veces seguidas en progreso.log, sácala de tareas.txt y revísala tú mismo — no dejes que reintente para siempre.
• Chequeo externo de "terminado" — algo que puedas comprobar tú sin la IA: grep -c "^hecho:" tareas.txt te dice cuántas van, sin depender de que la IA "te avise".

Plantilla — Meta Verificable (cópiala antes de construir cualquier loop)

OBJETIVO (una frase, resultado final, no el proceso): _____

CRITERIOS QUE SE PUEDEN COMPROBAR (todos deben cumplirse):
[ ] _____________________________________________
[ ] _____________________________________________
[ ] _____________________________________________

QUIÉN AUDITA (distinto de quien produce): _____

TOPES DUROS:
- Máximo de vueltas: _____
- Máximo de gasto (USD): _____
- Si se traba, avisa a: _____

NO uso loop si: la tarea es de un solo paso, no hay forma de comprobar el
resultado sin opinar, o la acción es riesgosa sin un humano de por medio.

¿Algo salió mal?

• "jq: command not found": corre sudo apt install -y jq y vuelve a intentar.
• DeepSeek responde error 401 (unauthorized): revisa que copiaste bien tu clave en API_KEY dentro del script, sin espacios de más.
• El loop no avanza: revisa cat progreso.log — probablemente una tarea sigue "RECHAZADO" una y otra vez. Por eso importa el detector de estancamiento.
• El auditor siempre aprueba todo: tu prompt del auditor es muy laxo — dale criterios más específicos en el script y pídele que explique el "por qué" antes del sí/no.
• Cron no lo está corriendo: confirma con crontab -l que la línea quedó guardada, y revisa grep CRON /var/log/syslog para ver si se está ejecutando.