Cómo construí a Ada, mi empleada de IA (y cómo podrías construir la tuya)

La versión corta: escribe especificaciones con una línea de «terminado significa», mantén las tareas pequeñas, pon puertas entre la IA y cualquier cosa real, revisa su trabajo como el de un compañero, devuelve cada fallo a las instrucciones y deja la producción detrás de un humano. El resto del artículo es cómo se ve eso en la práctica, más un prompt que te arma todo el andamiaje.

Casi todas las noches mi teléfono vibra alrededor de las 3 de la madrugada. No es una persona. Es Ada, avisándome que terminó una función, corrió las pruebas y subió el código para revisión. Me vuelvo a dormir. Por la mañana leo su trabajo igual que leería el de cualquier compañero, y si está bien, se publica.

Ada no es algo que puedas comprar. Es un sistema que construí: un modelo de IA corriendo dentro de un bucle, con barreras de protección que fui agregando de a una a medida que las cosas salían mal. Soy ingeniero de software y lograr que funcionara de verdad me tomó meses. No meses de escribir código. Meses de averiguar cómo delegar en una IA sin que todo se desarme en silencio.

Este artículo es el método completo. La primera mitad sirve escribas código o no. La segunda mitad es la configuración práctica, incluido un prompt que puedes pegar en Claude Code para armar tu propia versión inicial.

El método

Cada regla de abajo existe porque algo salió mal sin ella.

1. Escribe especificaciones, no deseos

La diferencia entre un resultado de IA útil y uno que te arruina la tarde casi siempre está en la instrucción que le diste.

Un deseo se ve así: «agrega validación al formulario de registro».

Una especificación se ve así: «los correos inválidos y las contraseñas vacías deben rechazarse con mensajes de error visibles. Primero escribe pruebas que envíen esas entradas, después haz que pasen. Terminado significa: todas las pruebas en verde, ningún otro archivo modificado».

Cada tarea que Ada toma tiene una especificación con una línea de «terminado significa». Si no puedo escribir esa línea, la tarea no está lista para delegarse.

2. Corta el trabajo en partes pequeñas

Ada nunca recibe «construye el sistema de facturación». Recibe una porción acotada a la vez, cada una terminable en una sola corrida. Las tareas pequeñas fallan en pequeño. Las grandes fallan de maneras que solo descubres tres días después.

Si delegas cualquier cosa en una IA, el tamaño de la tarea es tu principal perilla de riesgo. Bájala.

3. Construye puertas que la IA no pueda saltarse

No confío en Ada. Confío en las puertas.

Nada de lo que escribe cuenta como terminado hasta que pasa la suite de pruebas, el verificador de tipos, el linter y una compilación completa de producción. Se ejecutan siempre, y ella no puede corregir su propia tarea.

Si no eres técnico, la misma regla se ve así: el resultado de la IA nunca va directo al destino. Siempre hay un punto de control por el que tiene que pasar y que la IA no controla. Una lista de verificación, una segunda lectura, un envío de prueba a ti mismo antes del envío real.

4. Revisa como si fuera un compañero, no magia

Cada mañana leo lo que Ada entregó durante la noche, línea por línea, como leería un pull request de un compañero humano. A veces está muy bien. A veces se lo devuelvo con notas. La revisión nunca es opcional.

El resultado de la IA se ve seguro tenga razón o no. La revisión es donde detectas la diferencia.

5. Lleva un registro de aprendizajes

Cuando algo sale mal, no me limito a arreglarlo. Anoto qué pasó, por qué y qué regla lo habría evitado. Esas notas vuelven a las instrucciones permanentes de Ada. Este mes es mejor que el mes pasado porque mejoraron las instrucciones, no porque mejorara el modelo.

Casi todos se saltan este paso. Es el que rinde interés compuesto.

6. Deja la última puerta en manos humanas

Ada puede publicar en mi entorno de staging toda la noche. Producción espera una palabra específica de mi parte, y nada automatiza eso.

Sea cual sea tu versión de producción, tu publicación, tu entregable para un cliente, la página de tu curso en vivo, mantén una mano humana en esa última puerta.

El stack real, para quienes construyen

