Nuevas devtools para Node.js: Vitest, OXC, Knip y Vite+

Hace unas semanas me crucé con un tweet de Wes Bos que decía "Vite+ is SO GOOD, I've moved 3 sites over and scaffolded out a few more. So sold". Me llamó la atención porque no había escuchado hablar de Vite+ todavía, así que me metí a investigar.

Lo que encontré fue mucho más que una herramienta nueva, fue todo un ecosistema de devtools que están cambiando bastante cómo desarrollamos en Node.js. En este post les quiero contar sobre estas herramientas que ya pasaron a ser mi estandar, por qué me parecen relevantes y cómo las migré en proyectos reales.

El punto de partida: Vite+

Vite+ es básicamente una CLI unificada que consolida todo el toolchain de desarrollo web en un solo lugar: dev server, build, linting, formatting, type-checking, testing y task running. En vez de tener un package.json con 15 devDependencies distintas para cada parte del proceso, Vite+ lo unifica todo.

Los comandos son bastante directos:

vite+ dev       # dev server
vite+ build     # build de producción
vite+ check     # lint + format + typecheck
vite+ test      # tests
vite+ run       # task runner

Lo interesante es que por debajo usa herramientas que ya venían ganando tracción por separado: Vitest para testing, Oxlint y Oxfmt para linting y formatting, y tsgo para type-checking. Vite+ simplemente las empaqueta con una experiencia unificada.

Pero lo que me interesó más fue meterme en cada una de estas herramientas por separado, porque no necesitás Vite+ para usarlas.

Vitest: tests sin la fricción de Jest

Vitest es un framework de testing nativo de Vite. La API es compatible con Jest (tiene expect, describe, it, snapshots, mocking), así que la migración es bastante directa.

Las ventajas principales que vi:

• Reutiliza la config de Vite: aliases, plugins, transforms. No necesitás duplicar configuración como pasa con Jest.
• ESM y TypeScript nativo: no hace falta ts-jest ni babel-jest. Funciona directo.
• Watch mode inteligente: similar a HMR, solo re-ejecuta los tests afectados por el cambio.
• Browser mode: podés correr tests en un browser real para component testing.

En la práctica, la diferencia más notable es el tiempo. En un proyecto con NestJS pasé de 21 segundos con Jest a 7 segundos con Vitest. Y el watch mode es instantáneo.

La migración se resume en cambiar las importaciones de @jest/globals a vitest, ajustar la config y poco más. La API es tan similar que la mayoría de los tests no necesitan cambios.

OXC: linting y formatting en Rust

OXC (The JavaScript Oxidation Compiler) es una colección de herramientas de alto rendimiento escritas en Rust. Las dos que más me interesan son:

Oxlint

Un linter compatible con ESLint con más de 700 reglas. Los números que manejan son impactantes: 50-100x más rápido que ESLint. Soporta plugins de ESLint y type-aware linting.

En la práctica, lo que antes tardaba 8-10 segundos con ESLint ahora tarda menos de 200ms. Eso suena a un detalle menor, pero cuando estás iterando rápido (especialmente con herramientas de IA), esa diferencia se siente mucho.

Oxfmt

Un formatter compatible con Prettier, 30x más rápido según sus benchmarks (y 3x más rápido que Biome). Soporta sorting de clases de Tailwind, que era una de las cosas que me ataba a Prettier.

La transición desde Prettier es bastante transparente. El output es prácticamente idéntico en la mayoría de los casos.

Knip: encontrando código muerto

Knip fue un descubrimiento aparte. No reemplaza a ninguna de las herramientas anteriores, sino que complementa: encuentra dependencias no usadas, exports sin usar y archivos muertos en tu proyecto.

Construye un grafo de dependencias a partir de los entry points de tu framework (tiene más de 100 plugins, incluyendo Next.js, NestJS, Vite, etc.) y te marca todo lo que no se está usando.

