Cet agent IA traque le JavaScript inutile dans vos pages Next.js
Next.js 16.4 embarque un agent qui remonte les imports pour trouver le code qui se charge sans raison. Voici le bug qu'il est fait pour attraper.

Un développeur enveloppe un composant lourd dans lazy(), le réflexe React classique pour dire au navigateur « ne charge ça que si c’est vraiment nécessaire ». La compilation passe, le code a l’air correct, et pourtant le composant se charge à chaque visite de chaque page, sans exception. Rien dans le code source ne semble cassé. Ce genre de bug peut survivre des années à la relecture de code, et c’est exactement le point de départ pour comprendre ce qu’un agent IA peut réellement faire contre le poids excessif du JavaScript, par opposition à ce qu’on en raconte.
Next.js, le framework React maintenu par Vercel, a décrit ce piège précis dans un billet publié le 28 octobre 2026, signé par Will Binns-Smith, de l’équipe Next.js. Le billet présente une nouveauté de Next.js 16.4, mais l’histoire qui dure vraiment, c’est ce qu’il révèle sur l’origine de ce type de bug, et sur la raison pour laquelle le simple fait de lire le code ne suffit pas à le voir.
Le piège du lazy() qui trompe même un lecteur attentif
Un bundler (empaqueteur) est l’outil de build qui prend tous les fichiers JavaScript séparés d’un projet web et les compresse en un ou plusieurs fichiers que le navigateur télécharge réellement, appelés bundles. Si on tient à garder ces bundles légers, c’est une question de vitesse : chaque kilo-octet supplémentaire, c’est du code que le navigateur du visiteur doit télécharger, analyser et exécuter avant que la page ne devienne réactive.
lazy() est la façon dont React indique au bundler de découper un composant dans son propre morceau de code et de n’aller le chercher qu’au moment où il s’affiche vraiment, au lieu de l’empaqueter avec tout le reste dès le départ. C’est une technique connue, sans mystère, que la plupart des développeurs utilisent correctement la plupart du temps.
Voici la partie facile à manquer. Selon le billet de l’équipe Next.js, un composant enveloppé dans lazy() se charge quand même tout de suite si un autre module du même bundle importe directement cette même cible, de façon classique. L’appel à lazy() ne contrôle que cette référence précise. Il n’a aucune prise sur un second import ordinaire, posé ailleurs dans le code, qui récupère exactement le même composant de la manière habituelle. Le bundler se retrouve avec deux instructions contradictoires pour le même bout de code — l’une qui dit d’attendre, l’autre de charger tout de suite — et c’est la seconde qui gagne. Le composant part donc à chaque chargement de page, en silence, alors même que le code source donne l’impression d’avoir été géré correctement.
Repérer ce second import suppose de remonter le vrai graphe de modules, la carte complète de qui importe quoi, potentiellement sur des centaines de fichiers. Relire le fichier du composant lui-même ne révèle rien : le problème se cache dans un tout autre fichier, écrit peut-être des mois plus tôt par quelqu’un d’autre, pour une raison qui n’a rien à voir.

