Voltar para o blog
BunIAAgentesTypeScript

Bun no setup de agentes de IA: o que realmente muda

06 de novembro de 2026·6 min de leitura·Diego Horvatti

Alguém abriu um tópico no Hacker News com uma pergunta simples: qual é o seu setup atual de agentes de IA?. Como sempre, apareceram centenas de respostas, e cada uma descreve um ecossistema próprio. Eu li procurando uma coisa só: o runtime. Quem usa agente para escrever TypeScript está, cada vez mais, rodando tudo em cima do Bun. E isso tem menos a ver com moda do que parece.

Este texto é sobre isso. O que o Bun ganha num fluxo com agentes, onde ele não muda nada e como eu montaria um setup hoje.

Por que o runtime importa quando quem digita é o agente

Quando você programa sozinho, o tempo de rodar um teste quase não aparece. Você salva, olha o terminal, toma um gole de café. Dois segundos a mais não fazem diferença.

Com um agente é diferente. Ele não toma café. Ele roda o teste, lê o erro, edita, roda de novo. Numa tarefa média isso acontece 20, 30, às vezes 50 vezes. Se cada ciclo gasta 4 segundos de overhead só para subir o runtime, transpilar e resolver módulos, são minutos parados por tarefa. Multiplica por várias tarefas no dia e por alguns agentes rodando em paralelo.

O gargalo mudou de lugar. Antes era a sua velocidade de digitar. Agora é a velocidade do loop de feedback.

Agente bom com feedback lento continua sendo um agente lento.

É aí que o Bun entra. Ele foi pensado para startup rápido e para fazer muita coisa sem configuração. No dia a dia de um humano isso é conforto. No loop de um agente, isso vira tempo e token economizados.

O que o Bun resolve no loop de um agente de IA

Vou separar o que eu vejo funcionando na prática.

Roda TypeScript direto. Sem tsc, sem ts-node, sem loader. O agente cria um script .ts e executa na hora:

bun run scripts/migrar-usuarios.ts

Parece pouco, mas elimina uma categoria inteira de erro. Quantas vezes você já viu um agente se perder em ERR_UNKNOWN_FILE_EXTENSION ou brigando com "type": "module" no package.json? Cada uma dessas brigas custa várias rodadas e um monte de contexto jogado fora.

Teste embutido e rápido. O bun test tem API compatível com Jest na maior parte dos casos. O agente já conhece describe, it e expect de cor, então escreve testes sem precisar ler documentação:

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

describe("calcularFrete", () => {
  it("zera o frete acima de 200 reais", () => {
    expect(calcularFrete({ total: 250, cep: "01310100" })).toBe(0);
  });
});

Numa suíte pequena, a diferença de tempo para um setup com Jest e transpilação é bem perceptível. E o agente roda essa suíte o tempo todo.

Instalação de dependência que não trava. O bun install é rápido o bastante para o agente poder apagar o node_modules e reinstalar sem medo. Em sandbox efêmero, onde cada tarefa começa do zero, isso pesa mais ainda.

Menos ferramenta para o agente entender. Runtime, gerenciador de pacotes, test runner, bundler e até shell (Bun.$) no mesmo binário. Cada ferramenta a menos é uma página de documentação a menos que o modelo precisa acertar. Menos superfície, menos alucinação.

Os setups que funcionam na prática

Lendo o tópico, dá para notar que os setups parecem diferentes mas convergem para a mesma forma: um agente de terminal, um repositório com instruções claras e um loop de verificação automático. O runtime fica no meio disso tudo.

O meu hoje é mais ou menos este:

  • Um agente de terminal com acesso ao repositório.
  • Um arquivo de instruções na raiz (CLAUDE.md, AGENTS.md ou equivalente) dizendo exatamente quais comandos usar.
  • Scripts curtos no package.json que o agente chama sem pensar.

A parte que mais ajuda é a terceira. Eu deixo os comandos explícitos:

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

E no arquivo de instruções, uma linha só: "antes de dizer que terminou, rode bun run check". Isso sozinho mudou mais a qualidade do que qualquer troca de modelo que eu fiz este ano.

