---
title: "next-bundle-optimizer: la skill de Vercel que audita el bundle de Next.js, probada en mi sitio"
excerpt: "next-bundle-optimizer es la skill oficial de Next.js que le da a tu agente el grafo de módulos de Turbopack para encontrar JavaScript que sobra. En Vercel recortó casi dos megabytes. En mi blog, 3 KB por ruta. Las dos cifras dicen algo útil."
date: "2026-11-15T18:00:00.000Z"
category: "Next.js"
tech_article: true
author:
  name: "angel cruz"
  picture: "/images/me/angel-cruz.png"
ogImage:
  url: "/images/open-graph/next-opengraph-image.png"
seo_title: "next-bundle-optimizer: la skill para reducir el bundle de Next.js"
seo_description: "Qué es next-bundle-optimizer, cómo instalarla con npx skills, qué hace next analyze y lo que encontró en un sitio real de Next.js 16.4: los números completos."
---

**next-bundle-optimizer es la skill oficial de Next.js para agentes de código: le da a tu agente el grafo de módulos de Turbopack, a través de `next analyze`, para que encuentre JavaScript que tu app carga antes de necesitarlo y proponga cómo diferirlo o quitarlo.** Vercel cuenta que con ella [recortó casi dos megabytes de JavaScript comprimido entre v0 y vercel.com](https://nextjs.org/blog/ship-less-javascript-with-ai). La pasé por este blog, que también es Next.js, y encontró 3 KB por ruta. Las dos cifras son ciertas, y la distancia entre ellas te dice si vale la pena correrla en tu proyecto.

## Qué es next-bundle-optimizer

La skill vive en el propio repositorio de Next.js, en [`skills/next-bundle-optimizer`](https://github.com/vercel/next.js/tree/canary/skills/next-bundle-optimizer), y entró el 6 de octubre de 2026, el mismo día que salió [Next.js 16.4.0 en npm](https://www.npmjs.com/package/next/v/16.4.0). La presentó Will Binns-Smith en el [blog de Next.js el 28 de octubre](https://nextjs.org/blog/ship-less-javascript-with-ai).

Es un `SKILL.md` con seis pasos: fijar el alcance, capturar una línea base, interpretar el grafo, explicar cada candidato, verificar un cambio y reportar. Lo que la hace distinta de pedirle a tu agente "optimiza el bundle" es que trabaja sobre datos del build y no sobre intuiciones. Según el post de Vercel, busca grupos grandes de módulos conectados (con el [método de Louvain](https://en.wikipedia.org/wiki/Louvain_method)) y después calcula un [corte mínimo](https://en.wikipedia.org/wiki/Minimum_cut): el conjunto más chico de imports que, si se vuelven diferidos, sacan ese grupo de la carga inicial.

Además de los imports diferibles, el post dice que detecta lógica que podría moverse a Server Components, versiones duplicadas de dependencias grandes y casos donde el tree shaking no pudo aplicarse.

Por defecto solo audita. [El `SKILL.md`](https://github.com/vercel/next.js/blob/canary/skills/next-bundle-optimizer/SKILL.md) es explícito: en modo audit genera los artefactos del análisis y reporta candidatos sin tocar el código, las dependencias ni el lockfile. Para que cambie algo hay que pedírselo.

## Instalar next-bundle-optimizer con npx skills

La skill se instala con [`npx skills`](/post/npx-skills), el mismo comando que sirve para cualquier otra skill. El post de Vercel da esta línea:

```bash
npx skills add vercel/next.js --skill next-bundle-optimizer
```

Después se invoca desde el agente:

```text
/next-bundle-optimizer        # audita y reporta
/next-bundle-optimizer fix    # aplica los cambios y compara antes y después
```

Hay dos requisitos. El post pide [Next.js 16.4](https://nextjs.org/blog/ship-less-javascript-with-ai), y el analizador solo funciona con Turbopack, que es el bundler por defecto desde Next.js 16. Si tu `next build` todavía corre con `--webpack`, la skill no tiene grafo que leer.

Mi proyecto estaba en 16.3.4, así que lo primero fue actualizar `next`, `eslint-config-next` y `@next/third-parties` a 16.4.6. El typecheck y los 222 tests pasaron sin tocar nada.

## Qué hace next analyze

`next analyze` es el comando que alimenta a la skill. Construye la app con Turbopack y guarda el análisis de los bundles sin producir un build desplegable. Sin flags abre una interfaz web en el puerto 4000; con `--output` solo escribe los archivos a disco, que es lo que usa el agente.

Las dos opciones que importan para medir un cambio:

```bash
# Captura con nombre, para poder comparar después
pnpm exec next analyze --output --snapshot 'audit-before'

# Exporta ese snapshot como JSON Lines, sin volver a construir
pnpm exec next analyze export --snapshot 'audit-before' | gzip > before.jsonl.gz
```

El export es un registro JSON por línea: módulos, rutas, archivos de salida y los grupos de carga que los conectan. El esquema viene dentro del paquete (`next/analyze/graph-v1.schema.json`), y la skill le pide al agente leerlo antes de interpretar nada. Así cada cifra del reporte sale de un registro concreto.

Si prefieres mirarlo tú, la interfaz web trae una portada con las rutas cliente más pesadas, una tabla por ruta ordenable por tamaño, snapshots que se pueden comparar y un filtro que deja solo el código que carga de forma síncrona en el render inicial.

## Lo que encontró en mi sitio

La auditoría la corrió Claude Code con la skill, sobre la app entera: 70 rutas, de las cuales 41 cargan JavaScript de cliente. La métrica son los bytes comprimidos que el build atribuye a los archivos que se cargan al abrir cada ruta.

Cada ruta carga unos 248 KB comprimidos de JS y CSS inicial. Unos 180 KB de eso son framework: Next, React DOM, el router y el runtime de Turbopack. Eso no se toca.

Lo que es mío y viaja en todas las rutas:

| Qué | KB | Por qué está |
| --- | ---: | --- |
| Radix Dialog | 15,1 | el menú móvil (`Sheet`) y el buscador (`Dialog`) |
| `app/globals.css` | 14,3 | CSS global |
| Navbar, menú móvil, buscador, banner de cookies | 11,6 | el chrome del layout |
| `tailwind-merge` y `clsx` | 8,4 | `cn()` en los componentes de Radix |
| `@next/third-parties` | 5,3 | Google Analytics y Tag Manager |
| `@vercel/analytics` y `speed-insights` | 2,8 | métricas |

No había paquetes duplicados ni código de servidor filtrado al cliente: el sitio no tiene Server Actions. Lo que ya cargaba diferido (la animación ASCII de la portada, por ejemplo) seguía diferido.

Encontró tres candidatos:

1. **El buscador viajaba en la carga inicial de todas las rutas.** Un comentario en `Navbar.tsx` decía que el módulo "no existe" hasta que buscas. Era falso: se importaba de forma estática. Lo único que esperaba era el montaje y el fetch del índice.
2. **Radix y `tailwind-merge`, unos 26 KB por ruta**, que solo salen si también se difiere el menú móvil.
3. **El barrel de `@next/third-parties/google` arrastra código de YouTube y Google Maps**, unos 2,3 KB que no uso. Quitarlos implica reemplazar los componentes de GA y GTM por `next/script` propio.

## El cambio que acepté: 3 KB por ruta

Del primer candidato salió el único cambio que hice: cargar el buscador con `next/dynamic` en vez del import estático.

```tsx
import dynamic from "next/dynamic";

const SearchDialog = dynamic(() => import("./SearchDialog"));
```

Con un snapshot nuevo (`audit-after-searchdialog-dynamic`) comparado contra el de antes, 38 de las 41 rutas con JS de cliente bajaron 3,0 KB. La portada pasó de 248,7 a 245,7 KB. El buscador quedó como un chunk aparte de 3,1 KB, que se descarga la primera vez que abres el buscador. Ninguna ruta empeoró.

Radix se quedó en la carga inicial. El agente revisó todos los caminos del grafo hacia esos módulos y el menú móvil seguía importándolo, así que diferir solo el buscador no lo sacaba. Ese es el detalle que el post de Vercel ilustra con un `lazy()`: si **otro** módulo del mismo bundle importa el componente de forma estática, el `import()` diferido no ahorra nada.

## Por qué no apliqué los 26 KB

Los 26 KB de Radix y `tailwind-merge` existen, pero sacarlos cambia el comportamiento. Habría que pintar el botón del menú sin Radix y cargar el `Sheet` con el primer toque, y ese primer toque tendría una espera. También habría que cuidar la animación, el foco y el estado del ícono.

Hay una trampa más fina: un comentario de `MobileMenu.tsx` depende de que `twMerge` resuelva una clase `data-[side=top]:top-18` contra un `top-0`. Quitar `cn()` del `Sheet` cambia cómo se resuelven las clases, y el build no avisaría: el error aparecería como un menú mal posicionado.

Para 26 KB comprimidos en un sitio estático, no me compensa. La skill tampoco empujó: lo dejó como candidato con su riesgo escrito y pidió aprobación explícita, que es lo que dice su `SKILL.md` para cualquier cambio que toque comportamiento visible o timing.

## Vercel recortó dos megabytes, yo 3 KB

Las cifras de Vercel son reales, y el post las detalla caso por caso. [En v0](https://nextjs.org/blog/ship-less-javascript-with-ai), un editor de código experimental cargaba en casi todas las páginas, incluso para usuarios fuera del experimento: 150 KB. Un registro centralizado de diálogos cargaba los pesados de entrada: de 40 a 650 KB según la página. En vercel.com, el renderizado de markdown, el resaltado de sintaxis y los gráficos del panel de Vercel Agent viajaban aunque el panel estuviera cerrado: 255 KB en el dashboard.

El patrón de esos casos es el mismo: una feature grande y opcional, importada desde un lugar compartido. Un dashboard con años de features encima produce eso todo el tiempo. Un blog estático con un buscador y un menú, casi nunca.

La skill no inventa grasa donde no la hay. En mi caso confirmó que unos 180 de los 248 KB que carga cada ruta son framework, encontró un comentario mentiroso y un ahorro de 3 KB. Eso también es un resultado: ya sé dónde no tengo que buscar.

## Lo que la auditoría no cubrió

Dos límites del reporte, que cambian cómo leer las cifras:

- **No corrió el algoritmo de comunidades.** El agente agrupó los módulos por paquete a mano, porque con unos 60 KB de código propio en el cliente los grupos coincidían con los chunks que ya emite el build. En una app grande ese atajo no vale, y el paso de Louvain y corte mínimo es justamente lo que encontró los casos de Vercel.
- **Las cifras son del build, no del navegador.** Son bytes comprimidos atribuidos a cada ruta. Cuántos milisegundos ahorran y cuánto se transfiere de verdad hay que medirlo aparte. El propio post de Vercel avisa que un chunk de `next/dynamic` puede terminar en la carga inicial según el estado del render, y pide probar la app.

## Cuándo correr next-bundle-optimizer

Córrela si tu app tiene features pesadas que no todo el mundo abre: un editor, un panel de IA, gráficos, un visor de trazas, diálogos que se registran en un solo lugar. Ahí el corte mínimo encuentra imports que una persona no ve, porque el problema está en la cadena de imports que lleva hasta el componente.

En un sitio de contenido estático, córrela una vez para saber cuánto es framework y cuánto es tuyo, y guarda el snapshot. Sirve como línea base para la próxima dependencia que agregues.

Y empieza siempre en modo audit. El `fix` mide antes y después, pero la decisión de cambiar el comportamiento sigue siendo tuya.

Si te interesa el resto del ecosistema de skills, tengo [qué son las skills de Claude Code y cómo crearlas](/post/skills-claude-code), y de Vercel, [fx, su agente de código escrito en Zig](/post/fx-vercel-agente-codigo-zig).

## Preguntas frecuentes

### ¿Qué es next-bundle-optimizer?

Una skill oficial de Next.js para agentes de código. Usa el grafo de módulos que genera `next analyze` con Turbopack para encontrar JavaScript que se carga antes de hacer falta, código duplicado o imports que podrían diferirse, y propone cambios medidos con snapshots de antes y después.

### ¿Cómo instalo next-bundle-optimizer?

Con `npx skills add vercel/next.js --skill next-bundle-optimizer` en la raíz del proyecto. Después se invoca con `/next-bundle-optimizer` para auditar o `/next-bundle-optimizer fix` para aplicar cambios.

### ¿Qué versión de Next.js necesita?

El anuncio de Vercel pide Next.js 16.4. Además, el analizador requiere Turbopack, que es el bundler por defecto desde Next.js 16; con webpack no hay grafo que analizar.

### ¿next-bundle-optimizer cambia mi código sin preguntar?

No. Por defecto solo audita y reporta candidatos, sin tocar el código, las dependencias ni el lockfile. El modo `fix` hay que pedirlo, y aun así la skill pide aprobación antes de cambiar comportamiento visible o timing.

### ¿Qué es next analyze?

El comando de Next.js que construye la app con Turbopack y guarda el análisis de los bundles. Sin opciones abre una interfaz web; con `--output` y `--snapshot` guarda una captura con nombre, y `next analyze export` la exporta como JSON Lines para compararla o procesarla.

### ¿Cuánto JavaScript se puede ahorrar?

Depende de la app. Vercel reporta casi dos megabytes entre v0 y vercel.com, con páginas que ahorraron cientos de kilobytes. En este blog, un sitio de contenido estático, el ahorro fue de 3 KB por ruta, porque unos 180 de los 248 KB iniciales son framework.

## Fuentes

- [Ship less JavaScript in Next.js with your AI agent](https://nextjs.org/blog/ship-less-javascript-with-ai), Will Binns-Smith, blog de Next.js, 28 de octubre de 2026 (instalación, requisitos y los casos de v0 y vercel.com).
- [`skills/next-bundle-optimizer/SKILL.md`](https://github.com/vercel/next.js/blob/canary/skills/next-bundle-optimizer/SKILL.md), en el repositorio de Next.js (modos audit y fix, pasos del proceso).
- [next en npm](https://www.npmjs.com/package/next/v/16.4.0) (fecha de publicación de la 16.4.0).

---

## Sitemap

Índice completo del sitio: [/sitemap.md](https://www.angelcruz.dev/sitemap.md)

Canónico HTML: [https://www.angelcruz.dev/post/next-bundle-optimizer-skill-vercel](https://www.angelcruz.dev/post/next-bundle-optimizer-skill-vercel)
