Le manifeste sans build : livrer sans bundler
Ce qui suit n’est pas un plaidoyer pour que vous abandonniez vos outils de build. C’est une mesure de ce qui se passe quand vous le faites.
blakecrosley.com fonctionne avec FastAPI + Jinja2 + HTMX + Alpine.js + CSS pur. Pas de webpack. Pas de Vite. Pas de Rollup. Pas de compilateur TypeScript. Pas de Babel. Pas de PostCSS. Pas de Tailwind. Pas de package.json. Pas de node_modules/. Le site sert 37 articles de blog avec 20 composants JavaScript interactifs, 20 guides, des traductions en dix langues, et obtient 100/100/100/100 sur Lighthouse. Vous pouvez vérifier le score Lighthouse vous-même : lancez PageSpeed Insights sur n’importe quelle page.11
En bref
La communauté HTMX ne manque pas de plaidoyers. Ce qui lui manque, ce sont des preuves. Les chiffres présentés ici proviennent d’un site de production au contenu substantiel, doté de fonctionnalités interactives et d’une internationalisation, le tout sans le moindre outil de build. Les compromis sont exposés honnêtement, et la conclusion est ciblée : pour les sites axés sur le contenu avec un développeur solo ou une petite équipe, les outils de build résolvent des problèmes que vous n’avez pas tout en créant des problèmes que vous avez bel et bien. Pour les grandes équipes avec des bibliothèques de composants partagées et des paquets de design system, les outils de build méritent leur complexité. La frontière est plus nette que le discours ne le laisse entendre.
La stack
Backend: FastAPI + Jinja2 (server-rendered HTML)
Frontend: HTMX + Alpine.js + Bootstrap 5 (CDN)
Styles: Plain CSS with custom properties
JavaScript: Vanilla JS, IIFE-scoped per component
Deployment: Railway (git push → live)
CDN: Cloudflare (caching, Workers, D1)
Pas de transpilation. Pas de tree shaking. Pas de hot module replacement. Pas de source maps. Le JavaScript que vous écrivez est le JavaScript qui est livré.
Les chiffres
Voici les métriques réelles, pas des estimations :
| Métrique | blakecrosley.com | Projet Next.js typique (estimation de l’auteur)1 |
|---|---|---|
| Dépendances | 15 paquets Python | 311 paquets npm (vérifié : npx create-next-app@latest, févr. 2026)1 |
| Fichiers de configuration de build | 0 | 5-8 (next.config, tsconfig, postcss, tailwind, eslint, babel, etc.) |
Taille de node_modules/ |
N’existe pas | 187 Mo de base (vérifié), 250-400 Mo avec ajouts1 |
| Temps d’installation | pip install -r requirements.txt : 8 secondes |
npm install : 30-90 secondes |
| Étape de build | Aucune | next build : 15-60 secondes |
| Pipeline de déploiement | git push → en ligne en ~40 secondes |
git push → install → build → deploy : 2-5 minutes |
| Fichiers CSS | 17 fichiers, 10 846 lignes (CSS pur) | Généré depuis Tailwind/Sass, résultat variable |
| Fichiers JS | 33 fichiers, 8 819 lignes (lisibles par un humain) | Bundlé, minifié, découpé en chunks : illisible en production |
| Performance Lighthouse | 100 | 70-90 sans optimisation explicite (selon la propre documentation de performance de Vercel)13 |
Les 15 paquets Python incluent FastAPI, Jinja2, Pydantic et 12 autres. Aucun n’est un outil de build. Aucun n’est un compilateur. Aucun n’est un bundler.2
Ce à quoi vous renoncez
L’honnêteté exige de lister les coûts réels. Ils sont bien réels.
Pas de TypeScript. Chaque fichier .js de ce projet est du JavaScript vanilla. Ce sont les tests et l’analyse de Claude Code qui détectent les erreurs de type, pas un compilateur. L’approche fonctionne pour un développeur solo. Elle ne fonctionnerait pas pour une équipe de 10 personnes partageant des interfaces de composants entre modules.
Pas de Hot Module Replacement. Quand je modifie un fichier CSS, je rafraîchis le navigateur manuellement. Le hx-boost de HTMX rend la navigation assez rapide pour que les rafraîchissements complets restent tolérables, car il ne récupère que le contenu du body via AJAX et le remplace sans recharger toute la page. Sur un projet où j’itère sur des détails visuels toutes les 30 secondes, le HMR ferait gagner un temps appréciable.
Pas de Tree Shaking. Chaque octet de JavaScript que j’écris part vers le navigateur. Je ne peux pas importer une seule fonction d’une bibliothèque utilitaire sans livrer le fichier entier. Le tree shaking (l’élimination du code mort par le bundler, qui suit les chemins d’import et supprime les fonctions qu’aucun module ne référence) exige par définition une étape de build. La contrainte impose la discipline : des fichiers petits et ciblés plutôt que de gros modules utilitaires. Les 20 composants interactifs font en moyenne 130 à 450 lignes chacun parce qu’ils doivent être autonomes.3
Pas de bibliothèque de composants npm. Pas de Radix, pas de shadcn/ui, pas de Headless UI. Chaque élément interactif (la simulation de boids, le visualiseur de code de Hamming, le simulateur de consensus) est construit à la main. L’approche n’est viable que parce que les composants interactifs servent des objectifs pédagogiques précis, et non des patterns d’interface génériques.
Pas de tokens de design system npm. Mon design system vit entièrement dans des propriétés personnalisées CSS. Je ne peux pas l’importer comme paquet dans un autre projet. Pour un système mono-site, la contrainte est acceptable. Pour une organisation multi-produits, elle ne l’est pas.
Les cinq compromis sont acceptables pour un site axé sur le contenu avec un seul développeur. Ils seraient inacceptables pour un produit SaaS doté d’une équipe d’ingénierie de 15 personnes.
Ce que vous gagnez
Zéro échec de build. Le pipeline de déploiement, c’est git push. Aucun npm install ne peut échouer à cause d’un conflit de peer dependency. Aucun next build ne peut échouer à cause d’une erreur TypeScript dans un fichier que je n’ai pas touché. Aucune PR Dependabot ne met à jour une dépendance transitive en cassant le build.4
Déboguer avec « Afficher le code source ». Le JavaScript qui s’exécute dans le navigateur est le JavaScript que j’ai écrit. Pas besoin de source maps. Pas de correspondance entre la sortie compilée et le code source d’origine. Quand un bug apparaît en production, je lis directement le fichier déployé.
Démarrage local instantané. uvicorn app.main:app --reload démarre en moins de 2 secondes. Pas de npm run dev qui installe, compile et bundle avant d’afficher une page.
Une cascade de requêtes concrète. Une première visite sur un article de blog charge : un document HTML (~15 Ko compressé en gzip), un fichier CSS (~8 Ko), un fichier CSS propre à la page (~2 Ko), HTMX depuis un CDN (~14 Ko, en cache), Alpine.js depuis un CDN (~14 Ko, en cache) et le composant JS interactif de la page (~4-8 Ko). Transfert total : 45-60 Ko lors de la première visite, 15-25 Ko avec le cache. Pas de découpage en bundles, pas de négociation de chunks, pas de résolution de modules à l’exécution. Le navigateur demande exactement ce dont la page a besoin, et rien d’autre.
Zéro bruit Dependabot. Sans package-lock.json, pas de PR hebdomadaires mettant à jour semver, ansi-regex ou glob-parent : des paquets que je n’ai jamais importés directement mais qui vivent trois couches plus bas dans mon arbre de dépendances.
Un frontend pérenne. Le code côté client fonctionnera encore dans 10 ans. Le HTML est du HTML. Le CSS est du CSS. Le JavaScript est du JavaScript. Il n’y a pas de migration de Webpack 4 vers 5, pas de dépréciation de Create React App, pas de migration vers le Next.js App Router. La plateforme est le standard.5 Les dépendances côté serveur (FastAPI, Python, Railway) exigent toujours une gestion des versions et des mises à jour occasionnelles : l’approche sans build élimine le renouvellement incessant de la chaîne d’outils frontend, pas la maintenance du backend.
HTMX comme architecture
Le discours autour de HTMX se concentre sur la syntaxe : hx-get, hx-swap, hx-target. C’est le mauvais angle. L’idée architecturale, c’est que le HTML rendu côté serveur est l’API.
Dans une SPA traditionnelle :
Browser → fetch('/api/users') → JSON → React renders HTML → DOM update
Avec HTMX :
Browser → GET /users (hx-get) → Server renders HTML fragment → DOM swap
Le serveur renvoie la représentation finale. Pas de gestion d’état côté client, pas de sérialisation ni de désérialisation, pas d’hydratation. Le template Jinja2 est le composant. L’endpoint FastAPI est l’API. Une seule couche, pas trois.6
Les implications architecturales s’enchaînent. Trois suppressions, chacune éliminant une catégorie entière de problèmes plutôt qu’un bug isolé.
Pas de frontière JSON. Les incohérences de forme des réponses, les ambiguïtés entre null et undefined et les incohérences de sérialisation des dates disparaissent. TypeScript et Zod existent pour prévenir ces bugs. HTMX élimine la catégorie entière en renvoyant du HTML au lieu du JSON.
Pas de gestion d’état côté client. Garder l’état du serveur et celui du client cohérents est la partie la plus difficile du développement d’une SPA. HTMX supprime le problème en n’ayant qu’une seule source de vérité : le serveur.
Pas d’hydratation. La « vallée de l’étrange », où la page affiche le HTML du serveur puis clignote pendant que le framework JavaScript la rend de nouveau côté client, n’existe pas. Le HTML du serveur est la sortie finale.
Une comparaison concrète montre la différence. Voici un champ de recherche à résultats instantanés, construit de deux façons :
Avec React + outils de build (JSX, nécessite une transpilation) :
// SearchBox.jsx — requires Babel, bundler, npm install
import { useState, useEffect } from 'react';
export default function SearchBox() {
const [query, setQuery] = useState('');
const [results, setResults] = useState([]);
useEffect(() => {
if (!query) return setResults([]);
fetch(`/api/search?q=${query}`).then(r => r.json()).then(setResults);
}, [query]);
return (<div>
<input value={query} onChange={e => setQuery(e.target.value)} />
<ul>{results.map(r => <li key={r.id}>{r.title}</li>)}</ul>
</div>);
}
Avec HTMX + rendu côté serveur (HTML pur, sans étape de build) :
<!-- search.html — ships as-is, no transpilation -->
<input type="search" name="q"
hx-get="/search" hx-trigger="keyup changed delay:300ms"
hx-target="#results" />
<ul id="results"></ul>
# server — returns rendered HTML, not JSON
@router.get("/search")
async def search(q: str = ""):
results = await db.search(q)
return templates.TemplateResponse("partials/results.html",
{"results": results})
La version HTMX n’a ni état client, ni frontière de sérialisation, ni étape de build. Le serveur renvoie le HTML final. Le navigateur l’insère. Toute l’interaction tient en huit lignes de template et cinq lignes de Python.
Ce pattern correspond directement au principe d’ingénierie par accumulation : chaque élément d’infrastructure fait exactement une chose, et les éléments se composent sans interférence. Un template rend du HTML. Une route le renvoie. HTMX l’insère dans le DOM. Aucune étape de build ne coordonne ces éléments, parce qu’aucune coordination n’est nécessaire.
Un exemple plus complexe : formulaire en plusieurs étapes avec validation
La recherche à résultats instantanés est la démo canonique de HTMX. Un formulaire en plusieurs étapes montre le pattern avec une complexité de production (validation côté serveur, progression conditionnelle entre les étapes et état conservé d’une requête à l’autre) sans gestion d’état côté client :
<!-- step1.html — first form step -->
<form id="signup-form" hx-post="/signup/step1" hx-target="#signup-form" hx-swap="outerHTML">
<input type="email" name="email" required />
<button type="submit">Next</button>
</form>
# server — validates step 1, returns step 2 or errors
@router.post("/signup/step1")
async def signup_step1(request: Request, email: str = Form(...)):
if not validate_email(email):
return templates.TemplateResponse("partials/step1.html",
{"error": "Invalid email format", "email": email})
# Store progress server-side (session, DB, or signed cookie)
request.session["signup_email"] = email
return templates.TemplateResponse("partials/step2.html",
{"email": email})
<!-- step2.html — second step, rendered by server only after step 1 validates -->
<form id="signup-form" hx-post="/signup/step2" hx-target="#signup-form" hx-swap="outerHTML">
<p>Email: {{ email }}</p>
<input type="text" name="name" required />
<input type="password" name="password" minlength="8" required />
<button type="submit">Create Account</button>
</form>
Le serveur détient l’état du formulaire. L’étape 2 ne s’affiche qu’une fois l’étape 1 validée côté serveur : pas de rendu conditionnel côté client, pas de bibliothèque d’état de formulaire, pas de useReducer. Les erreurs de validation remplacent l’étape en cours par la même étape accompagnée des messages d’erreur. Tout le parcours en plusieurs étapes fonctionne sans la moindre ligne de JavaScript côté client. Dans un équivalent React, le même parcours exigerait un useState pour chaque champ, un compteur d’étapes, une logique de rendu conditionnel, une validation côté client (qui duplique celle du serveur) et une frontière de sérialisation d’API. La version HTMX élimine ces cinq préoccupations en gardant l’état là où vit déjà la logique de validation : sur le serveur.
Le CSS pur suffit
Mon design system utilise 10 tokens de couleur, 13 paliers d’échelle typographique et huit valeurs d’espacement, le tout en propriétés personnalisées CSS :
:root {
--color-bg-dark: #000000;
--color-text-primary: #ffffff;
--color-text-secondary: rgba(255,255,255,0.65);
--spacing-sm: 1rem;
--spacing-md: 1.5rem;
--font-size-lg: 1.25rem;
}
Pas d’étape de compilation Sass. Pas de configuration Tailwind générant des utilitaires. Pas de plugins PostCSS transformant une syntaxe personnalisée. Le navigateur lit ces valeurs directement. Les propriétés personnalisées CSS offrent des capacités qui manquent aux variables des préprocesseurs : elles se propagent en cascade dans le DOM, héritent des éléments parents et peuvent être redéfinies dans des media queries ou limitées à des composants à l’exécution. Les variables Sass sont compilées en valeurs statiques puis disparaissent. Les propriétés personnalisées restent vivantes, si bien qu’un simple changement de thème ou un basculement en mode sombre modifie chaque valeur dérivée sans recompilation.7
L’esthétique beauté et brutalisme de ce site (blanc sur noir absolu avec quatre niveaux d’opacité) naît de la contrainte. Quand vous ne pouvez pas recourir à une palette de couleurs, la typographie porte la hiérarchie. Quand vous ne pouvez pas recourir aux ombres de composants, l’espace blanc crée la structure. La contrainte est le design.8
Le parcours du CLS
Le parcours Lighthouse a révélé un coût réel de l’absence de build : l’extraction du CSS critique a nécessité un script Python sur mesure. Dans un projet Next.js, le framework s’en charge automatiquement.
Le bug précis : une media query mobile redéfinissait une propriété personnalisée CSS (--gutter: 48px → --gutter: 24px). Le CSS critique incluait la valeur desktop mais pas la redéfinition mobile. Sur mobile, le hero s’affichait avec un padding de 48px, puis passait à 24px une fois la feuille de style complète chargée, ce qui produisait un CLS de 0,493.
La correction tenait en 12 lignes de Python qui extraient le CSS critique, redéfinitions des media queries comprises :
# critical_css.py — extract CSS rules matching critical selectors
# including @media overrides for mobile-first responsive values
import re
def extract_critical(css_text, selectors):
rules = []
for sel in selectors:
# Match both direct rules and media-wrapped rules
pattern = rf'{re.escape(sel)}\s*\{{[^}}]+\}}'
rules.extend(re.findall(pattern, css_text))
# Also extract @media blocks containing critical selectors
media_blocks = re.findall(r'@media[^{]+\{([^}]+\{[^}]+\}[\s]*)+\}', css_text)
for block in media_blocks:
if any(sel in block for sel in selectors):
rules.append(block)
return '\n'.join(rules)
L’investigation a pris trois heures. La correction elle-même a pris 20 minutes. Un outil de build aurait géré cela automatiquement.
Le bilan honnête : les outils de build automatisent des choses que vous pouvez faire à la main, mais la version manuelle coûte du temps de débogage quand elle casse. La question est de savoir si le coût de l’automatisation (complexité, dépendances, échecs de build, migrations à répétition) dépasse le coût manuel (des séances de débogage occasionnelles).
Pour ce site, le coût manuel a été inférieur. Trois ans, un bug de CLS, trois heures de débogage.10 L’alternative (maintenir un pipeline de build) aurait consommé davantage de temps cumulé en mises à jour de dépendances, changements cassants et maintenance de configuration.
Quand ne pas utiliser cette approche
L’approche sans build est inadaptée pour :
Les grandes équipes. La valeur de TypeScript augmente avec la taille de l’équipe.9 Quand 10 développeurs partagent des interfaces de composants, la vérification de types à la compilation prévient des bugs d’intégration que les tests à l’exécution détectent trop tard. Un développeur solo garde tout le système en tête. Une équipe ne le peut pas.
Les paquets de design system. Si plusieurs produits consomment votre design system, il doit devenir un paquet npm avec un versionnement approprié, du tree shaking et un pipeline de build. Des propriétés personnalisées CSS dans une seule feuille de style ne se composent pas d’un dépôt à l’autre.
Un état client complexe. Si votre application a un état côté client riche (interfaces en glisser-déposer, collaboration en temps réel, données offline-first), un framework comme React ou Svelte mérite sa complexité. HTMX remplace l’état client par des allers-retours avec le serveur, ce qui fonctionne jusqu’à ce que la latence compte.
Les bibliothèques de l’écosystème npm. Si vous avez besoin des primitives Radix, de Framer Motion ou de TanStack Query, vous avez besoin d’un pipeline de build. Les trois supposent un bundler. Les utiliser sans bundler va du pénible à l’impossible.
La frontière est plus simple que le discours ne le laisse entendre : si votre application consiste surtout en du contenu rendu par un serveur, les outils de build sont une surcharge. Si elle consiste surtout en de l’état géré par un client, les outils de build sont de l’infrastructure.
Cadre de décision : avez-vous besoin d’outils de build ?
Répondez à ces quatre questions :
-
Plus de cinq développeurs partagent-ils des interfaces JavaScript ? Si oui, la vérification de types de TypeScript à la compilation prévient des bugs d’intégration que les tests à l’exécution détectent trop tard. Ajoutez une étape de build.
-
Votre application gère-t-elle un état côté client complexe ? Si le glisser-déposer, la collaboration en temps réel ou les données offline-first sont des fonctionnalités centrales (et non de simples bonus), un framework comme React ou Svelte mérite sa complexité. Ajoutez une étape de build.
-
Plusieurs produits consomment-ils une bibliothèque de composants partagée ? Si oui, cette bibliothèque a besoin d’un packaging npm, d’un versionnement sémantique et de tree shaking. Ajoutez une étape de build.
-
Dépendez-vous de bibliothèques de l’écosystème npm qui supposent un bundler ? Si Radix, Framer Motion, TanStack Query ou des bibliothèques similaires sont au cœur du produit, un pipeline de build est obligatoire.
Si les quatre réponses sont « non », l’approche sans build est viable. Si une seule réponse est « oui », les outils de build résolvent un vrai problème que vous avez. L’erreur consiste à ajouter des outils de build alors que les quatre réponses sont « non » : vous résolvez des problèmes que vous n’avez pas tout en créant une charge de gestion des dépendances que vous aurez bel et bien.
Exercice : auditez votre projet actuel. Lancez du -sh node_modules/ (ou l’équivalent) et wc -l package-lock.json. Notez les deux nombres. Puis listez les trois fonctionnalités de votre pipeline de build qui servent directement vos utilisateurs (et non votre expérience de développeur). Si vous ne parvenez pas à en citer trois, le pipeline sert peut-être davantage la chaîne d’outils que le produit. Les nombres ne sont pas mauvais en soi : ils mesurent une complexité qui doit justifier sa place.
Points clés à retenir
Pour les développeurs solo et les petites équipes :
-
La preuve, c’est le site, pas l’argumentaire. blakecrosley.com sert 37 articles, 20 composants interactifs, 20 guides et dix langues avec zéro outil de build et des scores Lighthouse parfaits. Les chiffres sont vérifiables.
-
Le coût honnête du sans-build, c’est le débogage occasionnel. Le bug de CLS a demandé trois heures de correction. Un outil de build l’aurait géré automatiquement. Sur trois ans, le temps de débogage cumulé a été bien inférieur au temps de maintenance cumulé qu’un pipeline de build aurait exigé.
-
Les contraintes produisent le design. L’absence de couleurs a forcé la typographie à porter la hiérarchie. L’absence d’outils de build a imposé un JavaScript simple et autonome. Les meilleures contraintes sont celles que vous choisissez avant d’en avoir besoin.
Pour les responsables d’équipe qui évaluent des choix de stack :
-
Les outils de build résolvent des problèmes à l’échelle d’une équipe. TypeScript, le tree shaking et les bibliothèques de composants méritent leur complexité quand plusieurs développeurs partagent des interfaces. Un développeur solo qui construit des sites axés sur le contenu n’a pas ces problèmes.
-
La vraie contribution de HTMX est architecturale. Le HTML rendu côté serveur en guise d’API élimine la gestion d’état côté client, la sérialisation et l’hydratation. La syntaxe est secondaire par rapport à cette idée.
Questions fréquentes
HTMX est-il prêt pour la production dans de vraies applications web ?
Oui. HTMX est stable depuis 2020 et utilisé en production par des entreprises de nombreux secteurs. Carson Gross, son créateur, fait de la rétrocompatibilité un principe de conception central ; la documentation de HTMX l’indique explicitement : « htmx follows semantic versioning and will not break existing applications within a major version. »14 La bibliothèque elle-même pèse 14 Ko minifiée et compressée en gzip, n’a aucune dépendance et suit le versionnement sémantique. blakecrosley.com fait tourner HTMX en production depuis trois ans sans le moindre bug lié à HTMX : chaque problème rencontré venait de la logique applicative, pas de la bibliothèque.
Puis-je utiliser TypeScript sans étape de build ?
En partie. Les fichiers TypeScript peuvent être vérifiés avec tsc --noEmit sans générer de fichiers de sortie, ce qui fournit une vérification de types à la compilation à la manière d’un linter plutôt que d’un transpileur. Cependant, les navigateurs ne peuvent pas exécuter directement des fichiers .ts, si bien qu’une étape de build reste nécessaire pour servir du TypeScript au navigateur. L’alternative consiste à utiliser des annotations de type JSDoc dans des fichiers .js ordinaires, que TypeScript peut vérifier sans compilation. Cette approche apporte la sûreté des types pendant le développement tout en livrant du JavaScript standard.
Comment cette approche se compare-t-elle à Astro ou 11ty ?
Astro et 11ty occupent une position intermédiaire : ce sont des générateurs de sites statiques qui produisent du HTML pur avec peu ou pas de JavaScript côté client, mais ils exigent toujours une étape de build (Node.js, npm install, une commande de build). L’approche sans build supprime entièrement cette étape : le serveur rend le HTML à chaque requête. Le compromis : Astro et 11ty produisent des pages statiques plus rapides (aucun calcul côté serveur), tandis que FastAPI + HTMX gère nativement le contenu dynamique (données propres à chaque utilisateur, soumissions de formulaires, mises à jour en temps réel) sans couche d’API.
Une équipe de développement web peut-elle livrer sans outils de build ni npm ?
Cela dépend de ce que l’équipe construit. Pour des sites axés sur le contenu et des outils internes, des équipes de 2 à 5 personnes ont livré avec succès sans outils de build, à l’aide de HTML rendu côté serveur et de CSS pur. La contrainte qui se fait sentir en premier, ce sont les interfaces de composants partagées : sans TypeScript, deux développeurs peuvent diverger sur l’entrée attendue par une fonction sans que le compilateur ne le détecte. La limite pratique se situe autour de 5 à 8 développeurs travaillant sur du JavaScript partagé. Au-delà, TypeScript et une bibliothèque de composants méritent leur complexité.
Le coût des dépendances JavaScript n’est pas une observation propre à l’auteur. Potvin, R. et Levenberg, J. (2016), dans « Why Google Stores Billions of Lines of Code in a Single Repository », ont documenté les coûts organisationnels de la gestion des dépendances à grande échelle.12 À l’échelle d’un projet individuel, la profondeur des dépendances de l’écosystème npm produit exactement la charge de maintenance décrite ici : des dépendances transitives que le développeur n’a jamais choisies créent une pression de mise à jour qu’il doit gérer.
Cet article fait le lien entre les sections Design et Pratique d’ingénierie du blog. Les décisions de design apparaissent dans Beauté et Brutalisme, Design Systems pour Startups et Échelles typographiques. Les mesures d’ingénierie se trouvent dans Score Lighthouse parfait et Ingénierie par accumulation. L’article sur le vibe coding explore là où cette philosophie s’applique au développement assisté par IA.
-
La colonne « Projet Next.js typique » reflète l’expérience de l’auteur sur plus de 5 projets Next.js (2021-2024) et les normes rapportées par la communauté. Pour référence : un
npx create-next-app@latesttout neuf (Next.js 15, testé en février 2026) installe 311 paquets dansnode_modules/, pour un total de 187 Mo. Les 311 paquets et 187 Mo du tableau sont cette base mesurée ; les projets de production avec des dépendances supplémentaires tendent vers le haut, d’où sa fourchette de 250-400 Mo. Chaque projet varie considérablement. ↩↩↩ -
Liste complète des dépendances en février 2026 : fastapi, uvicorn, starlette, pydantic, pydantic-settings, jinja2, markdown, pygments, beautifulsoup4, lxml, nh3, resend, python-multipart, httpx, analytics-941. Aucune n’est un outil de build. Aucune n’est un compilateur. Aucune n’est un bundler. ↩
-
Taille moyenne des composants (130-450 lignes) mesurée sur les 20 fichiers JS interactifs de
/static/js/en février 2026. Les tailles vont de 132 lignes (compound-interest-mind.js) à 450 lignes (subtraction-machine.js), arcade.js faisant figure d’exception avec 1 666 lignes. ↩ -
D’après l’expérience de l’auteur dans la maintenance de projets Next.js, l’écosystème JavaScript génère 15 à 25 PR Dependabot par mois pour un projet actif, la plupart mettant à jour des dépendances transitives que le développeur n’a jamais importées directement. Ce chiffre est une estimation issue de l’observation directe, pas un benchmark vérifié de manière indépendante. ↩
-
La plateforme web (HTML, CSS, JavaScript) a maintenu sa rétrocompatibilité pendant 30 ans. Une page de 1996 s’affiche encore dans Chrome 2026. Tim Berners-Lee en a fait un principe de conception : « a browser should be backwards-compatible, in that it should be able to read an earlier version of the language. » Voir w3.org/DesignIssues/Principles. ↩
-
Carson Gross, créateur de HTMX, formule cela comme « hypermedia as the engine of application state » (HATEOAS). Voir les essais sur htmx.org et le livre Hypermedia Systems (2023) de Gross, Stepinski et Cotter : hypermedia.systems. ↩
-
Les propriétés personnalisées CSS (variables CSS) sont prises en charge par plus de 97 % des navigateurs dans le monde. Source : caniuse.com/css-variables. Aucune étape de compilation n’est nécessaire pour les utiliser. ↩
-
Le principe de « la contrainte comme outil de design » a une longue histoire. Charles Eames : « Design depends largely on constraints. » Le mouvement Dogme 95 au cinéma a prouvé que retirer des outils (pas d’éclairage artificiel, pas de postproduction) produisait une narration plus honnête, et non moins honnête. Voir en.wikipedia.org/wiki/Dogme_95. ↩
-
La Stack Overflow Developer Survey 2024 a classé TypeScript parmi les cinq langages de programmation les plus utilisés et comme le sur-ensemble de JavaScript le plus largement adopté. La méthodologie et les résultats complets de l’enquête sont disponibles sur survey.stackoverflow.co/2024/. L’observation selon laquelle l’adoption de TypeScript est corrélée à la taille de l’équipe est une déduction de l’auteur fondée sur la pratique du secteur, et non un résultat direct de l’enquête. ↩
-
L’historique git du site commence en mars 2023. Le chiffre de « trois ans » couvre la période allant du premier déploiement sur Railway (mars 2023) à février 2026. Le bug de CLS documenté dans la section « Le parcours du CLS » est le seul problème CSS ayant eu un impact en production sur cette période. ↩
-
Google PageSpeed Insights (pagespeed.web.dev) exécute des audits Lighthouse sur n’importe quelle URL publique. L’outil évalue Performance, Accessibilité, Bonnes pratiques et SEO sur une échelle de 0 à 100. blakecrosley.com obtient 100 dans les quatre catégories en février 2026. Les résultats sont vérifiables publiquement et ne sont pas autodéclarés. ↩
-
Potvin, R. et Levenberg, J. (2016). « Why Google Stores Billions of Lines of Code in a Single Repository. » Communications of the ACM, 59(7), 78-87. doi.org/10.1145/2854146. L’approche monorepo de Google était motivée en partie par le coût organisationnel de la gestion des versions de dépendances sur des milliers de projets, la même force qui produit le gonflement de
node_modules/à l’échelle d’un projet individuel. L’article documente comment la gestion des dépendances consomme du temps d’ingénierie proportionnellement au nombre de dépendances transitives, et non directes. ↩ -
La documentation de performance de Next.js publiée par Vercel reconnaît que les scores Lighthouse par défaut varient selon la complexité de l’application et recommande des optimisations précises (optimisation des images, chargement des polices, configuration du découpage du code) pour dépasser 90. Voir nextjs.org/docs/app/building-your-application/optimizing. La fourchette 70-90 correspond à un projet
create-next-apptout neuf avec les réglages par défaut, avant ces optimisations, ce qui concorde avec les benchmarks communautaires publiés dans les discussions GitHub de Next.js. ↩ -
La politique de versionnement de HTMX et son engagement de rétrocompatibilité sont documentés sur htmx.org/migration-guide-htmx-1/. Le guide de migration de 1.x vers 2.x illustre l’approche du projet : les changements cassants sont limités aux versions majeures, clairement documentés et accompagnés d’outils de migration. Carson Gross a énoncé le principe de rétrocompatibilité dans plusieurs conférences et dans Hypermedia Systems (2023). ↩