Setup de agentes de IA: lo que los devs usan de verdad
Alguien abrió un Ask HN preguntando cuál es el setup de agentes de IA de cada uno, y el hilo se volvió lo que estos hilos siempre se vuelven: un montón de devs mostrando su propio banco de trabajo. Hay gente con cinco agentes corriendo en paralelo. Hay gente que usa solo una terminal y un archivo de instrucciones. Y hay gente que se rindió y volvió al autocompletado. Lo leí y me reconocí en casi todas las etapas. Por eso decidí contar lo que aprendí armando mi propio setup de agentes de IA y lo que creo que importa de verdad.
Por qué todo el mundo pregunta lo mismo
Hace poco más de un año, la pregunta era "¿qué modelo usas?". Hoy el modelo es casi un detalle. Los buenos están muy cerca unos de otros. Lo que separa una sesión productiva de una tarde perdida es lo que rodea al modelo:
- el contexto que le das;
- las herramientas que puede llamar;
- cuánto puede hacer sin pedirte permiso;
- cómo verificas lo que hizo.
Nadie tiene la respuesta lista porque el terreno cambió demasiado rápido. Cada uno fue armando su propio parche. Hilos como este son básicamente un intercambio de parches, y eso es genial. Así es como la herramienta madura de verdad, lejos del material de marketing.
Qué necesita tener un setup de agentes de IA
Después de probar muchas cosas, el mío se resume en cuatro piezas. Ninguna es exótica.
1. Un agente en la terminal. Lee el repositorio, ejecuta comandos, edita archivos. Prefiero la terminal a una extensión del IDE porque el agente ve lo que yo veo: los scripts del package.json, los tests, el git status.
2. Un archivo de instrucciones del proyecto. Es lo que más rinde y lo que más gente ignora. Un markdown en la raíz que explica cómo funciona el proyecto. No tiene que ser largo:
# Proyecto
- Monorepo con Bun workspaces. Apps en apps/, libs en packages/.
- Correr tests: bun test (nunca npm test).
- Base de datos: PostgreSQL. Migrations en packages/db/migrations, nunca editar una ya aplicada.
- Las páginas nuevas usan el componente PageLayout.
- No correr el build de varias apps al mismo tiempo.
Cinco líneas así evitan unas veinte correcciones por semana. El agente no adivina que usas Bun. Si no se lo dices, va a correr npm install y crear un package-lock.json que nadie pidió.
3. Permisos bien definidos. La lectura y los tests corren libres. Commit, push, deploy y cualquier cosa que borre datos piden confirmación. Parece burocracia hasta el día en que el agente decide "limpiar" una carpeta que no era suya.
4. Una forma rápida de verificar. Tests, type-check, lint. Si el agente puede correr eso solo y leer el error, se corrige. Si no puede, tú te conviertes en su compilador humano.
¿Vale la pena correr varios agentes en paralelo?
Esta es la parte del hilo que más llama la atención. Gente corriendo tres, cuatro, ocho agentes al mismo tiempo, cada uno en una branch o worktree separado. Suena al futuro.
Mi opinión: para la mayoría de los devs, no vale la pena. Al menos no todavía.
El cuello de botella nunca fue que el agente escriba. El cuello de botella es que tú revises. Un agente genera en diez minutos un diff que toma veinte revisar con atención. Con cuatro corriendo, te conviertes en revisor de PR a tiempo completo, y cansado. Un revisor cansado aprueba cosas mal hechas.
Un agente que escribe más rápido de lo que puedes revisar solo adelanta el próximo bug.
Donde el paralelo funciona bien es en tareas independientes y fáciles de verificar. Un ejemplo real: actualizar el mismo patrón de import en cuarenta archivos, o generar tests para funciones puras que ya existen. El resultado es binario, pasó o no pasó. Ahí sí, puedes soltar a la jauría.
Para una feature nueva con decisiones de arquitectura, me quedo con un solo agente y lo sigo de cerca.
MCP, subagentes y el riesgo de coleccionar herramientas
Otro patrón común es el setup lleno de servidores MCP: base de datos, GitHub, Slack, navegador, gestor de tareas, todo conectado. Yo ya lo hice. Tenía más herramientas conectadas de las que usaba en una semana.
El problema es que cada herramienta tiene un costo:
- ocupa contexto, porque su descripción va incluida en cada conversación;
- confunde al modelo, que a veces elige la herramienta equivocada;
- consume recursos, y un servidor MCP parado en background comiéndose la CPU es más común de lo que parece.
Hoy activo lo que el proyecto necesita y apago el resto. La base de datos local y GitHub cubren el 90% de mi día. El navegador entra cuando estoy tocando el front y quiero que el agente vea la pantalla que él mismo rompió.
Los subagentes siguen la misma lógica. Son útiles para búsquedas amplias, tipo "encuentra todos los lugares que llaman a esta función", porque devuelven solo la conclusión y no llenan tu contexto de archivos. Para una tarea pequeña, delegar cuesta más que hacerlo directamente. Un subagente solo sabe lo que escribiste en el pedido. Si el pedido es malo, la respuesta llega equivocada con toda la confianza del mundo.
Qué cambia en tu flujo de trabajo
El cambio más concreto que sentí no fue escribir menos código. Fue escribir más texto. Describir bien una tarea se volvió una habilidad técnica de verdad.
Un pedido como "arregla el login" da un diff aleatorio. Algo así da un diff que se puede revisar:
El login con Google falla cuando el usuario ya tiene cuenta por e-mail.
Error en apps/web/src/auth/callback.ts, línea del upsert.
Quiero: vincular la cuenta de Google a la cuenta existente por el e-mail.
No tocar el flujo de e-mail/contraseña. Agregar un test para este caso.
Fíjate que es el mismo texto que le mandarías a un colega junior. Quien ya escribía buenas issues está en ventaja. Quien escribía "no funciona, échale un ojo" va a sufrir otra vez, ahora con una máquina.
Otros cambios prácticos que adopté:
- Commits más pequeños. Le pido al agente que se detenga después de cada etapa. Así es más fácil revertir.
- Tests primero. Cuando el test existe, el agente tiene un objetivo. Sin test, se declara ganador por su cuenta.
- Leer el diff completo. Siempre. Al agente le encanta "aprovechar" y refactorizar algo que no pediste.
Y un cuidado de bolsillo: correr un agente es correr procesos. Type-check, build y tests en loop calientan la máquina y gastan cuota de CI. Si tu notebook se vuelve una estufa cada vez que abres una sesión, el problema probablemente está en tu setup, y no en el modelo.
¿Cuál es el mejor setup, al final?
El más aburrido posible. Un agente, un archivo de instrucciones bien escrito, permisos conservadores y tests que corran rápido. A partir de ahí, cada pieza nueva tiene que resolver un problema que ya tuviste, no un problema que imaginas que vas a tener.
El hilo de HN es divertido justamente porque muestra que nadie llegó al setup definitivo. Quien dice que llegó normalmente está vendiendo un curso. Yo sigo ajustando el mío en cada proyecto, y la mejor configuración que tengo hoy fue la que más herramientas perdió con el tiempo.
Si quieres ver dónde corre este flujo en la práctica, échale un vistazo a los proyectos que mantengo.
Resumen para LinkedIn
Hay devs corriendo ocho agentes de IA en paralelo. Yo me quedé con uno solo. Leí un Ask HN sobre setups de agentes y me reconocí en casi todas las etapas. Hoy el modelo pesa poco. Lo que decide es lo que pones alrededor de él. Mi setup es bastante aburrido: un agente en la terminal, un archivo de instrucciones del proyecto, permisos conservadores y tests rápidos. Cinco líneas de markdown me ahorran unas veinte correcciones por semana. Los agentes en paralelo parecen el futuro, pero el cuello de botella nunca fue escribir. El cuello de botella es revisar. Un agente que escribe más rápido de lo que tú revisas solo adelanta el próximo bug. La mejor configuración que tengo hoy es justamente la que más herramientas perdió con el tiempo. ¿Y tu setup, está creciendo o adelgazando? Cuéntamelo en los comentarios. #IA #AgentesDeIA #DesarrolloDeSoftware #Productividad #DevTools