Das No-Build-Manifest: Ausliefern ohne Bundler

Das Folgende ist kein Plädoyer dafür, dass Sie Ihre Build-Tools aufgeben sollten. Es ist eine Messung dessen, was passiert, wenn Sie es tun.

blakecrosley.com läuft mit FastAPI + Jinja2 + HTMX + Alpine.js + reinem CSS. Kein webpack. Kein Vite. Kein Rollup. Kein TypeScript-Compiler. Kein Babel. Kein PostCSS. Kein Tailwind. Keine package.json. Kein node_modules/. Die Seite liefert 37 Blogbeiträge mit 20 interaktiven JavaScript-Komponenten, 20 Leitfäden und Übersetzungen in zehn Sprachen aus und erreicht 100/100/100/100 bei Lighthouse. Den Lighthouse-Wert können Sie selbst überprüfen: Führen Sie PageSpeed Insights auf einer beliebigen Seite aus.11

Zusammenfassung

An Fürsprache mangelt es der HTMX-Community nicht. Was ihr fehlt, sind Belege. Die Zahlen hier stammen von einer Produktionsseite mit umfangreichem Inhalt, interaktiven Funktionen und Internationalisierung, und das alles ohne ein einziges Build-Tool. Die Kompromisse sind ehrlich benannt, und die Schlussfolgerung ist eng gefasst: Bei inhaltsorientierten Seiten mit einem Einzelentwickler oder einem kleinen Team lösen Build-Tools Probleme, die Sie nicht haben, und schaffen dabei Probleme, die Sie dann haben. Für große Teams mit gemeinsamen Komponentenbibliotheken und Design-System-Paketen rechtfertigen Build-Tools ihre Komplexität. Die Grenze ist klarer, als die Debatte vermuten lässt.


Der 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)

Keine Transpilierung. Kein Tree Shaking. Kein Hot Module Replacement. Keine Source Maps. Das JavaScript, das Sie schreiben, ist das JavaScript, das ausgeliefert wird.


Die Zahlen

Hier sind die echten Messwerte, keine Schätzungen:

Metrik blakecrosley.com Typisches Next.js-Projekt (Schätzung des Autors)1
Abhängigkeiten 15 Python-Pakete 311 npm-Pakete (verifiziert: npx create-next-app@latest, Feb. 2026)1
Build-Konfigurationsdateien 0 5-8 (next.config, tsconfig, postcss, tailwind, eslint, babel usw.)
Größe von node_modules/ Existiert nicht 187 MB Basiswert (verifiziert), 250-400 MB mit Ergänzungen1
Installationszeit pip install -r requirements.txt: 8 Sekunden npm install: 30-90 Sekunden
Build-Schritt Keiner next build: 15-60 Sekunden
Deploy-Pipeline git push → live in ~40 Sekunden git push → Installieren → Bauen → Deployen: 2-5 Minuten
CSS-Dateien 17 Dateien, 10.846 Zeilen (reines CSS) Generiert aus Tailwind/Sass, Ausgabe variiert
JS-Dateien 33 Dateien, 8.819 Zeilen (menschenlesbar) Gebündelt, minifiziert, in Chunks aufgeteilt: in Produktion unlesbar
Lighthouse Performance 100 70-90 ohne gezielte Optimierung (laut Vercels eigener Performance-Dokumentation)13

Zu den 15 Python-Paketen gehören FastAPI, Jinja2, Pydantic und 12 weitere. Keines davon ist ein Build-Tool. Keines ist ein Compiler. Keines ist ein Bundler.2


Was Sie aufgeben

Ehrlichkeit verlangt, die tatsächlichen Kosten aufzuzählen. Es gibt sie wirklich.

Kein TypeScript. Jede .js-Datei in diesem Projekt ist Vanilla JavaScript. Typfehler fangen Tests und die Analyse durch Claude Code ab, nicht ein Compiler. Für einen Einzelentwickler funktioniert dieser Ansatz. Für ein Team von 10 Personen, die Komponentenschnittstellen modulübergreifend teilen, würde er nicht funktionieren.