Ce que Vercel a construit pour suivre ce graphe automatiquement
C’est précisément ce problème que vise la nouveauté de Next.js 16.4. Elle s’appelle next-bundle-optimizer, et il vaut la peine d’être précis sur ce qu’elle est vraiment, car le cadrage compte plus que le nom ne le laisse croire.
Ce n’est ni un produit à part, ni un nouveau modèle d’IA, ni un service hébergé. C’est ce que Vercel appelle une agent skill (compétence d’agent) : un petit script, qu’on installe avec une commande du type npx skills add vercel/next.js --skill next-bundle-optimizer, qui donne des instructions et un accès aux données à un agent IA de codage déjà existant, comme Claude Code ou un autre outil conçu selon le même standard « skills ». La compétence elle-même ne réfléchit pas. Elle tend à l’agent une carte structurée du graphe de modules du projet, exportée en JSON par une commande appelée next analyze export, et lui explique comment l’interroger.
Cet export n’existe que grâce à Turbopack, le bundler écrit en Rust devenu le choix par défaut dans Next.js depuis la version 16 (Webpack, l’ancien bundler, n’est pas pris en charge ici). Turbopack suit déjà, en interne, le graphe complet des imports pour faire son travail ; cette fonctionnalité se contente d’exposer ces données pour qu’un agent puisse les lire.
Une fois le graphe en main, la méthode décrite dans le billet n’a rien d’inédit : c’est une technique connue de la théorie des graphes. L’agent cherche d’abord des groupes de modules via la méthode de Louvain, un algorithme qui repère les clusters de modules qui s’importent beaucoup entre eux — le genre de groupe soudé qui finit souvent empaqueté ensemble, voulu ou non. Puis, à l’intérieur de ces clusters, il calcule une coupe minimale : le plus petit ensemble possible de connexions d’import qui, si on les supprimait, séparerait un morceau de code rarement utilisé du morceau qui se charge à chaque visite. C’est exactement à cet endroit-là qu’une frontière lazy(), ou une correction équivalente, doit être posée.
Au-delà du piège du lazy(), le billet de l’équipe Next.js explique que la même compétence peut aussi signaler du code qui devrait passer en React Server Component (du code qui tourne sur le serveur et n’a jamais besoin d’atterrir dans le navigateur), des copies en double de la même dépendance empaquetées plusieurs fois, et du code mal tree-shaké — autrement dit du code mort que le bundler n’a pas réussi à retirer, même si rien dans l’application ne l’utilise réellement.
Par défaut, lancer la compétence produit un rapport et une correction proposée, rien de plus. Une commande suivante, /next-bundle-optimizer fix, applique le changement, relance l’analyse, et compare les instantanés avant/après pour vérifier que la correction a vraiment marché. Selon le billet, l’agent peut ouvrir une pull request pour chaque correction prise isolément, si bien qu’un humain reste dans la boucle pour relire et valider avant la mise en ligne.
Les chiffres que Vercel rapporte sur ses propres produits
Le billet de Vercel donne des chiffres issus de l’application de cette approche sur deux de ses propres produits, v0 (la plateforme de Vercel pour construire des applications par IA) et vercel.com (le tableau de bord de l’entreprise). Ce sont des chiffres auto-déclarés par Vercel, pas des mesures auditées de façon indépendante ; mieux vaut les lire comme une illustration de l’ampleur possible des économies que comme un repère universel.
Sur v0, l’équipe a trouvé un composant expérimental d’éditeur de code qui se chargeait sur presque toutes les pages, alors que la plupart des visiteurs n’y touchaient jamais ; corriger ça a économisé environ 150 Ko sur la plupart des pages. Un registre centralisé de fenêtres de dialogue chargeait d’avance plusieurs boîtes de dialogue lourdes dont il n’avait pas encore besoin, pour une économie allant de 40 à 650 Ko selon la page. Un composant de visualisation de traces d’exécution, accessible depuis presque toutes les routes mais rarement ouvert, représentait encore 7 à 61 Ko selon la page.
Sur vercel.com, le rendu markdown, la coloration syntaxique du code et le traçage de graphiques construits pour une fonctionnalité appelée « Vercel Agent » se chargeaient même quand le panneau de cette fonctionnalité était fermé, pour une économie de 255 Ko sur la page du tableau de bord une fois corrigé. Une bibliothèque d’analyse de dates en langage naturel se chargeait avant toute interaction avec l’assistant, pour 55 Ko en moyenne. Un utilitaire partagé d’analyse d’URL entraînait aussi, sans le vouloir, l’intégralité du moteur de requêtes d’observabilité de l’entreprise — une correction qui valait 125 Ko sur la page des déploiements.
Next.js — le billet du blog Vercel qui annonce next-bundle-optimizer et ses économies de taille de bundle.
Mis bout à bout, Vercel annonce un total cumulé sur les deux produits proche de 2 Mo de JavaScript compressé retiré. Aucun de ce code n’était mort : tout faisait bien quelque chose, quelque part dans l’application. Il était simplement câblé dans la mauvaise case, se chargeant pour tous les visiteurs au lieu des seuls qui en avaient besoin.
La même version a aussi amélioré le volet pensé pour les humains de cette histoire. Le Bundle Analyzer, l’outil visuel pour inspecter ce qu’une application Next.js envoie en JavaScript, apparu dès Next.js 16.1, a gagné une page d’accueil qui classe les routes les plus lourdes du projet, la possibilité de comparer deux instantanés d’analyse côte à côte, et un filtre qui distingue le code synchrone (celui qui bloque l’interactivité de la page) du code asynchrone (celui qui peut se charger en arrière-plan). Cet outil et la nouvelle compétence d’agent lisent exactement les mêmes données sous-jacentes. L’un est fait pour une personne qui parcourt un graphique, l’autre pour un agent qui parcourt le graphe de façon automatisée.
Next.js — la documentation du Bundle Analyzer, l’outil pensé pour les humains qui lit le même graphe de modules que la compétence d’agent.
L’agent trouve-t-il quelque chose qu’un développeur avec le graphique n’aurait pas vu
C’est la question qui mérite qu’on s’y arrête, parce que la réponse honnête, dans le billet même de Vercel, est plus modeste que ce que le nom de la fonctionnalité suggère. L’agent ne détecte rien que le graphique du Bundle Analyzer ne pourrait, en théorie, révéler aussi. Les deux outils lisent le même graphe de modules que Turbopack construit déjà. Le graphique montre à un développeur où se trouve le poids ; le travail de l’agent, c’est de remonter chaque chaîne d’imports à l’intérieur de ce poids et de calculer le point de coupe précis où placer la correction.
Un développeur qui regarde le Bundle Analyzer peut très bien repérer qu’une route est trop lourde. Ce qu’il ne peut en revanche pas faire, réalistement, dans une journée de travail normale, c’est remonter à la main cinquante ou cent instructions d’import à travers une grosse base de code pour trouver l’unique import égaré qui annule un lazy() posé trois dossiers plus loin. C’est un travail mécanique, épuisant, facile à manquer — exactement le genre de tâche qui gagne à être automatisée plutôt que traitée au jugé. La compétence ne remplace pas le jugement sur ce que l’application doit faire. Elle remplace la partie fastidieuse qui consiste à vérifier comment le code se comporte vraiment.
Cette distinction est la vraie leçon qui se cache sous l’annonce produit. Les agents de codage servent à deux types de travail très différents. Le premier, c’est écrire de nouvelles fonctionnalités, ce qui suppose des choix de conception, de nommage, d’intention, et où la sortie de l’agent demande toujours un vrai regard critique. Le second, c’est trouver et corriger une catégorie connue d’inefficacité existante par une analyse mécanique et reproductible, plus proche de ce que fait un linter ou un outil d’analyse statique, simplement avec assez de contexte pour aussi proposer et tester la correction. La compétence de traçage de bundle appartient clairement à cette seconde catégorie. C’est un niveau de confiance très différent de celui qu’on accorde à un agent censé écrire une fonctionnalité à partir d’un simple prompt, et ça vaut la peine de s’en souvenir au moment de décider jusqu’où s’appuyer sur l’un ou l’autre.
FAQ
Qu’est-ce que next-bundle-optimizer ?
next-bundle-optimizer est une compétence d’agent livrée avec Next.js 16.4, pas un outil autonome. Elle donne à un agent IA de codage, comme Claude Code, un accès structuré au graphe de modules d’un projet Next.js, pour qu’il puisse remonter les chaînes d’imports et proposer où découper le code qui se charge plus tôt que nécessaire.
Cette fonctionnalité marche-t-elle avec Webpack au lieu de Turbopack ?
Non. La compétence dépend des données exportées par Turbopack, le bundler par défaut dans Next.js depuis la version 16, et ne fonctionne pas avec Webpack. Un projet doit tourner sous Turbopack pour que l’export du graphe de modules que la compétence lit existe tout simplement.
Pourquoi un composant en lazy() se charge-t-il parfois tout de suite ?
Un composant enveloppé dans lazy() se charge quand même immédiatement si un autre fichier de la même partie de l’application importe ce même composant directement, en dehors de l’appel lazy(). Le bundler suit les deux instructions, et c’est l’import direct qui l’emporte, si bien que le chargement différé n’a en réalité jamais lieu.
Vercel a-t-il vérifié ces économies de taille de bundle de façon indépendante ?
Non. Les chiffres d’économies, y compris le total proche de 2 Mo sur v0 et vercel.com, viennent du propre billet de blog de Vercel sur ses propres produits, pas d’un audit indépendant. Ils illustrent l’ampleur de ce type de bug plutôt que de servir de repère vérifié pour toute l’industrie.
Est-ce la même chose que le Bundle Analyzer de Next.js ?
Non. Le Bundle Analyzer est un outil visuel destiné aux humains pour inspecter ce qu’un projet envoie en JavaScript, introduit dans Next.js 16.1 et enrichi dans la 16.4. La compétence d’agent lit le même graphe de modules sous-jacent, mais elle est conçue pour qu’un agent IA l’interroge et agisse dessus de façon automatisée, pas pour qu’une personne la parcoure.