Volver al blog
BunIAAgentesTypeScript

Bun en el setup de agentes de IA: lo que realmente cambia

06 de noviembre de 2026·7 min de lectura·Diego Horvatti

Alguien abrió un hilo en Hacker News con una pregunta simple: ¿cuál es tu setup actual de agentes de IA?. Como siempre, aparecieron cientos de respuestas, y cada una describe un ecosistema propio. Yo las leí buscando una sola cosa: el runtime. Quien usa agentes para escribir TypeScript está, cada vez más, corriendo todo sobre Bun. Y eso tiene menos que ver con la moda de lo que parece.

De eso va este texto. Qué gana Bun en un flujo con agentes, dónde no cambia nada y cómo armaría un setup hoy.

Por qué el runtime importa cuando el que escribe es el agente

Cuando programas solo, el tiempo de correr un test casi no se nota. Guardas, miras la terminal, tomas un sorbo de café. Dos segundos más no hacen diferencia.

Con un agente es distinto. Él no toma café. Corre el test, lee el error, edita, vuelve a correr. En una tarea promedio eso pasa 20, 30, a veces 50 veces. Si cada ciclo gasta 4 segundos de overhead solo para levantar el runtime, transpilar y resolver módulos, son minutos parados por tarea. Multiplícalo por varias tareas al día y por algunos agentes corriendo en paralelo.

El cuello de botella cambió de lugar. Antes era tu velocidad para escribir. Ahora es la velocidad del loop de feedback.

Un buen agente con feedback lento sigue siendo un agente lento.

Ahí es donde entra Bun. Fue pensado para arrancar rápido y para hacer muchas cosas sin configuración. En el día a día de un humano eso es comodidad. En el loop de un agente, eso se convierte en tiempo y tokens ahorrados.

Lo que Bun resuelve en el loop de un agente de IA

Voy a separar lo que veo funcionando en la práctica.

Corre TypeScript directo. Sin tsc, sin ts-node, sin loader. El agente crea un script .ts y lo ejecuta al instante:

bun run scripts/migrar-usuarios.ts

Parece poco, pero elimina una categoría entera de errores. ¿Cuántas veces viste a un agente perderse en ERR_UNKNOWN_FILE_EXTENSION o peleando con "type": "module" en el package.json? Cada una de esas peleas cuesta varias rondas y un montón de contexto tirado a la basura.

Tests integrados y rápidos. bun test tiene una API compatible con Jest en la mayoría de los casos. El agente ya se sabe describe, it y expect de memoria, así que escribe tests sin tener que leer documentación:

import { describe, it, expect } from "bun:test";
import { calcularFrete } from "./frete";

describe("calcularFrete", () => {
  it("deja el envío en cero por encima de 200 reales", () => {
    expect(calcularFrete({ total: 250, cep: "01310100" })).toBe(0);
  });
});

En una suite pequeña, la diferencia de tiempo frente a un setup con Jest y transpilación se nota bastante. Y el agente corre esa suite todo el tiempo.

Instalación de dependencias que no se traba. bun install es lo bastante rápido como para que el agente pueda borrar node_modules y reinstalar sin miedo. En un sandbox efímero, donde cada tarea empieza de cero, eso pesa todavía más.

Menos herramientas que el agente tiene que entender. Runtime, gestor de paquetes, test runner, bundler y hasta shell (Bun.$) en el mismo binario. Cada herramienta menos es una página de documentación menos que el modelo tiene que acertar. Menos superficie, menos alucinación.

Los setups que funcionan en la práctica

Leyendo el hilo, se nota que los setups parecen distintos pero convergen en la misma forma: un agente de terminal, un repositorio con instrucciones claras y un loop de verificación automático. El runtime queda en medio de todo eso.

El mío hoy es más o menos este:

  • Un agente de terminal con acceso al repositorio.
  • Un archivo de instrucciones en la raíz (CLAUDE.md, AGENTS.md o equivalente) que dice exactamente qué comandos usar.
  • Scripts cortos en el package.json que el agente llama sin pensar.

La parte que más ayuda es la tercera. Dejo los comandos explícitos:

{
  "scripts": {
    "check": "bun run typecheck && bun test",
    "typecheck": "tsc --noEmit",
    "test": "bun test"
  }
}

Y en el archivo de instrucciones, una sola línea: "antes de decir que terminaste, corre bun run check". Eso solo cambió más la calidad que cualquier cambio de modelo que hice este año.