Kein Hot Module Replacement. Wenn ich eine CSS-Datei ändere, lade ich den Browser manuell neu. HTMXs hx-boost macht die Navigation so schnell, dass vollständige Neuladevorgänge erträglich sind, weil es per AJAX nur den Body-Inhalt abruft und ihn ohne vollständigen Seitenaufbau austauscht. Bei einem Projekt, in dem ich alle 30 Sekunden an visuellen Details feile, würde HMR spürbar Zeit sparen.

Kein Tree Shaking. Jedes Byte JavaScript, das ich schreibe, landet im Browser. Ich kann keine einzelne Funktion aus einer Hilfsbibliothek importieren, ohne die gesamte Datei auszuliefern. Tree Shaking (das Entfernen toten Codes durch den Bundler, der Importpfade verfolgt und Funktionen streicht, auf die kein Modul verweist) setzt per Definition einen Build-Schritt voraus. Die Einschränkung erzwingt Disziplin: kleine, fokussierte Dateien statt großer Hilfsmodule. Die 20 interaktiven Komponenten umfassen im Schnitt 130-450 Zeilen, weil jede für sich allein funktionieren muss.3

Keine Komponentenbibliothek aus npm. Kein Radix, kein shadcn/ui, kein Headless UI. Jedes interaktive Element (die Boids-Simulation, der Hamming-Code-Visualisierer, der Konsens-Simulator) ist von Hand gebaut. Tragfähig ist der Ansatz nur, weil die interaktiven Komponenten konkreten didaktischen Zwecken dienen und keine generischen UI-Muster abbilden.

Keine Design-System-Tokens aus npm. Mein Design-System lebt vollständig in CSS Custom Properties. Ich kann es in einem anderen Projekt nicht als Paket importieren. Für ein System, das nur eine einzige Website bedient, ist die Einschränkung akzeptabel. Für eine Organisation mit mehreren Produkten ist sie es nicht.

Die fünf Kompromisse sind für eine inhaltsorientierte Seite mit einem einzigen Entwickler akzeptabel. Für ein SaaS-Produkt mit einem Engineering-Team von 15 Personen wären sie es nicht.


Was Sie gewinnen

Null fehlgeschlagene Builds. Die Deploy-Pipeline ist git push. Kein npm install kann an einem Peer-Dependency-Konflikt scheitern. Kein next build kann an einem TypeScript-Fehler in einer Datei scheitern, die ich gar nicht angefasst habe. Kein Dependabot-PR aktualisiert eine transitive Abhängigkeit und bricht dabei den Build.4

Debugging per Quelltextansicht. Das JavaScript, das im Browser läuft, ist das JavaScript, das ich geschrieben habe. Keine Source Maps nötig. Keine Zuordnung von kompilierter Ausgabe zum ursprünglichen Quellcode. Tritt in Produktion ein Bug auf, lese ich direkt die ausgelieferte Datei.

Sofortiger lokaler Start. uvicorn app.main:app --reload startet in unter 2 Sekunden. Kein npm run dev, das erst installiert, kompiliert und bündelt, bevor eine Seite erscheint.

Ein konkreter Request-Wasserfall. Der erste Besuch eines Blogbeitrags lädt: ein HTML-Dokument (~15KB gzipped), eine CSS-Datei (~8KB), eine seitenspezifische CSS-Datei (~2KB), HTMX vom CDN (~14KB, gecacht), Alpine.js vom CDN (~14KB, gecacht) und die interaktive JS-Komponente der Seite (~4-8KB). Gesamtübertragung: 45-60KB beim ersten Besuch, 15-25KB aus dem Cache. Kein Bundle-Splitting, keine Chunk-Aushandlung, keine Modulauflösung zur Laufzeit. Der Browser fordert genau das an, was die Seite braucht, und sonst nichts.

Kein Dependabot-Rauschen. Ohne package-lock.json gibt es keine wöchentlichen PRs, die semver, ansi-regex oder glob-parent aktualisieren: Pakete, die ich nie direkt importiert habe, die aber drei Ebenen tief in meinem Abhängigkeitsbaum stecken.