Repara num detalhe: o tsc --noEmit continua lá. O Bun executa TypeScript, mas não checa tipos. Ele só remove as anotações e roda. Se você não colocar o typecheck no loop, o agente vai entregar código que roda e que tem erro de tipo escondido. Já vi isso acontecer mais de uma vez, e o agente responde todo confiante que "os testes passaram".

Onde o Bun ainda não é a resposta

Agora a parte honesta. Eu uso Bun em quase tudo que é novo, mas tem lugar onde eu não troco.

Compatibilidade com Node não é 100%. Melhorou muito, e a maioria das libs funciona. Mas módulo nativo antigo, alguma API mais obscura de node: ou ferramenta que depende de detalhe interno do Node ainda podem quebrar. O problema não é só quebrar. É que o agente não sabe que o culpado é o runtime. Ele vai tentar consertar o seu código por meia hora antes de desconfiar do ambiente.

Projeto legado grande. Se você tem um monorepo com Jest configurado, mocks complexos e plugins de transformação, migrar só porque o agente ficaria mais rápido raramente compensa. Faz por pacote, começando pelos novos.

Produção com requisito específico. Se o seu provedor, o seu APM ou a sua equipe de infra só suportam Node, desenvolver em Bun e rodar em Node é pedir para cair em diferença sutil de comportamento. Dá para fazer, mas aí o seu teste precisa rodar nos dois.

React Native. O Metro e o ecossistema do Expo vivem no mundo Node. Uso bun install para instalar dependência e paro por aí. Não vale a dor de cabeça.

Minha regra prática: projeto novo, script, CLI interna, API em Bun puro ou com Hono, ferramenta que o agente vai rodar mil vezes? Bun. Projeto que já existe e funciona? Deixa quieto até ter um motivo concreto.

Como montar seu setup em uma tarde

Se você quer testar sem reescrever nada, faz assim:

  1. Escolhe um projeto pequeno ou um pacote isolado do monorepo.
  2. Troca o gerenciador de pacotes: bun install gera o bun.lock.
  3. Roda a suíte atual com bun test e vê o que quebra. Na maioria dos casos é só ajustar imports de mock.
  4. Cria o script check com typecheck e testes, como mostrei acima.
  5. Escreve no arquivo de instruções do agente quais comandos ele deve usar. Seja específico: "use bun, nunca npm nem npx".

O item 5 parece bobo, mas não é. Sem essa linha, o agente às vezes mistura npm install com bun.lock e você acaba com dois lockfiles brigando no repositório. É como deixar duas pessoas organizando a mesma gaveta sem conversar.

Depois de uma semana, compara. Quanto tempo as tarefas levaram, quantas vezes o agente travou em erro de ambiente e quantas vezes ele entregou algo que não passava no typecheck. Número, não sensação.

Minha opinião

O tópico do HN mostra que ninguém achou o setup perfeito. Cada um está remendando o seu. Mas uma coisa me parece clara: o runtime virou parte da ferramenta de IA, e não um detalhe de infraestrutura. Quando o agente roda o mesmo comando cinquenta vezes por tarefa, cada segundo e cada configuração a menos entram na conta.

O Bun não deixa o modelo mais inteligente. Ele tira obstáculos do caminho. E muitas vezes é exatamente isso que separa um agente que resolve de um que fica andando em círculo. Só não esquece o typecheck, porque executar não é a mesma coisa que estar certo.

Se quiser ver onde eu já estou usando essa stack, dá uma olhada nos meus projetos.

Resumo para o LinkedIn

Meu agente rodava o teste 50 vezes por tarefa. O gargalo nunca foi o modelo.

Quando quem digita é o agente, cada segundo de overhead do runtime se multiplica no loop de feedback.

Foi por isso que passei a usar Bun nos projetos novos: TypeScript direto, teste embutido e install rápido. É menos ferramenta para o agente entender e menos chance de alucinar.

Mas tem uma pegadinha: o Bun executa TypeScript e não checa tipos. Sem `tsc --noEmit` no loop, o agente entrega código com erro escondido e jura que os testes passaram.

Uma linha no arquivo de instruções ("rode bun run check antes de dizer que terminou") melhorou mais a qualidade do que qualquer troca de modelo que fiz este ano.

Escrevi sobre onde o Bun ajuda e onde eu ainda não troco. Qual é o seu setup hoje?

#Bun #TypeScript #IA #AgentesDeIA #DevTools