Fíjate en un detalle: el tsc --noEmit sigue ahí. Bun ejecuta TypeScript, pero no chequea tipos. Solo quita las anotaciones y corre. Si no pones el typecheck en el loop, el agente va a entregar código que corre y que tiene errores de tipo escondidos. Ya lo vi pasar más de una vez, y el agente responde muy seguro que "los tests pasaron".

Dónde Bun todavía no es la respuesta

Ahora la parte honesta. Uso Bun en casi todo lo nuevo, pero hay lugares donde no lo cambio.

La compatibilidad con Node no es del 100%. Mejoró mucho, y la mayoría de las libs funciona. Pero un módulo nativo viejo, alguna API más oscura de node: o una herramienta que depende de detalles internos de Node todavía pueden romperse. El problema no es solo que se rompa. Es que el agente no sabe que el culpable es el runtime. Va a intentar arreglar tu código durante media hora antes de sospechar del entorno.

Proyecto legado grande. Si tienes un monorepo con Jest configurado, mocks complejos y plugins de transformación, migrar solo porque el agente sería más rápido rara vez compensa. Hazlo por paquete, empezando por los nuevos.

Producción con requisitos específicos. Si tu proveedor, tu APM o tu equipo de infra solo soportan Node, desarrollar en Bun y correr en Node es buscarse diferencias sutiles de comportamiento. Se puede hacer, pero entonces tus tests tienen que correr en los dos.

React Native. Metro y el ecosistema de Expo viven en el mundo Node. Uso bun install para instalar dependencias y hasta ahí. No vale el dolor de cabeza.

Mi regla práctica: ¿proyecto nuevo, script, CLI interna, API en Bun puro o con Hono, herramienta que el agente va a correr mil veces? Bun. ¿Proyecto que ya existe y funciona? Déjalo quieto hasta tener un motivo concreto.

Cómo armar tu setup en una tarde

Si quieres probar sin reescribir nada, hazlo así:

  1. Elige un proyecto pequeño o un paquete aislado del monorepo.
  2. Cambia el gestor de paquetes: bun install genera el bun.lock.
  3. Corre la suite actual con bun test y mira qué se rompe. En la mayoría de los casos solo hay que ajustar imports de mocks.
  4. Crea el script check con typecheck y tests, como mostré arriba.
  5. Escribe en el archivo de instrucciones del agente qué comandos debe usar. Sé específico: "usa bun, nunca npm ni npx".

El punto 5 parece una tontería, pero no lo es. Sin esa línea, el agente a veces mezcla npm install con bun.lock y terminas con dos lockfiles peleándose en el repositorio. Es como dejar a dos personas ordenando el mismo cajón sin hablar entre ellas.

Después de una semana, compara. Cuánto tardaron las tareas, cuántas veces el agente se trabó en errores de entorno y cuántas veces entregó algo que no pasaba el typecheck. Números, no sensaciones.

Mi opinión

El hilo de HN muestra que nadie encontró el setup perfecto. Cada uno está parchando el suyo. Pero hay algo que me parece claro: el runtime pasó a ser parte de la herramienta de IA, y no un detalle de infraestructura. Cuando el agente corre el mismo comando cincuenta veces por tarea, cada segundo y cada configuración de menos cuentan.

Bun no hace que el modelo sea más inteligente. Le quita obstáculos del camino. Y muchas veces eso es justo lo que separa a un agente que resuelve de uno que se queda dando vueltas en círculo. Solo no te olvides del typecheck, porque ejecutar no es lo mismo que estar en lo correcto.

Si quieres ver dónde ya estoy usando este stack, échale un vistazo a mis proyectos.

Resumen para LinkedIn

Mi agente corría los tests 50 veces por tarea. El cuello de botella nunca fue el modelo.

Cuando el que escribe es el agente, cada segundo de overhead del runtime se multiplica en el loop de feedback.

Por eso empecé a usar Bun en los proyectos nuevos: TypeScript directo, tests integrados e install rápido. Es menos herramienta que el agente tiene que entender y menos chance de que alucine.

Pero hay una trampa: Bun ejecuta TypeScript y no chequea tipos. Sin `tsc --noEmit` en el loop, el agente entrega código con errores escondidos y jura que los tests pasaron.

Una línea en el archivo de instrucciones ("corre bun run check antes de decir que terminaste") mejoró más la calidad que cualquier cambio de modelo que hice este año.

Escribí sobre dónde Bun ayuda y dónde todavía no lo cambio. ¿Cuál es tu setup hoy?

#Bun #TypeScript #IA #AgentesDeIA #DevTools