Ein zukunftssicheres Frontend. Der clientseitige Code wird auch in 10 Jahren noch funktionieren. Das HTML ist HTML. Das CSS ist CSS. Das JavaScript ist JavaScript. Es gibt keine Migration von Webpack 4 auf 5, keine Abkündigung von Create React App, keine Migration auf den Next.js App Router. Die Plattform ist der Standard.5 Die serverseitigen Abhängigkeiten (FastAPI, Python, Railway) brauchen weiterhin Versionspflege und gelegentliche Updates: Der No-Build-Ansatz beseitigt die Unruhe in der Frontend-Toolchain, nicht die Wartung des Backends.


HTMX als Architektur

Die Debatte um HTMX dreht sich um Syntax: hx-get, hx-swap, hx-target. Das ist der falsche Rahmen. Die architektonische Erkenntnis lautet: Server-gerendertes HTML ist die API.

In einer klassischen SPA:

Browser → fetch('/api/users') → JSON → React renders HTML → DOM update

Mit HTMX:

Browser → GET /users (hx-get) → Server renders HTML fragment → DOM swap

Der Server liefert die endgültige Darstellung. Kein clientseitiges State-Management, keine Serialisierung und Deserialisierung, keine Hydration. Das Jinja2-Template ist die Komponente. Der FastAPI-Endpunkt ist die API. Eine Schicht statt drei.6

Die architektonischen Folgen ziehen Kreise. Drei Dinge fallen weg, und jedes beseitigt eine ganze Problemkategorie statt eines einzelnen Bugs.

Keine JSON-Grenze. Abweichende Antwortstrukturen, Mehrdeutigkeiten zwischen null und undefined und inkonsistente Datumsserialisierung verschwinden. TypeScript und Zod existieren, um genau diese Bugs zu verhindern. HTMX beseitigt die gesamte Kategorie, indem es HTML statt JSON zurückgibt.

Kein clientseitiges State-Management. Serverzustand und Clientzustand konsistent zu halten, ist der schwierigste Teil der SPA-Entwicklung. HTMX löst das Problem, indem es nur eine einzige Quelle der Wahrheit gibt: den Server.

Keine Hydration. Das „Uncanny Valley“, in dem die Seite zunächst Server-HTML rendert und dann flackert, während das JavaScript-Framework sie clientseitig neu rendert, existiert nicht. Das HTML des Servers ist die endgültige Ausgabe.

Ein konkreter Vergleich zeigt den Unterschied. Hier ist ein Suchfeld mit Ergebnissen während der Eingabe, auf zwei Arten gebaut:

Mit React + Build-Tools (JSX, erfordert Transpilierung):

// 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>);
}

Mit HTMX + Server-Rendering (reines HTML, kein Build-Schritt):

<!-- 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})

Die HTMX-Version hat keinen Client-State, keine Serialisierungsgrenze und keinen Build-Schritt. Der Server liefert das fertige HTML. Der Browser tauscht es ein. Die gesamte Interaktion besteht aus acht Zeilen Template und fünf Zeilen Python.

Das Muster entspricht unmittelbar dem Prinzip des Compounding Engineering: Jedes Stück Infrastruktur erledigt genau eine Aufgabe, und die Teile lassen sich ohne gegenseitige Störung kombinieren. Ein Template rendert HTML. Eine Route gibt es zurück. HTMX tauscht es ein. Kein Build-Schritt koordiniert diese Teile, weil keine Koordination nötig ist.

Ein komplexeres Beispiel: mehrstufiges Formular mit Validierung

Suche während der Eingabe ist die klassische HTMX-Demo. Ein mehrstufiges Formular zeigt das Muster in Produktionskomplexität: serverseitige Validierung, bedingtes Weiterschalten der Schritte und ein über mehrere Requests erhaltener Zustand, ganz ohne clientseitiges State-Management:

<!-- 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>

Der Server besitzt den Formularzustand. Schritt 2 wird erst gerendert, nachdem Schritt 1 serverseitig validiert wurde: kein clientseitiges bedingtes Rendering, keine Formular-State-Bibliothek, kein useReducer. Validierungsfehler ersetzen den aktuellen Schritt durch denselben Schritt samt Fehlermeldungen. Der gesamte mehrstufige Ablauf kommt ohne eine einzige Zeile clientseitiges JavaScript aus. Ein React-Gegenstück bräuchte für denselben Ablauf useState für jedes Feld, einen Schrittzähler, Logik für bedingtes Rendering, clientseitige Validierung (als Doppelung der Servervalidierung) und eine API-Serialisierungsgrenze. Die HTMX-Version beseitigt alle fünf Punkte, indem sie den Zustand dort hält, wo die Validierungslogik ohnehin lebt: auf dem Server.