Vercel lo usó internamente y borró ~300k líneas de código muerto. En mis proyectos no fue tan dramático, pero encontró varias dependencias en el package.json que ya no se usaban y exports que habían quedado huérfanos después de refactors.

npx knip

Así de simple. Y la salida es clara: te dice qué archivos, qué exports y qué dependencias podés eliminar.

Tanto Knip como OXC tienen extensiones para VS Code. La de Knip en particular está muy buena porque te marca visualmente el código muerto directo en el editor: exports sin usar, dependencias huérfanas, archivos que nadie importa. En vez de correr el comando y revisar la salida, lo ves en tiempo real mientras trabajás.

Migrando con Claude Code

Acá viene la parte que más me sorprendió. Tenía varios proyectos con NestJS que usaban el stack clásico: Jest, ESLint y Prettier. Decidí probar migrarlos a Vitest, Oxlint, Oxfmt y agregar Knip.

En vez de hacerlo manualmente, le pedí a Claude Code que hiciera las migraciones directamente. Le di instrucciones como "migrá este proyecto de Jest a Vitest, reemplazá ESLint por Oxlint, Prettier por Oxfmt, y agregá Knip".

El resultado fue sorprendente:

• La migración de tests fue limpia: cambió las importaciones, ajustó la configuración, adaptó los mocks donde hacía falta.
• La config de Oxlint y Oxfmt quedó lista sin problemas.
• Knip lo configuró y ejecutó, identificando código muerto que pude eliminar.

Cada migración que manualmente me hubiera llevado un buen rato, Claude Code la resolvió en minutos. Y no estoy hablando de proyectos chicos: eran proyectos con buena cobertura de tests y configuraciones no triviales de ESLint. Ni hablar de toda la limpieza de código gracias a knip junto con claude.

Por qué la velocidad importa más que nunca

Este es el punto que más me interesa resaltar. No se trata solo de ahorrar unos segundos en cada lint o cada test run. Se trata de cómo estas herramientas cambian el flujo de trabajo cuando usás IA para desarrollar.

Pensemos en un ciclo típico con Claude Code o cualquier herramienta similar:

1. Le pedís que implemente algo
2. Corre los tests para verificar
3. Formatea el código
4. Corre el linter
5. Si algo falla, itera

Si cada paso tarda 30-45 segundos, esas iteraciones se acumulan rápido. Pero si los tests corren en 15 segundos, el linter en 200ms y el formatter en menos de un segundo, la velocidad de iteración se multiplica.

Y hay otro punto importante: los modelos de IA son muy buenos armando tests. Si tenés una suite de tests rápida, podés pedirle al modelo que agregue tests para cada cambio, correrlos al instante y tener confianza de que no se rompió nada. Con Jest tardando 30-35 segundos por corrida, el incentivo de agregar tests baja, de hecho, hasta tuve que empezar a cuidar partes por timeouts o similares. Con Vitest en 7-8 segundos, testear se vuelve parte natural del loop.

En los proyectos que migré, el ciclo completo de iteración (test + lint + format) pasó de ~30 segundos a ~8 segundos. Casi un tercio del tiempo original, con mejores resultados porque Oxlint encuentra cosas que ESLint no detectaba y Knip limpió código que nadie estaba mirando.

Resumen

Herramienta	Reemplaza	Mejora principal
Vitest	Jest	~3x más rápido, ESM nativo, config compartida con Vite
Oxlint	ESLint	50-100x más rápido, +700 reglas
Oxfmt	Prettier	30x más rápido, compatible con Tailwind
Knip	(nada)	Encuentra código y dependencias muertos
Vite+	Todo junto	CLI unificada para todo el toolchain

Si todavía no probaron estas herramientas, les recomiendo empezar por Vitest y Oxlint. La migración desde Jest y ESLint es directa, y la diferencia de velocidad se nota desde el primer momento. Y si usan herramientas de IA para desarrollar, la mejora en el loop de iteración es todavía más significativa.