A inteligência artificial está transformando a forma como desenvolvemos software. Hoje é possível gerar um CRUD completo em poucos minutos utilizando ferramentas como ChatGPT, Claude, Gemini e outras plataformas de IA.

Nesse contexto surge uma pergunta estratégica: qual stack tecnológica consome menos tokens e entrega maior produtividade na geração de código?

Essa questão importa porque o consumo de tokens impacta diretamente o custo de utilização da IA, a velocidade de geração, a clareza das respostas, a facilidade de manutenção e a quantidade de contexto disponível para regras de negócio.

O que são tokens

Tokens são as unidades de texto processadas pelos modelos de linguagem. Cada modelo possui um orçamento finito de tokens por requisição, e tudo que ele lê ou produz consome desse orçamento.

  • Palavras inteiras ou fragmentos de palavras.
  • Símbolos e pontuações.
  • Trechos de código fonte, com nomes de variáveis, tipos e estruturas.
  • Espaços, quebras de linha e indentação.

Quanto mais extenso e verboso for o código, maior será o consumo de tokens. Frameworks que exigem muito boilerplate ou decoradores extensos drenam o orçamento antes mesmo da regra de negócio aparecer.

Por que isso importa

Ao desenvolver aplicações com apoio de IA, parte do orçamento de tokens é consumida pela estrutura do próprio código. Stacks mais enxutas oferecem vantagens diretas para o time de engenharia.

  • Menor custo operacional em chamadas para a API do modelo.
  • Respostas mais rápidas, porque o contexto enviado é menor.
  • Menor necessidade de dividir prompts em várias etapas.
  • Mais espaço para descrever regras de negócio e requisitos específicos.
“Quanto menos tokens a infraestrutura consome, mais tokens sobram para o que realmente gera valor para o negócio.”

Metodologia do benchmark

Para tornar a comparação justa, definimos um cenário padrão que qualquer stack precisa entregar: um CRUD completo para a entidade Customer, com regras de negócio explícitas e endpoints REST padronizados.

A entidade Customer possui os seguintes campos:

  • id
  • name
  • email
  • document
  • phone
  • status
  • created_at
  • updated_at

Os endpoints REST esperados são:

  • POST /customers, cria um novo cliente.
  • GET /customers, lista clientes com paginação.
  • GET /customers/:id, recupera um cliente específico.
  • PUT /customers/:id, atualiza dados do cliente.
  • DELETE /customers/:id, remove o cliente.

As regras de negócio que cada implementação precisa garantir:

  • O campo name é obrigatório.
  • O email deve ser único entre os clientes.
  • O document deve ser único entre os clientes.
  • O status aceita apenas os valores active ou inactive.
  • A listagem retorna resultados paginados.
  • Erros são padronizados em respostas JSON.

Stacks avaliadas

  • PHP com Laravel.
  • Bun com Elysia e Drizzle.
  • Bun com Hono e Drizzle.
  • Go com Fiber e Ent.
  • Go com Gin e GORM.
  • TypeScript com NestJS e Prisma.

Para cada stack acompanhamos os mesmos critérios de avaliação:

  • Total de tokens consumidos na geração.
  • Linhas de código produzidas.
  • Quantidade de arquivos gerados.
  • Tempo de implementação até o primeiro deploy local.
  • Número de ajustes necessários após a primeira execução.
  • Complexidade de manutenção a longo prazo.

Resultado esperado

Antes de rodar o benchmark na prática, vale registrar a hipótese de ranqueamento baseada em experiência de uso real de IA para geração de código:

  • 1. Bun com Elysia e Drizzle, excelente equilíbrio entre concisão e tipagem.
  • 2. PHP com Laravel, altíssima produtividade e maturidade.
  • 3. Bun com Hono e Drizzle, estrutura enxuta e simples.
  • 4. Go com Fiber e Ent, forte na geração de código a partir de schema.
  • 5. Go com Gin e GORM, boa produtividade, porém mais verboso.
  • 6. TypeScript com NestJS e Prisma, arquitetura robusta, mas mais detalhada.

Laravel: o benchmark clássico

O Laravel continua sendo uma referência em produtividade no mundo PHP. Uma única linha cria todas as rotas REST de um recurso, e o ecossistema entrega praticamente tudo que um CRUD precisa: validação, migrações, ORM, autenticação e testes.

  • Convenções maduras que reduzem decisões repetitivas.
  • CLI poderosa para gerar controllers, models e migrations.
  • Eloquent como ORM robusto e expressivo.
  • Grande ecossistema com pacotes consolidados.

Bun com Elysia e Drizzle: o novo concorrente

O Bun combina um runtime moderno com suporte nativo a TypeScript. O Elysia oferece uma API extremamente concisa para definir rotas e validações, e o Drizzle mantém o acesso ao banco tipado, leve e próximo ao SQL.

  • Código enxuto, com poucas linhas para expor uma rota completa.
  • Excelente inferência de tipos de ponta a ponta.
  • Alta performance no runtime do Bun.
  • Baixo overhead de boilerplate e decoradores.

Go com Ent: produtividade com geração de código

O Go tradicionalmente é mais explícito que linguagens dinâmicas, mas o Ent reduz significativamente o boilerplate. Ao definir o schema da entidade, grande parte das operações de CRUD é gerada automaticamente, com tipos fortes e queries seguras.

Isso aproxima o Go da produtividade de frameworks mais opinativos, sem abrir mão de binários simples e alta performance em produção.

