La inteligencia artificial está transformando la forma en que desarrollamos software. Hoy es posible generar un CRUD completo en pocos minutos utilizando herramientas como ChatGPT, Claude, Gemini y otras plataformas de IA.

En ese contexto surge una pregunta estratégica: ¿qué stack tecnológico consume menos tokens y ofrece mayor productividad en la generación de código?

Esta cuestión importa porque el consumo de tokens impacta directamente en el costo de uso de la IA, la velocidad de generación, la claridad de las respuestas, la facilidad de mantenimiento y la cantidad de contexto disponible para las reglas de negocio.

Qué son los tokens

Los tokens son las unidades de texto procesadas por los modelos de lenguaje. Cada modelo tiene un presupuesto finito de tokens por solicitud, y todo lo que lee o produce consume parte de ese presupuesto.

  • Palabras enteras o fragmentos de palabras.
  • Símbolos y signos de puntuación.
  • Fragmentos de código fuente, con nombres de variables, tipos y estructuras.
  • Espacios, saltos de línea e indentación.

Cuanto más extenso y verboso sea el código, mayor será el consumo de tokens. Los frameworks que exigen mucho boilerplate o decoradores extensos agotan el presupuesto antes incluso de que aparezca la regla de negocio.

Por qué esto importa

Al desarrollar aplicaciones con apoyo de IA, parte del presupuesto de tokens se consume en la estructura del propio código. Los stacks más concisos ofrecen ventajas directas para el equipo de ingeniería.

  • Menor costo operativo en llamadas a la API del modelo.
  • Respuestas más rápidas, porque el contexto enviado es menor.
  • Menor necesidad de dividir los prompts en varios pasos.
  • Más espacio para describir reglas de negocio y requisitos específicos.
“Cuantos menos tokens consume la infraestructura, más tokens quedan para lo que realmente genera valor para el negocio.”

Metodología del benchmark

Para que la comparación sea justa, definimos un escenario estándar que cualquier stack debe entregar: un CRUD completo para la entidad Customer, con reglas de negocio explícitas y endpoints REST estandarizados.

La entidad Customer tiene los siguientes campos:

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

Los endpoints REST esperados son:

  • POST /customers, crea un nuevo cliente.
  • GET /customers, lista los clientes con paginación.
  • GET /customers/:id, recupera un cliente específico.
  • PUT /customers/:id, actualiza los datos del cliente.
  • DELETE /customers/:id, elimina el cliente.

Reglas de negocio que cada implementación debe garantizar:

  • El campo name es obligatorio.
  • El email debe ser único entre los clientes.
  • El document debe ser único entre los clientes.
  • El status solo acepta los valores active o inactive.
  • El listado devuelve resultados paginados.
  • Los errores se estandarizan en respuestas JSON.

Stacks evaluados

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

Para cada stack seguimos los mismos criterios de evaluación:

  • Total de tokens consumidos durante la generación.
  • Líneas de código producidas.
  • Cantidad de archivos generados.
  • Tiempo de implementación hasta el primer despliegue local.
  • Cantidad de ajustes necesarios tras la primera ejecución.
  • Complejidad de mantenimiento a largo plazo.

Resultado esperado

Antes de ejecutar el benchmark en la práctica, vale la pena registrar la hipótesis de ranking que sostenemos hoy, basada en la experiencia real de uso de IA para generación de código:

  • 1. Bun con Elysia y Drizzle, excelente equilibrio entre concisión y tipado.
  • 2. PHP con Laravel, altísima productividad y madurez.
  • 3. Bun con Hono y Drizzle, estructura ligera y simple.
  • 4. Go con Fiber y Ent, fuerte en la generación de código a partir de schema.
  • 5. Go con Gin y GORM, buena productividad, pero más verboso.
  • 6. TypeScript con NestJS y Prisma, arquitectura robusta, pero más detallada.

Laravel: el benchmark clásico

Laravel sigue siendo una referencia en productividad en el mundo PHP. Una sola línea crea todas las rutas REST de un recurso, y el ecosistema entrega prácticamente todo lo que un CRUD necesita: validación, migraciones, ORM, autenticación y pruebas.

  • Convenciones maduras que reducen decisiones repetitivas.
  • CLI potente para generar controllers, models y migrations.
  • Eloquent como ORM robusto y expresivo.
  • Gran ecosistema con paquetes consolidados.

Bun con Elysia y Drizzle: el nuevo competidor

Bun combina un runtime moderno con soporte nativo para TypeScript. Elysia ofrece una API extremadamente concisa para definir rutas y validaciones, y Drizzle mantiene el acceso a la base de datos tipado, ligero y cercano al SQL.

  • Código conciso, con pocas líneas para exponer una ruta completa.
  • Excelente inferencia de tipos de extremo a extremo.
  • Alto rendimiento en el runtime de Bun.
  • Bajo overhead de boilerplate y decoradores.

Go con Ent: productividad mediante generación de código

Go es tradicionalmente más explícito que los lenguajes dinámicos, pero Ent reduce significativamente el boilerplate. Al definir el schema de la entidad, gran parte de las operaciones de CRUD se generan automáticamente, con tipos fuertes y queries seguras.

Esto acerca a Go a la productividad de frameworks más opinados, sin renunciar a binarios simples y alto rendimiento en producción.

NestJS con Prisma: arquitectura corporativa