Reines CSS genügt

Mein Design-System verwendet 10 Farb-Tokens, 13 Stufen der Typografieskala und acht Abstandswerte, allesamt CSS Custom Properties:

: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;
}

Kein Sass-Kompilierungsschritt. Keine Tailwind-Konfiguration, die Utilities generiert. Keine PostCSS-Plugins, die eigene Syntax umwandeln. Der Browser liest diese Werte direkt. CSS Custom Properties können Dinge, die Präprozessor-Variablen fehlen: Sie kaskadieren durch das DOM, erben von übergeordneten Elementen und lassen sich zur Laufzeit in Media Queries überschreiben oder auf Komponenten begrenzen. Sass-Variablen werden zu statischen Werten kompiliert und verschwinden. Custom Properties bleiben lebendig, sodass ein einziger Themenwechsel oder Dark-Mode-Schalter jeden abgeleiteten Wert ohne Neukompilierung ändert.7

Die Ästhetik von Schönheit und Brutalismus dieser Seite (Weiß auf absolutem Schwarz mit vier Deckkraftstufen) entsteht aus der Einschränkung. Wenn Sie nicht zu einer Farbpalette greifen können, trägt die Typografie die Hierarchie. Wenn Sie nicht zu Komponentenschatten greifen können, schafft Weißraum die Struktur. Die Einschränkung ist das Design.8


Der Weg zum CLS

Der Weg zu Lighthouse legte einen echten Preis von No-Build offen: Das Extrahieren von kritischem CSS erforderte ein eigenes Python-Skript. In einem Next.js-Projekt erledigt das Framework dies automatisch.

Der konkrete Bug: Eine mobile Media Query überschrieb eine CSS Custom Property (--gutter: 48px → --gutter: 24px). Das kritische CSS enthielt den Desktop-Wert, nicht aber die mobile Überschreibung. Auf Mobilgeräten wurde der Hero-Bereich mit 48px Innenabstand gerendert und rutschte dann auf 24px, sobald das vollständige Stylesheet geladen war, was einen CLS von 0,493 ergab.

Die Lösung waren 12 Zeilen Python, die kritisches CSS einschließlich der Media-Query-Überschreibungen extrahieren:

# 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)

Die Untersuchung dauerte drei Stunden. Die Korrektur selbst dauerte 20 Minuten. Ein Build-Tool hätte das automatisch erledigt.

Die ehrliche Bilanz: Build-Tools automatisieren Dinge, die Sie auch von Hand erledigen können, doch die Handarbeit kostet Debugging-Zeit, wenn sie bricht. Die Frage ist, ob die Kosten der Automatisierung (Komplexität, Abhängigkeiten, fehlgeschlagene Builds, ständige Migrationen) die Kosten der Handarbeit (gelegentliche Debugging-Sitzungen) übersteigen.

Für diese Seite waren die Kosten der Handarbeit geringer. Drei Jahre, ein CLS-Bug, drei Stunden Debugging.10 Die Alternative (eine Build-Pipeline zu pflegen) hätte kumuliert mehr Zeit gekostet, für Abhängigkeits-Updates, Breaking Changes und Konfigurationspflege.


Wann Sie darauf verzichten sollten

Der No-Build-Ansatz ist falsch für:

Große Teams. Der Wert von TypeScript wächst mit der Teamgröße.9 Wenn 10 Entwickler Komponentenschnittstellen teilen, verhindert die Typprüfung zur Kompilierzeit Integrationsfehler, die Laufzeittests zu spät finden. Ein Einzelentwickler hat das gesamte System im Kopf. Ein Team kann das nicht.

Design-System-Pakete. Wenn mehrere Produkte Ihr Design-System nutzen, muss es ein npm-Paket mit sauberer Versionierung, Tree Shaking und Build-Pipeline sein. CSS Custom Properties in einem einzigen Stylesheet lassen sich nicht über Repositorys hinweg kombinieren.

