Hoy casi todo el mundo programa con agentes de IA. Yo también: llevo un tiempo desarrollando un proyecto propio con Claude Code. No es una app de juguete: tiene un frontend con microfrontends en Angular, un backend en NestJS, base de datos y bastantes reglas de negocio.
Tres VS Code, tres agentes y yo en medio
Mi primera idea fue la obvia: si un agente hace una tarea, tres agentes hacen tres. Así que cloné el repositorio en tres carpetas, abrí tres VS Code y en cada uno una terminal con Claude Code trabajando en una tarea distinta. Estaba jugando a sacar varias tareas en paralelo.
Me duró dos días.
Sobre el papel, genial. En la práctica, cada vez que un agente terminaba, me tocaba a mí:
- Ir a esa carpeta.
- Levantar el backend, la base de datos y los tres frontends.
- Probar a mano que la funcionalidad estaba bien.
- Tirarlo todo.
- Revisar el código, hacer la PR.
- Ir a la siguiente carpeta y vuelta a empezar.
Era como un cocinero con tres fogones encendidos y una sola cuchara para probar. Los fogones van solos; el que no da abasto es él.
Ahí me di cuenta de algo que ahora me parece evidente: el cuello de botella de programar con agentes no es programar. Un agente termina una tarea en minutos. Yo tardo bastante más en comprobar que está bien. Si añado más agentes, lo único que crece es mi cola de revisión. Y mi portátil, con todo levantado tres veces, tampoco estaba muy contento.
Lo que hay antes del código
El agente no trabaja a ciegas. Antes de escribir una línea lee esto:
- PRDs. Un documento de producto general y uno por área de la aplicación, con qué tiene que hacer y por qué.
- La tarjeta de Jira, que es la fuente de verdad. Lleva los criterios de aceptación escritos como escenarios BDD (Dado / Cuando / Entonces). Claude Code la lee por MCP.
- El contrato de la API en un fichero OpenAPI.
Con eso, y usando SDD con OpenSpec, el agente escribe una propuesta con lo que va a cambiar y una lista de tareas. Yo resuelvo sus dudas, le digo que tire, implementa con tests que comprueban esos escenarios y abre una PR.
Qué es una PR Preview
Una PR Preview es un despliegue de tu aplicación con el código exacto de una pull request, en su propia URL, que se crea al abrir la PR y se destruye al cerrarla.
Lo vi por primera vez en proyectos grandes, en un banco entre otros, y
siempre me pareció un lujo de equipos con mucha infraestructura. La
idea es simple: abres la PR y, al rato, aparece un comentario con un
enlace tipo https://pr-42.preview.ejemplo.dev. Entras y ves la
aplicación tal y como quedaría si haces merge.
Es el piso piloto de cada reforma. No tienes que imaginarte cómo queda la cocina mirando los planos: entras y la ves.
Para mi problema era justo lo que necesitaba. Si cada PR se despliega sola, revisar ya no implica levantar nada en mi máquina. Y si mi máquina no hace falta para revisar, los agentes tampoco tienen por qué estar en ella.
Cómo lo monté
No quería pagar un servicio por esto, así que lo monté sobre una sola EC2 pequeña en AWS con Docker, por unos 22 euros al mes. El esquema es este:
Internet
│
▼
Caddy (80/443, HTTPS automático)
*.preview.ejemplo.dev
│ │
▼ ▼
pr-42.preview... pr-43.preview...
├── /api/* → backend ├── /api/* → backend
│ (contenedor pr-42) │ (contenedor pr-43)
└── /* → estáticos └── /* → estáticos
│ │
└──────────┬──────────────┘
▼
Mongo (compartido)
bases pr_42, pr_43...
│
Mailpit
(atrapa todos los correos)
Hay dos capas:
- Una base que se levanta una vez y no se toca: Caddy, Mongo y
Mailpit, en un
docker composepropio. - Un stack por PR, que solo lleva el contenedor del backend. Cada
uno se llama como su PR (
pr-42,pr-43…), y eso es lo que permite tener varios a la vez sin que se pisen.
Vamos pieza por pieza.
Caddy y un subdominio por PR
Caddy hace de puerta de entrada. Lo elegí porque saca certificados HTTPS solo, para cada subdominio nuevo, sin que yo haga nada.
En el DNS hay un único registro wildcard, *.preview.ejemplo.dev,
apuntando a la máquina. Con eso, cualquier pr-<número> funciona sin
tocar el DNS nunca más.
Cuando se despliega una PR, el workflow escribe un fichero de configuración pequeño para ese subdominio y recarga Caddy:
pr-42.preview.ejemplo.dev {
handle /api/* {
reverse_proxy pr-42-backend:3000
}
# El frontend es una SPA: cualquier ruta va a index.html
handle {
root * /srv/previews/pr-42
try_files {path} /index.html
file_server
}
}
El frontend no se compila en el servidor
Esta fue una de las primeras decisiones y de las más importantes. La
máquina es pequeña y un build de Angular se come la RAM. Así que los
frontends se compilan en GitHub Actions y al servidor solo se suben
los ficheros estáticos con rsync. Caddy los sirve sin gastar casi
memoria.
Resultado: cada PR solo tiene corriendo un contenedor, el backend. Unos 350 MB por PR.
Con microfrontends hay un detalle extra. El shell necesita saber dónde
están los remotes, y en local eso apunta a localhost. Antes de
compilar, el workflow reescribe el manifiesto de federación para que
apunte al subdominio de la PR:
{
"mf-catalogo": "https://pr-42.preview.ejemplo.dev/mf-catalogo/remoteEntry.json"
}
Sin esto, la preview arranca y no carga nada.
Una base de datos por PR
Las PRs no pueden compartir datos: si una prueba borra clientes, la otra no tiene por qué enterarse. Pero tampoco quería un Mongo por PR, que es mucha memoria.
La solución: un solo Mongo y una base de datos distinta dentro
(pr_42, pr_43…). Aislamiento total con el coste de un solo
proceso.
Una preview con la base vacía no sirve para revisar nada, así que en
el repositorio hay un dataset de prueba pequeño, sin datos reales. Al
abrir la PR se restaura con mongorestore en la base de esa PR. Solo
al abrirla: en los siguientes push no se toca, para no borrar lo que
estuviera probando.
Mailpit: que una preview nunca mande un correo de verdad
La aplicación envía correos. Una preview con datos de prueba mandando emails a direcciones reales es un susto que no quiero. Mailpit hace de servidor de correo falso: atrapa todo lo que sale y lo enseña en una web aparte. Así además puedo revisar los correos como parte de la PR.
El ciclo de vida, en dos workflows
Todo lo anterior lo mueven dos workflows de GitHub Actions.
Al abrir la PR o hacer push:
- Pasan los tests.
- Se compilan los frontends.
- Se suben los estáticos y el código del backend a la máquina.
docker compose -p pr-42 up -d --buildconstruye la imagen del backend y levanta su contenedor.- Si la PR es nueva, se carga el dataset.
- Se escribe la ruta de Caddy y se recarga.
- Se comenta la URL en la PR.
Al cerrar la PR, el otro workflow lo borra todo: contenedor, imagen, ruta de Caddy, base de datos y ficheros.
docker compose -p pr-42 -f docker-compose.preview.yml down -v --rmi local
rm -f /srv/caddy/sites/pr-42.caddy
rm -rf /srv/previews/pr-42
Este segundo workflow no es opcional. Sin él, la máquina se llena en pocas semanas.
Lo que se rompió por el camino
No salió a la primera. Algunas cosas que me encontré:
- La RAM va muy justa. Tuve que añadir 2 GB de swap a la máquina y ponerle un límite de memoria al contenedor del backend.
- Mongo se reserva media máquina por defecto. Su caché coge la mitad de la RAM disponible y deja sin memoria a las previews. Hubo que limitarla a mano.
- Transacciones. El backend usa transacciones y Mongo solo las admite en replica set, así que incluso con un único nodo tiene que arrancar como replica set.
- CORS. Si el backend no sabe cuál es el subdominio de su PR, el
navegador bloquea las llamadas y la preview parece rota sin ninguna
pista. Cada backend recibe su
CORS_ORIGINcon el número de PR. - El acceso a la máquina. Al principio GitHub Actions entraba por SSH con el puerto 22 abierto. Lo cambié a OIDC y Session Manager de AWS: GitHub demuestra que la ejecución viene de mi repositorio, AWS le da credenciales temporales y el túnel va por SSM. Ni puerto 22 abierto a internet ni claves de AWS permanentes guardadas en GitHub.
Cómo trabajo ahora
Con las previews montadas, el último paso fue sacar también a los agentes de mi portátil y usar Claude Code en la nube. El ciclo queda así:
Tarjeta de Jira
│ (MCP)
▼
Claude Code en la nube
│ OpenSpec: propuesta → dudas → plan
▼
Le digo que tire → implementa → abre la PR
│
▼
GitHub Actions: tests + despliegue
│
▼
https://pr-42.preview.ejemplo.dev
│
▼
Reviso código y funcionalidad ──► merge ──► se borra la preview
Todo pasa en la nube, desde el plan hasta la PR. Le paso una tarjeta, me plantea las dudas del plan, las resuelvo, le digo que tire y me olvido. Cuando abre la PR, unos minutos después tengo el enlace a la preview en un comentario. Puedo tener varias tareas en marcha a la vez y mi máquina no levanta nada.
Lo que no he delegado
Sigo revisando cada PR: el código, los commits y la funcionalidad con la aplicación delante. Lo que han conseguido las PR Previews es que revisar deje de ser un suplicio, no que deje de hacerlo.
Y lo que se construye lo sigo decidiendo yo: los PRDs, las tarjetas, los escenarios y el contrato de la API. Si algo no está en la tarjeta, el agente no se lo inventa.
Así trabajo hoy. Seguramente dentro de unos meses lo haga de otra forma. Pero la lección me la quedo: cuando los agentes escriben el código, el trabajo no desaparece, se mueve. Y conviene saber a dónde.