NestJS com Prisma: arquitetura corporativa

O NestJS é excelente para sistemas complexos e times grandes. Decoradores, módulos e injeção de dependência criam uma arquitetura previsível, ainda que à custa de mais tokens por arquivo gerado.

  • Arquitetura consistente entre módulos e features.
  • Separação clara de responsabilidades entre controllers, services e repositories.
  • Forte aderência a padrões corporativos e DDD.
  • Ecossistema maduro de integrações e testes.

O papel do framework

A linguagem é apenas parte da equação. O maior impacto no consumo de tokens está em decisões do framework escolhido.

  • Convenções que evitam reescrever a mesma estrutura a cada feature.
  • Geração automática de código a partir de schemas ou definições.
  • Nível de abstração escolhido para encapsular regras comuns.
  • Verbosidade exigida pela arquitetura de referência do framework.

Em muitos casos, o framework influencia mais o orçamento de tokens do que a linguagem em si. Trocar de framework dentro da mesma linguagem pode reduzir o consumo pela metade.

O que a Anthropic diz sobre isso

Esse raciocínio não é apenas opinião de quem usa IA no dia a dia. Em artigo recente sobre Claude Code em grandes bases de código, a própria Anthropic reforça que o entorno do modelo importa mais do que o modelo isolado.

“O ecossistema construído ao redor do modelo, o harness, determina o desempenho do Claude Code mais do que o modelo sozinho.”

Traduzindo para o debate de stacks: o framework, suas convenções, o ORM escolhido e a arquitetura padrão funcionam como o harness do modelo. É essa camada que decide se a IA gasta tokens entendendo a estrutura ou avançando na regra de negócio.

“A capacidade do Claude de ajudar em uma base de código grande é limitada pela sua capacidade de encontrar o contexto certo.”

Stacks enxutas como Bun com Elysia e Drizzle entregam essa legibilidade de forma natural: poucos arquivos, tipos inferidos e baixa indireção. Frameworks mais opinativos compensam com convenções fortes, mas o preço é pago em tokens por arquivo.

“Contexto demais carregado em cada sessão degrada a performance; contexto de menos deixa o Claude navegando às cegas.”

O ponto é direto: existe um equilíbrio. Stacks que minimizam o ruído estrutural deixam mais espaço para o que importa, sem cair no extremo oposto de exigir contexto adicional a cada prompt.

Qual stack escolher

A escolha depende de qual prioridade está no topo do projeto. Algumas combinações funcionam melhor em determinados cenários.

  • Prioridade em menor consumo de tokens: Bun com Elysia e Drizzle, seguido de Laravel.
  • Prioridade em produtividade e maturidade: Laravel.
  • Prioridade em type safety moderno: Bun com Elysia e Drizzle.
  • Prioridade em performance e binários simples: Go com Fiber e Ent.
  • Prioridade em arquitetura corporativa: NestJS com Prisma.

Minha recomendação

Para a maioria dos projetos de negócio, a recomendação é adotar Bun com Elysia e Drizzle como stack moderna e extremamente eficiente no uso de tokens. A combinação entrega tipagem forte, baixo boilerplate e performance suficiente para a grande maioria dos cenários.

Se o objetivo for máxima produtividade com um ecossistema consolidado e bibliotecas para praticamente qualquer integração, o Laravel segue como uma escolha excepcional.

Conclusão

Ao utilizar IA para desenvolvimento, o consumo de tokens passa a ser um fator estratégico, não apenas um detalhe técnico. Stacks mais concisas reduzem custo, aceleram a geração, simplificam iterações e liberam contexto para regras de negócio.

“A melhor stack é aquela que maximiza a produtividade do time e permite que a IA concentre esforços na lógica que diferencia o produto.”

Bun com Elysia e Drizzle se destaca por combinar modernidade, tipagem forte, performance e código enxuto. Laravel segue como uma das plataformas mais produtivas e maduras do mercado para times que valorizam convenção sobre configuração.

Limitações desta análise

É honesto reconhecer onde este artigo ainda não fecha o ciclo. A leitura apresentada aqui se sustenta em experiência prática de uso de IA para geração de código, não em medições controladas em laboratório.

  • Ainda não temos contagem absoluta de tokens por stack para o mesmo escopo.
  • O ranqueamento apresentado é uma hipótese de trabalho, não um resultado fechado.
  • Diferenças entre modelos (Claude, GPT, Gemini) podem alterar a ordem em casos específicos.
  • Custo total de propriedade depende também de talento disponível, suporte do ecossistema e custos operacionais fora da geração de código.

O próprio material da Anthropic sobre Claude Code em grandes bases reconhece um ponto parecido: as recomendações são qualitativas, sem números absolutos de tokens consumidos ou custo por tarefa. É exatamente essa lacuna que o próximo passo deste benchmark pretende preencher.

Próximos passos

Em um próximo artigo pretendo executar esse benchmark na prática e apresentar métricas reais de cada stack.

  • Tokens consumidos por arquivo e por iteração.
  • Linhas de código geradas para o mesmo escopo funcional.
  • Tempo de geração até o primeiro deploy local.
  • Performance em testes de carga simples.
  • Facilidade de manutenção e evolução do CRUD.

Se você também está utilizando IA para acelerar o desenvolvimento, essa comparação pode ajudar a escolher uma stack mais eficiente e alinhada à estratégia tecnológica do seu produto.