Komplexer Client-State. Hat Ihre Anwendung einen reichhaltigen clientseitigen Zustand (Drag-and-Drop-Oberflächen, Echtzeit-Zusammenarbeit, Offline-First-Daten), rechtfertigt ein Framework wie React oder Svelte seine Komplexität. HTMX ersetzt Client-State durch Server-Roundtrips, und das funktioniert, bis die Latenz ins Gewicht fällt.

Bibliotheken aus dem npm-Ökosystem. Wenn Sie Radix-Primitives, Framer Motion oder TanStack Query brauchen, brauchen Sie eine Build-Pipeline. Alle drei setzen einen Bundler voraus. Sie ohne einen zu verwenden, reicht von mühsam bis unmöglich.

Die Grenze ist einfacher, als die Debatte vermuten lässt: Besteht Ihre Anwendung in erster Linie aus Inhalten, die ein Server rendert, sind Build-Tools Ballast. Besteht sie in erster Linie aus Zustand, den ein Client verwaltet, sind Build-Tools Infrastruktur.

Entscheidungsrahmen: Brauchen Sie Build-Tools?

Beantworten Sie diese vier Fragen:

  1. Teilen mehr als fünf Entwickler JavaScript-Schnittstellen? Wenn ja, verhindert die Typprüfung von TypeScript zur Kompilierzeit Integrationsfehler, die Laufzeittests zu spät finden. Führen Sie einen Build-Schritt ein.

  2. Verwaltet Ihre Anwendung komplexen clientseitigen Zustand? Sind Drag-and-Drop, Echtzeit-Zusammenarbeit oder Offline-First-Daten Kernfunktionen (und nicht bloß nette Extras), rechtfertigt ein Framework wie React oder Svelte seine Komplexität. Führen Sie einen Build-Schritt ein.

  3. Nutzen mehrere Produkte eine gemeinsame Komponentenbibliothek? Wenn ja, braucht diese Bibliothek npm-Paketierung, semantische Versionierung und Tree Shaking. Führen Sie einen Build-Schritt ein.

  4. Hängen Sie von Bibliotheken aus dem npm-Ökosystem ab, die einen Bundler voraussetzen? Sind Radix, Framer Motion, TanStack Query oder ähnliche Bibliotheken zentral für das Produkt, ist eine Build-Pipeline Pflicht.

Lauten alle vier Antworten „nein“, ist der No-Build-Ansatz tragfähig. Lautet eine Antwort „ja“, lösen Build-Tools ein echtes Problem, das Sie haben. Der Fehler besteht darin, Build-Tools einzuführen, obwohl alle vier Antworten „nein“ lauten: Damit lösen Sie Probleme, die Sie nicht haben, und schaffen einen Aufwand für das Abhängigkeitsmanagement, den Sie dann sehr wohl haben.

Übung: Prüfen Sie Ihr aktuelles Projekt. Führen Sie du -sh node_modules/ (oder ein Äquivalent) und wc -l package-lock.json aus. Notieren Sie die beiden Zahlen. Listen Sie dann die drei Funktionen Ihrer Build-Pipeline auf, die unmittelbar Ihren Nutzern dienen (nicht Ihrer Developer Experience). Fallen Ihnen keine drei ein, dient die Pipeline womöglich eher der Toolchain als dem Produkt. Die Zahlen sind nicht per se schlecht: Sie messen Komplexität, die ihren Preis wert sein sollte.


Die wichtigsten Erkenntnisse

Für Einzelentwickler und kleine Teams:

  • Der Beweis ist die Seite, nicht das Argument. blakecrosley.com liefert 37 Beiträge, 20 interaktive Komponenten, 20 Leitfäden und zehn Sprachen mit null Build-Tools und perfekten Lighthouse-Werten aus. Die Zahlen sind überprüfbar.

  • Der ehrliche Preis von No-Build ist gelegentliches Debugging. Die Behebung des CLS-Bugs dauerte drei Stunden. Ein Build-Tool hätte ihn automatisch abgefangen. Über drei Jahre war die kumulierte Debugging-Zeit weit geringer als die kumulierte Wartungszeit, die eine Build-Pipeline erfordert hätte.

  • Einschränkungen erzeugen Design. Keine Farben zwangen die Typografie, die Hierarchie zu tragen. Keine Build-Tools erzwangen einfaches, eigenständiges JavaScript. Die besten Einschränkungen sind die, die Sie wählen, bevor Sie sie brauchen.