NestJS es excelente para sistemas complejos y equipos grandes. Decoradores, módulos e inyección de dependencias crean una arquitectura previsible, aunque a costa de más tokens por archivo generado.

  • Arquitectura consistente entre módulos y features.
  • Separación clara de responsabilidades entre controllers, services y repositories.
  • Fuerte adherencia a patrones corporativos y DDD.
  • Ecosistema maduro de integraciones y pruebas.

El papel del framework

El lenguaje es solo parte de la ecuación. El mayor impacto en el consumo de tokens proviene de las decisiones del framework elegido.

  • Convenciones que evitan reescribir la misma estructura en cada feature.
  • Generación automática de código a partir de schemas o definiciones.
  • Nivel de abstracción elegido para encapsular reglas comunes.
  • Verbosidad exigida por la arquitectura de referencia del framework.

En muchos casos, el framework influye más en el presupuesto de tokens que el lenguaje en sí. Cambiar de framework dentro del mismo lenguaje puede reducir el consumo a la mitad.

Lo que dice Anthropic al respecto

Este razonamiento no es solo la opinión de quien usa IA en el día a día. En un artículo reciente sobre Claude Code en grandes bases de código, la propia Anthropic refuerza que el entorno del modelo importa más que el modelo aislado.

“El ecosistema construido alrededor del modelo, el harness, determina el rendimiento de Claude Code más que el modelo por sí solo.”

Traducido al debate de stacks: el framework, sus convenciones, el ORM elegido y la arquitectura por defecto funcionan como el harness del modelo. Esa capa decide si la IA gasta tokens entendiendo tu estructura o avanzando en la lógica de negocio.

“La capacidad de Claude para ayudar en una base de código grande está limitada por su capacidad de encontrar el contexto correcto.”

Stacks concisos como Bun con Elysia y Drizzle entregan esa legibilidad de forma natural: pocos archivos, tipos inferidos y baja indirección. Los frameworks más opinados compensan con convenciones fuertes, pero el precio se paga en tokens por archivo.

“Demasiado contexto cargado en cada sesión degrada el rendimiento; muy poco contexto deja a Claude navegando a ciegas.”

El punto es directo: existe un equilibrio. Los stacks que minimizan el ruido estructural dejan más espacio para lo que importa, sin caer en el extremo opuesto de exigir contexto adicional en cada prompt.

Qué stack elegir

La elección depende de cuál sea la prioridad principal del proyecto. Algunas combinaciones funcionan mejor en escenarios específicos.

  • Prioridad en menor consumo de tokens: Bun con Elysia y Drizzle, seguido de Laravel.
  • Prioridad en productividad y madurez: Laravel.
  • Prioridad en type safety moderno: Bun con Elysia y Drizzle.
  • Prioridad en rendimiento y binarios simples: Go con Fiber y Ent.
  • Prioridad en arquitectura corporativa: NestJS con Prisma.

Mi recomendación

Para la mayoría de los proyectos de negocio, la recomendación es adoptar Bun con Elysia y Drizzle como stack moderno y extremadamente eficiente en el uso de tokens. La combinación entrega tipado fuerte, bajo boilerplate y suficiente rendimiento para la gran mayoría de los escenarios.

Si el objetivo es maximizar la productividad con un ecosistema consolidado y librerías para prácticamente cualquier integración, Laravel sigue siendo una opción excepcional.

Conclusión

Al utilizar IA para el desarrollo, el consumo de tokens se convierte en un factor estratégico, no solo un detalle técnico. Los stacks más concisos reducen el costo, aceleran la generación, simplifican las iteraciones y liberan contexto para las reglas de negocio.

“El mejor stack es aquel que maximiza la productividad del equipo y permite que la IA enfoque su esfuerzo en la lógica que diferencia el producto.”

Bun con Elysia y Drizzle se destaca por combinar modernidad, tipado fuerte, rendimiento y código conciso. Laravel sigue siendo una de las plataformas más productivas y maduras del mercado para equipos que valoran la convención sobre la configuración.

Limitaciones de este análisis

Es justo reconocer dónde este artículo aún no cierra el ciclo. La lectura presentada aquí se basa en la experiencia práctica de uso de IA para generación de código, no en mediciones controladas en laboratorio.

  • Aún no tenemos un conteo absoluto de tokens por stack para el mismo alcance.
  • El ranking presentado es una hipótesis de trabajo, no un resultado cerrado.
  • Las diferencias entre modelos (Claude, GPT, Gemini) pueden alterar el orden en casos específicos.
  • El costo total de propiedad también depende del talento disponible, el soporte del ecosistema y los costos operativos fuera de la generación de código.

El propio material de Anthropic sobre Claude Code en grandes bases de código reconoce un punto parecido: las recomendaciones son cualitativas, sin números absolutos de tokens consumidos o costo por tarea. Es precisamente esa brecha la que el siguiente paso de este benchmark pretende llenar.

Próximos pasos

En un próximo artículo planeo ejecutar este benchmark en la práctica y presentar métricas reales de cada stack.

  • Tokens consumidos por archivo y por iteración.
  • Líneas de código generadas para el mismo alcance funcional.
  • Tiempo de generación hasta el primer despliegue local.
  • Rendimiento en pruebas de carga simples.
  • Facilidad de mantenimiento y evolución del CRUD.

Si tú también estás utilizando IA para acelerar el desarrollo, esta comparación puede ayudarte a elegir un stack más eficiente y alineado con la estrategia tecnológica de tu producto.