Lo que Ada es físicamente:

• El cerebro es Claude, manejado por Claude Code, la CLI agéntica de Anthropic. Cualquier herramienta de programación agéntica capaz podría ocupar ese lugar. El bucle importa más que la marca.
• La cola es un archivo markdown que lista tareas. Cada tarea apunta a una especificación (qué y por qué, con los criterios de «terminado significa») y a un plan (cómo, paso a paso). Yo los escribo durante el día.
• El bucle es un script de PowerShell que vigila la cola, toma la siguiente tarea y se la pasa a la IA en su propia rama.
• Las puertas son pruebas unitarias, el modo estricto de TypeScript, ESLint y una compilación completa de producción. Las cuatro tienen que pasar antes de que algo cuente como terminado.
• El aviso es un bot de Telegram. Ada me escribe cuando termina, y me escribe distinto cuando falla. La vibración de las 3 de la madrugada es ese bot.
• El costo es una suscripción a Claude más aproximadamente cero de infraestructura. El bucle corre en mi propia máquina.

Ahí no hay ningún producto secreto. Especificaciones a la entrada, puertas activadas, revisión después.

Construye tu versión inicial en una tarde

Necesitas tres cosas: un proyecto que viva en git, Claude Code o cualquier CLI agéntica que pueda leer archivos y ejecutar comandos, y alrededor de una hora.

Una advertencia antes de que pegues nada: hoy no estás construyendo la Ada autónoma que trabaja de noche. Estás construyendo la versión inicial supervisada. Una tarea a la vez, puertas activadas, tú mirando. Es el mismo sistema que sigo usando. La parte nocturna es un detalle de programación horaria que solo agregué después de meses de que el bucle supervisado fuera aburrido y confiable.

Paso 1. Arma el andamiaje del sistema. Abre Claude Code dentro de tu proyecto y pega esto:

Set up a minimal "AI teammate" system in this repository. Scaffolding only, no feature work yet.
 
1. Detect this project's tooling: test command, type check, lint, build. List what you found and wait for my confirmation before creating anything.
 
2. After I confirm, create an ai-team/ folder with these files:
 
- QUEUE.md: a task table with columns: id, title, spec file, status (queued / in-progress / done / failed), branch, notes.
 
- specs/TEMPLATE.md: a spec template with sections: Goal (one paragraph), Done means (verifiable criteria a command or test can prove), Out of scope, How to verify (exact commands).
 
- RULES.md with these standing rules:
  * One task at a time, always from QUEUE.md, always following its spec file.
  * Work on a fresh branch named ai/<task-id>. Never commit to the default branch. Never push, never merge, never touch remotes. The human reviews and merges.
  * Before marking a task done, run every gate this project actually has from the step-1 detection (tests, type check, lint, build). All existing gates must pass. Record each result in the task's notes, and record any gate the project doesn't have as "N/A (not configured)" rather than skipping it silently.
  * If blocked after 3 materially different attempts, stop. Mark the task failed with a note on what was tried.
  * Never run destructive commands. Never delete or modify files outside the spec's scope. List any new dependency in the notes before installing it.
  * On every failure, append a dated entry to ai-team/LEARNINGS.md: what went wrong and what rule would have prevented it.
 
- LEARNINGS.md: empty, with a one-line header explaining its purpose.
 
3. Commit the ai-team/ folder to the current branch with the message "chore: add ai-team scaffolding", show me the created files, and stop.

Dos cosas que esperar cuando lo ejecutes. Se detiene después del paso 1 y espera tu respuesta; es deliberado, es el primer punto de control humano. Y si tu proyecto solo tiene algunas de las cuatro puertas, no pasa nada: las reglas se atan a lo que el paso 1 realmente encontró.

Paso 2. Escribe tu primera especificación. Copia specs/TEMPLATE.md y complétalo para algo pequeño y molesto que vengas postergando. Aquí importa que sea pequeño: si falla, deberías perder minutos, no tu fin de semana. Agrega una fila a QUEUE.md.

Paso 3. Ejecuta una tarea. Abre una sesión nueva y pega:

Read ai-team/RULES.md and follow it exactly. Pick the topmost queued task in ai-team/QUEUE.md, mark it in-progress, and do it on its own branch per the rules. When the gates pass, mark it done, summarize what you changed and why, and stop for my review.

Míralo trabajar las primeras veces. Estás aprendiendo en qué es confiablemente bueno, y él va acumulando sus propias reglas en LEARNINGS.md.

Paso 4. Revisa la rama como un PR. Lee el diff. Si está bien, la fusionas tú mismo. Si no, agrega notas a la especificación, devuelve la tarea a la cola y ejecútala de nuevo.

Paso 5. Avanza despacio. Cuando diez tareas seguidas hayan sido aburridas, encola varias a la vez. Cuando eso también se vuelva aburrido, busca el modo headless de tu CLI (Claude Code tiene uno), pon el comando de ejecución en un programador de tareas y agrega una notificación para cuando termine una corrida.

La versión de Telegram de esa notificación, ya que siempre me preguntan: escríbele a @BotFather en Telegram, envía /newbot y te entrega un token de bot. Mándale a tu nuevo bot cualquier mensaje desde tu propia cuenta, después abre esta URL en un navegador y copia el número chat.id de la respuesta:

https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates

De ahí en adelante, una línea al final de tu script de ejecución es todo el sistema de notificaciones:

curl -s "https://api.telegram.org/bot<YOUR_TOKEN>/sendMessage" -d chat_id=<YOUR_CHAT_ID> -d text="Ada: run finished"

Esa es la vibración de las 3 de la madrugada, y solo se siente bien gracias a cada barrera de protección que agregaste en el camino.

Lo que se rompió en el camino

Deberías saber cómo se ve esto cuando sale mal, porque va a salir mal.

El apagón nocturno. Una vez mi máquina se apagó a mitad de una corrida y dejó huérfano el trabajo de Ada a medio terminar. Ahora el bucle busca corridas obsoletas al arrancar y las recupera en lugar de fingir que nunca ocurrieron.

La rama equivocada. Al principio, el bucle no tenía conciencia de ramas. Una noche la rama de la tarea anterior ya había sido eliminada, y Ada confirmó en silencio una función entera en la rama equivocada, saltándose por completo mi puerta de revisión. No se publicó nada malo, pero ahora el sistema verifica dónde está parado antes de su primer commit, siempre.

Los procesos zombis. Servidores de desarrollo que nunca morían se fueron acumulando hasta que la máquina iba a paso de tortuga. Ahora no se da nada por muerto. El bucle revisa qué está corriendo de verdad y mata por ID de proceso.

Ninguno de estos fue un fallo de la IA. Mis barreras de protección tenían agujeros, los agujeros aparecieron como incidentes, y cada incidente se convirtió en una regla.

Si no escribes código

Puedes aplicar el mismo método con nada más que una IA de chat y algo de disciplina:

1. Ten un documento de instrucciones permanentes: quién eres, cómo se ve un buen resultado, qué no hacer nunca. Pégalo en cada proyecto, o usa una herramienta que lo conserve.
2. Escribe una especificación para cada tarea real, con una línea de «terminado significa».
3. Mantén las tareas lo bastante pequeñas como para que un mal resultado te cueste minutos, no días.
4. Pon un punto de control entre el resultado de la IA y el mundo real. Siempre.
5. Lleva una nota continua de cada error y de qué instrucción lo habría evitado. Devuélvela al sistema.
6. Revisa todo lo que salga con tu nombre. La IA suena segura en cualquier caso. Tú eres quien puede notar la diferencia.

No vas a conseguir las entregas de las 3 de la madrugada. Vas a conseguir la parte que importa más: una delegación que sigue mejorando, porque sigues devolviendo los errores al sistema.

Por qué te cuento esto

Construyo Classentra en público. Es una plataforma de enseñanza en vivo para educadores y creadores, y comparto el día a día en Instagram en @adinashby, incluidas las victorias de Ada y sus porrazos. Si llegaste aquí desde un reel, esta es la guía que prometí.

Ven a contarme qué le pasarías primero a una compañera de equipo de IA. Yo mismo respondo mis DMs.