Für Teamleiter, die Stack-Entscheidungen abwägen:

  • Build-Tools lösen Probleme im Teammaßstab. TypeScript, Tree Shaking und Komponentenbibliotheken rechtfertigen ihre Komplexität, wenn mehrere Entwickler Schnittstellen teilen. Ein Einzelentwickler, der inhaltsorientierte Seiten baut, hat diese Probleme nicht.

  • Der eigentliche Beitrag von HTMX ist architektonisch. Server-gerendertes HTML als API beseitigt Client-State-Management, Serialisierung und Hydration. Die Syntax ist zweitrangig gegenüber dieser Erkenntnis.


Häufige Fragen

Ist HTMX reif für den Produktionseinsatz in echten Webanwendungen?

Ja. HTMX ist seit 2020 stabil und wird von Unternehmen aus vielen Branchen produktiv eingesetzt. Carson Gross, der Erfinder, hält die Abwärtskompatibilität als zentrales Designprinzip hoch. Die HTMX-Dokumentation sagt ausdrücklich: “htmx follows semantic versioning and will not break existing applications within a major version.”14 Die Bibliothek selbst ist minifiziert und gzipped 14KB groß, hat keine Abhängigkeiten und folgt der semantischen Versionierung. blakecrosley.com setzt HTMX seit drei Jahren produktiv ein, ohne einen einzigen HTMX-bezogenen Bug: Jedes aufgetretene Problem lag in der Anwendungslogik, nicht in der Bibliothek.

Kann ich TypeScript ohne Build-Schritt verwenden?

Teilweise. TypeScript-Dateien lassen sich mit tsc --noEmit typprüfen, ohne Ausgabedateien zu erzeugen, sodass die Typprüfung zur Kompilierzeit als Linter statt als Transpiler dient. Browser können .ts-Dateien allerdings nicht direkt ausführen, weshalb weiterhin ein Build-Schritt nötig ist, um TypeScript an den Browser auszuliefern. Die Alternative sind JSDoc-Typannotationen in reinen .js-Dateien, die TypeScript ohne Kompilierung prüfen kann. So erhalten Sie Typsicherheit während der Entwicklung und liefern dennoch Standard-JavaScript aus.

Wie schneidet dieser Ansatz im Vergleich zu Astro oder 11ty ab?

Astro und 11ty besetzen einen Mittelweg: Es sind Static-Site-Generatoren, die reines HTML mit minimalem oder gar keinem Client-JavaScript erzeugen, doch sie erfordern weiterhin einen Build-Schritt (Node.js, npm install, einen Build-Befehl). Der No-Build-Ansatz beseitigt diesen Build-Schritt vollständig, denn der Server rendert das HTML bei jedem Request. Der Kompromiss: Astro und 11ty liefern schnellere statische Seiten (keine Berechnung auf dem Server), während FastAPI + HTMX dynamische Inhalte (nutzerspezifische Daten, Formularübermittlungen, Echtzeit-Updates) nativ und ohne API-Schicht verarbeitet.

Kann ein Webentwicklungsteam ohne Build-Tools und npm ausliefern?

Das hängt davon ab, was das Team baut. Bei inhaltsorientierten Seiten und internen Tools haben Teams von 2-5 Personen erfolgreich ohne Build-Tools ausgeliefert, mit server-gerendertem HTML und reinem CSS. Die Einschränkung, die zuerst schmerzt, sind gemeinsame Komponentenschnittstellen: Ohne TypeScript können zwei Entwickler unterschiedliche Vorstellungen von der erwarteten Eingabe einer Funktion haben, ohne dass ein Compiler es bemerkt. Die praktische Grenze liegt bei etwa 5-8 Entwicklern, die an gemeinsamem JavaScript arbeiten. Darüber hinaus rechtfertigen TypeScript und eine Komponentenbibliothek ihre Komplexität.


Die Kosten der JavaScript-Abhängigkeiten sind keine Einzelbeobachtung dieses Autors. Potvin, R. und Levenberg, J. (2016) dokumentierten in “Why Google Stores Billions of Lines of Code in a Single Repository” die organisatorischen Kosten des Abhängigkeitsmanagements im großen Maßstab.12 Auf der Ebene des einzelnen Projekts erzeugt die Abhängigkeitstiefe des npm-Ökosystems genau die hier beschriebene Wartungslast: transitive Abhängigkeiten, die der Entwickler nie gewählt hat, erzeugen einen Aktualisierungsdruck, den er bewältigen muss.

Dieser Artikel verbindet die Bereiche Design und Engineering des Blogs. Designentscheidungen finden sich in Beauty and Brutalism, Design Systems for Startups und Type Scales. Die technischen Messwerte stehen in Lighthouse Perfect Score und Compounding Engineering. Der Beitrag über Vibe Coding untersucht, wo sich diese Philosophie auf KI-gestützte Entwicklung übertragen lässt.



  1. Die Spalte „Typisches Next.js-Projekt“ spiegelt die Erfahrung des Autors aus mehr als 5 Next.js-Projekten (2021-2024) und in der Community berichtete Normen wider. Zum Vergleich: Ein frisches npx create-next-app@latest (Next.js 15, getestet im Februar 2026) installiert 311 Pakete in node_modules/ mit insgesamt 187 MB. Die 311 Pakete und 187 MB in der Tabelle sind dieser gemessene Basiswert; Produktionsprojekte mit zusätzlichen Abhängigkeiten liegen tendenziell höher, daher die Spanne von 250-400 MB in der Tabelle. Einzelne Projekte variieren erheblich. ↩↩↩

  2. Vollständige Abhängigkeitsliste, Stand Februar 2026: fastapi, uvicorn, starlette, pydantic, pydantic-settings, jinja2, markdown, pygments, beautifulsoup4, lxml, nh3, resend, python-multipart, httpx, analytics-941. Kein einziges davon ist ein Build-Tool. Keines ist ein Compiler. Keines ist ein Bundler. ↩

  3. Die durchschnittliche Komponentengröße (130-450 Zeilen) wurde an den 20 interaktiven JS-Dateien in /static/js/ gemessen, Stand Februar 2026. Die Größen reichen von 132 Zeilen (compound-interest-mind.js) bis 450 Zeilen (subtraction-machine.js); arcade.js ist mit 1.666 Zeilen ein Ausreißer. ↩

  4. Nach der Erfahrung des Autors mit der Pflege von Next.js-Projekten erzeugt das JavaScript-Ökosystem für ein aktives Projekt 15-25 Dependabot-PRs pro Monat, die meisten davon für transitive Abhängigkeiten, die der Entwickler nie direkt importiert hat. Die Zahl ist eine Schätzung aus direkter Beobachtung, kein unabhängig verifizierter Benchmark. ↩

  5. Die Webplattform (HTML, CSS, JavaScript) wahrt seit 30 Jahren die Abwärtskompatibilität. Eine Seite von 1996 wird auch in Chrome 2026 noch dargestellt. Tim Berners-Lee formulierte dies als Designprinzip: “a browser should be backwards-compatible, in that it should be able to read an earlier version of the language.” Siehe w3.org/DesignIssues/Principles. ↩

  6. Carson Gross, der Erfinder von HTMX, fasst dies als “hypermedia as the engine of application state” (HATEOAS). Siehe die Essays auf htmx.org und das Buch Hypermedia Systems (2023) von Gross, Stepinski und Cotter: hypermedia.systems. ↩

  7. CSS Custom Properties (CSS-Variablen) werden von über 97 % der Browser weltweit unterstützt. Quelle: caniuse.com/css-variables. Für ihre Verwendung ist kein Kompilierungsschritt nötig. ↩

  8. Das Prinzip „Einschränkung als Designwerkzeug“ hat eine lange Geschichte. Charles Eames: “Design depends largely on constraints.” Die Dogme-95-Bewegung im Film bewies, dass der Verzicht auf Werkzeuge (kein künstliches Licht, keine Nachbearbeitung) ehrlicheres Erzählen hervorbrachte, nicht weniger ehrliches. Siehe en.wikipedia.org/wiki/Dogme_95. ↩

  9. Die Stack Overflow Developer Survey 2024 führte TypeScript unter den fünf meistgenutzten Programmiersprachen und als das am weitesten verbreitete Superset von JavaScript. Methodik und vollständige Ergebnisse der Umfrage finden sich unter survey.stackoverflow.co/2024/. Die Beobachtung, dass die Verbreitung von TypeScript mit der Teamgröße zusammenhängt, ist eine Schlussfolgerung des Autors aus der Branchenpraxis, kein direktes Umfrageergebnis. ↩

  10. Die Git-Historie der Seite beginnt im März 2023. Die Angabe „drei Jahre“ bezeichnet den Zeitraum vom ersten Deployment auf Railway (März 2023) bis Februar 2026. Der im Abschnitt „Der Weg zum CLS“ dokumentierte CLS-Bug ist das einzige CSS-Problem in diesem Zeitraum, das sich auf die Produktion ausgewirkt hat. ↩

  11. Google PageSpeed Insights (pagespeed.web.dev) führt Lighthouse-Audits für jede öffentliche URL aus. Das Tool prüft Performance, Barrierefreiheit, Best Practices und SEO auf einer Skala von 0-100. blakecrosley.com erreicht mit Stand Februar 2026 in allen vier Kategorien 100. Die Ergebnisse sind öffentlich überprüfbar und keine Selbstauskunft. ↩

  12. Potvin, R. und 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. Googles Monorepo-Ansatz war unter anderem durch die organisatorischen Kosten motiviert, Abhängigkeitsversionen über Tausende von Projekten hinweg zu verwalten: dieselbe Kraft, die auf der Ebene des einzelnen Projekts aufgeblähte node_modules/ hervorbringt. Das Paper dokumentiert, wie das Abhängigkeitsmanagement Engineering-Zeit im Verhältnis zur Zahl der transitiven Abhängigkeiten verbraucht, nicht zur Zahl der direkten. ↩

  13. Vercels Performance-Dokumentation zu Next.js räumt ein, dass die Standardwerte bei Lighthouse je nach Komplexität der Anwendung variieren, und empfiehlt gezielte Optimierungen (Bildoptimierung, Schriftladen, Konfiguration des Code-Splittings), um Werte über 90 zu erreichen. Siehe nextjs.org/docs/app/building-your-application/optimizing. Der Bereich 70-90 entspricht einem frischen create-next-app-Projekt mit Standardeinstellungen vor diesen Optimierungen und deckt sich mit Community-Benchmarks aus den GitHub-Diskussionen zu Next.js. ↩

  14. Die Versionierungsrichtlinie von HTMX und ihre Verpflichtung zur Abwärtskompatibilität sind unter htmx.org/migration-guide-htmx-1/ dokumentiert. Der Migrationsleitfaden von 1.x auf 2.x zeigt die Vorgehensweise des Projekts: Breaking Changes bleiben auf Hauptversionen beschränkt, sind klar dokumentiert und werden von Migrationswerkzeugen begleitet. Carson Gross hat das Prinzip der Abwärtskompatibilität in mehreren Konferenzvorträgen und in Hypermedia Systems (2023) formuliert. ↩

Verwandte Beiträge

Signal-Scoring-Pipeline: Deterministische Wissens-Triage

Eine 733 Zeilen lange Python-Pipeline bewertet Notizen über vier Dimensionen und ordnet 7.700+ Elemente deterministisch …

21 Min. Lesezeit

Von 76 auf 100: Ein perfekter Lighthouse-Score

Wie eine Portfolio-Website vom mobilen Lighthouse-Performance-Score 76 bei 0,493 CLS zu perfekten 100/100/100/100 in all…

10 Min. Lesezeit

Die 15-fachen Kosten einer falschen Datenbankentscheidung: Lektionen im richtigen Entscheidungszeitpunkt

Ich habe die Kosten einer Datenbankentscheidung in drei Systemen gemessen: Die Migrationskosten stiegen in drei Jahren u…

8 Min. Lesezeit