Manifest „bez budowania”: wdrażanie bez bundlera

Poniższy tekst nie jest argumentem za porzuceniem narzędzi budowania. To pomiar tego, co się dzieje, gdy się je porzuci.

blakecrosley.com działa na FastAPI + Jinja2 + HTMX + Alpine.js + czystym CSS. Bez webpacka. Bez Vite. Bez Rollupa. Bez kompilatora TypeScript. Bez Babela. Bez PostCSS. Bez Tailwinda. Bez package.json. Bez node_modules/. Strona serwuje 37 wpisów blogowych z 20 interaktywnymi komponentami JavaScript, 20 przewodników, tłumaczenia na dziesięć języków i uzyskuje wynik 100/100/100/100 w Lighthouse. Wynik Lighthouse można zweryfikować samodzielnie: wystarczy uruchomić PageSpeed Insights na dowolnej stronie.11

TL;DR

Społeczności HTMX nie brakuje entuzjazmu. Brakuje jej dowodów. Przedstawione tu liczby pochodzą z produkcyjnej strony z obszerną treścią, interaktywnymi funkcjami i internacjonalizacją, a wszystko to bez jednego narzędzia budowania. Kompromisy są uczciwe, a wniosek wąski: w przypadku stron opartych na treści, prowadzonych przez jednego dewelopera lub mały zespół, narzędzia budowania rozwiązują problemy, których się nie ma, a tworzą problemy, które się ma. W dużych zespołach ze współdzielonymi bibliotekami komponentów i pakietami systemu projektowego narzędzia budowania uzasadniają swoją złożoność. Granica jest wyraźniejsza, niż sugeruje dyskusja w branży.


Stos technologiczny

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)

Bez transpilacji. Bez tree shakingu. Bez hot module replacement. Bez source maps. JavaScript, który się pisze, jest dokładnie tym JavaScriptem, który trafia na produkcję.


Liczby

Oto rzeczywiste metryki, nie szacunki:

Metryka blakecrosley.com Typowy projekt Next.js (szacunki autora)1
Zależności 15 pakietów Pythona 311 pakietów npm (zweryfikowane: npx create-next-app@latest, luty 2026)1
Pliki konfiguracji budowania 0 5-8 (next.config, tsconfig, postcss, tailwind, eslint, babel itp.)
Rozmiar node_modules/ Nie istnieje 187 MB na starcie (zweryfikowane), 250-400 MB z dodatkami1
Czas instalacji pip install -r requirements.txt: 8 sekund npm install: 30-90 sekund
Krok budowania Brak next build: 15-60 sekund
Pipeline wdrożenia git push → na żywo w ok. 40 sekund git push → instalacja → budowanie → wdrożenie: 2-5 minut
Pliki CSS 17 plików, 10 846 linii (czysty CSS) Generowane z Tailwinda/Sass, rozmiar wyniku różny
Pliki JS 33 pliki, 8819 linii (czytelne dla człowieka) Zbundlowane, zminifikowane, podzielone na chunki: nieczytelne na produkcji
Wydajność w Lighthouse 100 70-90 bez celowej optymalizacji (według dokumentacji wydajnościowej samego Vercela)13

Wśród 15 pakietów Pythona są FastAPI, Jinja2, Pydantic i 12 innych. Żaden nie jest narzędziem budowania. Żaden nie jest kompilatorem. Żaden nie jest bundlerem.2


Z czego się rezygnuje

Uczciwość wymaga wymienienia rzeczywistych kosztów. A są one realne.

Brak TypeScriptu. Każdy plik .js w tym projekcie to czysty JavaScript. Błędy typów wychwytują testy i analiza Claude Code, a nie kompilator. Takie podejście sprawdza się przy jednym deweloperze. Nie sprawdziłoby się w dziesięcioosobowym zespole współdzielącym interfejsy komponentów między modułami.

Brak Hot Module Replacement. Po zmianie pliku CSS odświeżam przeglądarkę ręcznie. hx-boost z HTMX pobiera przez AJAX tylko zawartość body i podmienia ją bez pełnego przeładowania strony, dzięki czemu nawigacja jest na tyle szybka, że pełne odświeżenia da się znieść. W projekcie, w którym co 30 sekund dopracowuje się szczegóły wizualne, HMR oszczędziłby sporo czasu.

Brak tree shakingu. Każdy bajt JavaScriptu, który piszę, trafia do przeglądarki. Nie da się zaimportować pojedynczej funkcji z biblioteki narzędziowej bez wysłania całego pliku. Tree shaking (eliminacja martwego kodu przez bundler, który śledzi ścieżki importów i usuwa funkcje, do których nie odwołuje się żaden moduł) z definicji wymaga kroku budowania. To ograniczenie wymusza dyscyplinę: małe, wyspecjalizowane pliki zamiast dużych modułów narzędziowych. 20 interaktywnych komponentów liczy średnio po 130-450 linii, bo każdy musi być samowystarczalny.3

Brak biblioteki komponentów z npm. Bez Radix, bez shadcn/ui, bez Headless UI. Każdy interaktywny element (symulacja boidów, wizualizator kodu Hamminga, symulator konsensusu) jest budowany ręcznie. To podejście jest wykonalne tylko dlatego, że interaktywne komponenty służą konkretnym celom dydaktycznym, a nie generycznym wzorcom UI.

Brak tokenów systemu projektowego z npm. Mój system projektowy istnieje wyłącznie w CSS custom properties. Nie można go zaimportować jako pakietu w innym projekcie. Przy systemie obsługującym jedną stronę to ograniczenie jest do przyjęcia. W organizacji z wieloma produktami już nie.

Te pięć kompromisów jest do przyjęcia dla strony opartej na treści, prowadzonej przez jednego dewelopera. Dla produktu SaaS z piętnastoosobowym zespołem inżynierskim byłyby nie do zaakceptowania.


Co się zyskuje

Zero nieudanych buildów. Pipeline wdrożenia to git push. Żaden npm install nie wyłoży się na konflikcie zależności peer. Żaden next build nie wyłoży się przez błąd TypeScriptu w pliku, którego nie dotykałem. Żaden PR Dependabota nie podbije zależności tranzytywnej i nie zepsuje budowania.4

Debugowanie przez „Pokaż źródło”. JavaScript, który działa w przeglądarce, to ten sam JavaScript, który napisałem. Bez source maps. Bez mapowania skompilowanego wyniku na oryginalne źródło. Gdy na produkcji pojawia się błąd, czytam bezpośrednio wdrożony plik.

Natychmiastowy start lokalny. uvicorn app.main:app --reload uruchamia się w mniej niż 2 sekundy. Nie ma npm run dev, które instaluje, kompiluje i bundluje, zanim pokaże stronę.

Konkretny wodospad żądań. Pierwsza wizyta we wpisie na blogu ładuje: jeden dokument HTML (ok. 15KB po gzipie), jeden plik CSS (ok. 8KB), jeden plik CSS specyficzny dla strony (ok. 2KB), HTMX z CDN (ok. 14KB, w cache), Alpine.js z CDN (ok. 14KB, w cache) oraz interaktywny komponent JS danej strony (ok. 4-8KB). Łączny transfer: 45-60KB przy pierwszej wizycie, 15-25KB z cache. Bez dzielenia bundla, bez negocjowania chunków, bez rozwiązywania modułów w czasie działania. Przeglądarka pobiera dokładnie to, czego strona potrzebuje, i nic więcej.

Zero szumu z Dependabota. Brak package-lock.json oznacza brak cotygodniowych PR-ów aktualizujących semver, ansi-regex czy glob-parent: pakiety, których nigdy bezpośrednio nie importowałem, a które siedzą trzy warstwy głębiej w drzewie zależności.

Frontend odporny na upływ czasu. Kod po stronie klienta będzie działał za 10 lat. HTML to HTML. CSS to CSS. JavaScript to JavaScript. Żadnej migracji z Webpacka 4 na 5, żadnego wycofania Create React App, żadnej migracji na Next.js App Router. Platforma jest standardem.5 Zależności po stronie serwera (FastAPI, Python, Railway) nadal wymagają zarządzania wersjami i okazjonalnych aktualizacji: podejście bez budowania eliminuje rotację narzędzi frontendowych, a nie utrzymanie backendu.


HTMX jako architektura

Dyskusja o HTMX koncentruje się na składni: hx-get, hx-swap, hx-target. To niewłaściwa perspektywa. Kluczowa obserwacja architektoniczna jest taka, że HTML renderowany po stronie serwera jest API.

W tradycyjnym SPA:

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

Z HTMX:

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

Serwer zwraca ostateczną reprezentację. Bez zarządzania stanem po stronie klienta, bez serializacji i deserializacji, bez hydracji. Szablon Jinja2 jest komponentem. Endpoint FastAPI jest API. Jedna warstwa zamiast trzech.6

Konsekwencje architektoniczne idą dalej. Trzy eliminacje, z których każda usuwa całą kategorię problemów, a nie pojedynczy błąd.

Brak granicy JSON. Znikają niezgodności kształtu odpowiedzi, niejednoznaczności null kontra undefined i niespójności w serializacji dat. TypeScript i Zod istnieją po to, by zapobiegać takim błędom. HTMX eliminuje całą tę kategorię, zwracając HTML zamiast JSON.

Brak zarządzania stanem po stronie klienta. Utrzymanie spójności między stanem serwera a stanem klienta to najtrudniejsza część pracy nad SPA. HTMX usuwa ten problem, bo istnieje tylko jedno źródło prawdy: serwer.

Brak hydracji. Nie istnieje „dolina niesamowitości”, w której strona renderuje HTML z serwera, a potem migocze, gdy framework JavaScript renderuje ją ponownie po stronie klienta. HTML z serwera jest wynikiem ostatecznym.

Konkretne porównanie pokazuje różnicę. Oto pole wyszukiwania z wynikami na bieżąco, zbudowane na dwa sposoby:

Z Reactem i narzędziami budowania (JSX, wymaga transpilacji):

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

Z HTMX i renderowaniem po stronie serwera (czysty HTML, bez kroku budowania):

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

Wersja z HTMX nie ma stanu klienta, granicy serializacji ani kroku budowania. Serwer zwraca gotowy HTML. Przeglądarka go podmienia. Cała interakcja to osiem linii szablonu i pięć linii Pythona.

Ten wzorzec odpowiada bezpośrednio zasadzie kumulującej się inżynierii: każdy element infrastruktury robi dokładnie jedną rzecz, a elementy składają się w całość bez wzajemnych zakłóceń. Szablon renderuje HTML. Route go zwraca. HTMX go podmienia. Żaden krok budowania nie koordynuje tych elementów, bo żadna koordynacja nie jest potrzebna.

Bardziej złożony przykład: wieloetapowy formularz z walidacją

Wyszukiwanie na bieżąco to klasyczne demo HTMX. Wieloetapowy formularz pokazuje ten wzorzec przy złożoności produkcyjnej: walidacja po stronie serwera, warunkowe przechodzenie między etapami i stan zachowywany między żądaniami bez zarządzania stanem po stronie klienta:

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

Stan formularza należy do serwera. Etap 2 renderuje się dopiero wtedy, gdy etap 1 przejdzie walidację po stronie serwera: bez warunkowego renderowania po stronie klienta, bez biblioteki do stanu formularzy, bez useReducer. Błędy walidacji zastępują bieżący etap tym samym etapem z komunikatami o błędach. Cały wieloetapowy przepływ nie używa ani linii JavaScriptu po stronie klienta. Odpowiednik w React wymagałby useState dla każdego pola, licznika etapów, logiki warunkowego renderowania, walidacji po stronie klienta (dublującej walidację serwerową) oraz granicy serializacji API. Wersja z HTMX eliminuje wszystkie pięć tych kwestii, trzymając stan tam, gdzie i tak znajduje się logika walidacji: na serwerze.


Czysty CSS wystarczy

Mój system projektowy używa 10 tokenów kolorów, 13 stopni skali typograficznej i ośmiu wartości odstępów, a wszystkie są 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;
}

Bez kroku kompilacji Sass. Bez konfiguracji Tailwinda generującej klasy narzędziowe. Bez pluginów PostCSS przekształcających niestandardową składnię. Przeglądarka odczytuje te wartości bezpośrednio. CSS custom properties mają możliwości, których brakuje zmiennym preprocesorów: kaskadują przez DOM, dziedziczą wartości po elementach nadrzędnych i można je nadpisywać w zapytaniach medialnych albo zawężać do komponentów w czasie działania. Zmienne Sass kompilują się do wartości statycznych i znikają. Custom properties pozostają żywe, więc jedno przełączenie motywu lub trybu ciemnego zmienia każdą wartość pochodną bez ponownej kompilacji.7

Estetyka piękna i brutalizmu tej strony (biel na absolutnej czerni z czterema poziomami przezroczystości) wyrasta z ograniczenia. Gdy nie można sięgnąć po paletę kolorów, hierarchię niesie typografia. Gdy nie można sięgnąć po cienie komponentów, strukturę tworzy pusta przestrzeń. Ograniczenie jest projektem.8


Historia z CLS

Droga do idealnego wyniku Lighthouse ujawniła jeden realny koszt pracy bez budowania: ekstrakcja krytycznego CSS wymagała własnego skryptu w Pythonie. W projekcie Next.js framework załatwia to automatycznie.

Konkretny błąd: zapytanie medialne dla urządzeń mobilnych nadpisywało CSS custom property (--gutter: 48px → --gutter: 24px). Krytyczny CSS zawierał wartość desktopową, ale nie mobilne nadpisanie. Na telefonie sekcja hero renderowała się z paddingiem 48px, a po załadowaniu pełnego arkusza stylów przeskakiwała do 24px, co dawało CLS na poziomie 0,493.

Poprawka to 12 linii Pythona, które wyodrębniają krytyczny CSS razem z nadpisaniami z zapytań medialnych:

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

Dochodzenie zajęło trzy godziny. Sama poprawka zajęła 20 minut. Narzędzie budowania obsłużyłoby to automatycznie.

Uczciwy rachunek: narzędzia budowania automatyzują rzeczy, które można zrobić ręcznie, ale wersja ręczna kosztuje czas debugowania, gdy coś się zepsuje. Pytanie brzmi, czy koszt automatyzacji (złożoność, zależności, nieudane buildy, ciągłe migracje) przewyższa koszt ręczny (okazjonalne sesje debugowania).

W przypadku tej strony koszt ręczny okazał się niższy. Trzy lata, jeden błąd CLS, trzy godziny debugowania.10 Alternatywa (utrzymywanie pipeline’u budowania) pochłonęłaby łącznie więcej czasu na aktualizacje zależności, zmiany łamiące kompatybilność i utrzymanie konfiguracji.


Kiedy tego nie stosować

Podejście bez narzędzi budowania jest złym wyborem w przypadku:

Dużych zespołów. Wartość TypeScriptu rośnie wraz z wielkością zespołu.9 Gdy 10 deweloperów współdzieli interfejsy komponentów, sprawdzanie typów w czasie kompilacji zapobiega błędom integracji, które testy w czasie działania wychwytują zbyt późno. Jeden deweloper mieści cały system w głowie. Zespół nie jest w stanie.

Pakietów systemu projektowego. Jeśli z systemu projektowego korzysta wiele produktów, musi on być pakietem npm z porządnym wersjonowaniem, tree shakingiem i pipeline’em budowania. CSS custom properties w jednym arkuszu stylów nie dają się składać między repozytoriami.

Złożonego stanu po stronie klienta. Jeśli aplikacja ma rozbudowany stan po stronie klienta (interfejsy drag-and-drop, współpraca w czasie rzeczywistym, dane offline-first), framework taki jak React czy Svelte uzasadnia swoją złożoność. HTMX zastępuje stan klienta zapytaniami do serwera, co działa, dopóki opóźnienie nie zaczyna mieć znaczenia.

Bibliotek z ekosystemu npm. Jeśli potrzebne są prymitywy Radix, Framer Motion czy TanStack Query, potrzebny jest pipeline budowania. Wszystkie trzy zakładają obecność bundlera. Korzystanie z nich bez niego bywa od bolesnego do niemożliwego.

Granica jest prostsza, niż sugeruje dyskusja w branży: jeśli aplikacja to przede wszystkim treść renderowana przez serwer, narzędzia budowania są narzutem. Jeśli aplikacja to przede wszystkim stan zarządzany przez klienta, narzędzia budowania są infrastrukturą.

Ramy decyzyjne: czy potrzebne są narzędzia budowania?

Warto odpowiedzieć na cztery pytania:

  1. Czy więcej niż pięciu deweloperów współdzieli interfejsy JavaScript? Jeśli tak, sprawdzanie typów TypeScriptu w czasie kompilacji zapobiega błędom integracji, które testy w czasie działania wychwytują zbyt późno. Należy dodać krok budowania.

  2. Czy aplikacja zarządza złożonym stanem po stronie klienta? Jeśli drag-and-drop, współpraca w czasie rzeczywistym lub dane offline-first to kluczowe funkcje (a nie miłe dodatki), framework taki jak React czy Svelte uzasadnia swoją złożoność. Należy dodać krok budowania.

  3. Czy wiele produktów korzysta ze współdzielonej biblioteki komponentów? Jeśli tak, ta biblioteka wymaga pakowania w npm, wersjonowania semantycznego i tree shakingu. Należy dodać krok budowania.

  4. Czy projekt zależy od bibliotek z ekosystemu npm, które zakładają obecność bundlera? Jeśli Radix, Framer Motion, TanStack Query lub podobne biblioteki są rdzeniem produktu, pipeline budowania jest obowiązkowy.

Jeśli wszystkie cztery odpowiedzi brzmią „nie”, podejście bez budowania jest wykonalne. Jeśli którakolwiek brzmi „tak”, narzędzia budowania rozwiązują realny problem, który faktycznie występuje. Błędem jest dodawanie narzędzi budowania, gdy wszystkie cztery odpowiedzi brzmią „nie”: rozwiązuje się wtedy problemy, których nie ma, a tworzy narzut zarządzania zależnościami, który jest jak najbardziej realny.

Ćwiczenie: audyt bieżącego projektu. Proszę uruchomić du -sh node_modules/ (lub odpowiednik) oraz wc -l package-lock.json i zapisać obie liczby. Następnie warto wypisać trzy funkcje pipeline’u budowania, które bezpośrednio służą użytkownikom (a nie wygodzie deweloperów). Jeśli nie da się wskazać trzech, pipeline może służyć bardziej łańcuchowi narzędzi niż produktowi. Same liczby nie są z natury złe: to pomiar złożoności, która powinna zapracować na swoje miejsce.


Kluczowe wnioski

Dla samodzielnych deweloperów i małych zespołów:

  • Dowodem jest strona, nie argument. blakecrosley.com serwuje 37 wpisów, 20 interaktywnych komponentów, 20 przewodników i dziesięć języków bez żadnych narzędzi budowania i z perfekcyjnymi wynikami Lighthouse. Liczby są weryfikowalne.

  • Rzeczywistym kosztem pracy bez budowania jest okazjonalne debugowanie. Naprawa błędu CLS zajęła trzy godziny. Narzędzie budowania obsłużyłoby go automatycznie. Przez trzy lata łączny czas debugowania był znacznie krótszy niż łączny czas utrzymania, którego wymagałby pipeline budowania.

  • Ograniczenia tworzą projekt. Brak kolorów sprawił, że hierarchię musiała nieść typografia. Brak narzędzi budowania wymusił prosty, samowystarczalny JavaScript. Najlepsze ograniczenia to te, które wybiera się, zanim staną się potrzebne.

Dla liderów zespołów oceniających wybór stosu:

  • Narzędzia budowania rozwiązują problemy w skali zespołu. TypeScript, tree shaking i biblioteki komponentów uzasadniają swoją złożoność, gdy wielu deweloperów współdzieli interfejsy. Samodzielny deweloper budujący strony oparte na treści nie ma tych problemów.

  • Prawdziwy wkład HTMX jest architektoniczny. HTML renderowany po stronie serwera jako API eliminuje zarządzanie stanem klienta, serializację i hydrację. Składnia jest drugorzędna wobec tej obserwacji.


Często zadawane pytania

Czy HTMX nadaje się do produkcyjnych aplikacji webowych?

Tak. HTMX jest stabilny od 2020 roku i działa na produkcji w firmach z wielu branż. Jego twórca, Carson Gross, traktuje wsteczną kompatybilność jako podstawową zasadę projektową, a dokumentacja HTMX stwierdza wprost: „htmx stosuje wersjonowanie semantyczne i nie zepsuje istniejących aplikacji w obrębie wersji głównej”.14 Sama biblioteka waży 14KB po minifikacji i kompresji gzip, nie ma żadnych zależności i stosuje wersjonowanie semantyczne. blakecrosley.com korzysta z HTMX na produkcji od trzech lat i nie miał ani jednego błędu związanego z HTMX: każdy napotkany problem tkwił w logice aplikacji, a nie w bibliotece.

Czy można używać TypeScriptu bez kroku budowania?

Częściowo. Pliki TypeScript można sprawdzać pod kątem typów poleceniem tsc --noEmit bez generowania plików wyjściowych, dzięki czemu sprawdzanie typów w czasie kompilacji działa jak linter, a nie transpilator. Przeglądarki nie potrafią jednak bezpośrednio wykonywać plików .ts, więc aby serwować TypeScript przeglądarce, krok budowania nadal jest potrzebny. Alternatywą są adnotacje typów JSDoc w zwykłych plikach .js, które TypeScript potrafi sprawdzić bez kompilacji. Takie podejście daje bezpieczeństwo typów podczas pracy, a na produkcję trafia standardowy JavaScript.

Jak to podejście wypada na tle Astro czy 11ty?

Astro i 11ty zajmują pozycję pośrednią: to generatory stron statycznych, które produkują czysty HTML z minimalną ilością JavaScriptu po stronie klienta albo zupełnie bez niego, ale nadal wymagają kroku budowania (Node.js, npm install, polecenie budowania). Podejście bez budowania całkowicie eliminuje ten krok: serwer renderuje HTML przy każdym żądaniu. Kompromis wygląda tak: Astro i 11ty dają szybsze strony statyczne (bez obliczeń po stronie serwera), natomiast FastAPI + HTMX natywnie obsługuje treści dynamiczne (dane konkretnego użytkownika, wysyłanie formularzy, aktualizacje w czasie rzeczywistym) bez warstwy API.

Czy zespół webdeveloperski może dostarczać oprogramowanie bez narzędzi budowania i npm?

To zależy od tego, co zespół buduje. W przypadku stron opartych na treści i narzędzi wewnętrznych zespoły liczące 2-5 osób z powodzeniem dostarczały produkty bez narzędzi budowania, korzystając z HTML renderowanego po stronie serwera i czystego CSS. Pierwszym ograniczeniem, które daje się we znaki, są współdzielone interfejsy komponentów: bez TypeScriptu dwóch deweloperów może inaczej rozumieć oczekiwane wejście funkcji, a kompilator tego nie wychwyci. Praktyczna granica leży mniej więcej przy 5-8 deweloperach pracujących nad współdzielonym JavaScriptem. Powyżej niej TypeScript i biblioteka komponentów uzasadniają swoją złożoność.


Koszt zależności JavaScript nie jest wyłącznie obserwacją autora tego tekstu. Potvin, R. i Levenberg, J. (2016) w pracy „Why Google Stores Billions of Lines of Code in a Single Repository” opisali organizacyjne koszty zarządzania zależnościami na dużą skalę.12 Na poziomie pojedynczego projektu głębokość zależności w ekosystemie npm tworzy dokładnie opisane tu obciążenie utrzymaniowe: zależności tranzytywne, których deweloper nigdy nie wybrał, generują presję aktualizacji, z którą musi sobie radzić.

Artykuł łączy działy Design i Praktyka inżynierska bloga. Decyzje projektowe opisano we wpisach Piękno i brutalizm, Systemy projektowe dla startupów i Skale typograficzne. Pomiary inżynierskie znajdują się we wpisach Perfekcyjny wynik Lighthouse i Kumulująca się inżynieria. Wpis o vibe codingu analizuje, gdzie ta filozofia ma zastosowanie w programowaniu wspomaganym przez AI.



  1. Kolumna „Typowy projekt Next.js” odzwierciedla doświadczenia autora z ponad 5 projektami Next.js (2021-2024) oraz normy zgłaszane przez społeczność. Dla porównania: świeże npx create-next-app@latest (Next.js 15, test z lutego 2026) instaluje w node_modules/ 311 pakietów o łącznym rozmiarze 187 MB. 311 pakietów i 187 MB w tabeli to właśnie ten zmierzony punkt odniesienia; projekty produkcyjne z dodatkowymi zależnościami zwykle wypadają wyżej i stąd bierze się zakres 250-400 MB w tabeli. Poszczególne projekty znacząco się różnią. ↩↩↩

  2. Pełna lista zależności na luty 2026: fastapi, uvicorn, starlette, pydantic, pydantic-settings, jinja2, markdown, pygments, beautifulsoup4, lxml, nh3, resend, python-multipart, httpx, analytics-941. Zero narzędzi budowania. Zero kompilatorów. Zero bundlerów. ↩

  3. Średni rozmiar komponentu (130-450 linii) zmierzony na 20 interaktywnych plikach JS w /static/js/ według stanu na luty 2026. Rozmiary wahają się od 132 linii (compound-interest-mind.js) do 450 linii (subtraction-machine.js), przy czym arcade.js z 1666 liniami to wartość odstająca. ↩

  4. Na podstawie doświadczeń autora z utrzymywaniem projektów Next.js ekosystem JavaScript generuje 15-25 PR-ów Dependabota miesięcznie dla aktywnego projektu, a większość z nich aktualizuje zależności tranzytywne, których deweloper nigdy bezpośrednio nie importował. Ta wartość jest szacunkiem z bezpośredniej obserwacji, a nie niezależnie zweryfikowanym benchmarkiem. ↩

  5. Platforma webowa (HTML, CSS, JavaScript) zachowuje wsteczną kompatybilność od 30 lat. Strona z 1996 roku nadal renderuje się w Chrome z 2026 roku. Tim Berners-Lee sformułował to jako zasadę projektową: „a browser should be backwards-compatible, in that it should be able to read an earlier version of the language”. Zob. w3.org/DesignIssues/Principles. ↩

  6. Carson Gross, twórca HTMX, ujmuje to jako „hypermedia as the engine of application state” (HATEOAS). Zob. eseje na htmx.org oraz książkę Hypermedia Systems (2023) autorstwa Grossa, Stepinskiego i Cottera: hypermedia.systems. ↩

  7. CSS Custom Properties (zmienne CSS) są obsługiwane przez ponad 97% przeglądarek na świecie. Źródło: caniuse.com/css-variables. Ich użycie nie wymaga żadnego kroku kompilacji. ↩

  8. Zasada „ograniczenia jako narzędzia projektowego” ma długą historię. Charles Eames: „Design depends largely on constraints”. Ruch Dogma 95 w kinematografii udowodnił, że rezygnacja z narzędzi (bez sztucznego oświetlenia, bez postprodukcji) dawała bardziej szczere opowiadanie historii, a nie mniej szczere. Zob. en.wikipedia.org/wiki/Dogme_95. ↩

  9. Ankieta Stack Overflow Developer Survey 2024 wykazała, że TypeScript należy do pięciu najczęściej używanych języków programowania i jest najszerzej przyjętym nadzbiorem JavaScriptu. Metodologia i pełne wyniki ankiety są dostępne pod adresem survey.stackoverflow.co/2024/. Obserwacja, że popularność TypeScriptu koreluje z wielkością zespołu, to wniosek autora wyciągnięty z praktyki branżowej, a nie bezpośredni wynik ankiety. ↩

  10. Historia gita tej strony zaczyna się w marcu 2023 roku. Liczba „trzech lat” obejmuje okres od pierwszego wdrożenia na Railway (marzec 2023) do lutego 2026. Błąd CLS opisany w sekcji „Historia z CLS” to jedyny problem z CSS, który w tym okresie wpłynął na produkcję. ↩

  11. Google PageSpeed Insights (pagespeed.web.dev) przeprowadza audyty Lighthouse dla dowolnego publicznego adresu URL. Narzędzie ocenia wydajność, dostępność, sprawdzone metody i SEO w skali 0-100. Według stanu na luty 2026 blakecrosley.com uzyskuje 100 punktów we wszystkich czterech kategoriach. Wyniki można publicznie zweryfikować, nie są deklarowane samodzielnie. ↩

  12. Potvin, R. and 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. Podejście Google’a do monorepo wynikało częściowo z organizacyjnego kosztu zarządzania wersjami zależności w tysiącach projektów: tej samej siły, która na poziomie pojedynczego projektu powoduje rozrost node_modules/. Praca dokumentuje, że zarządzanie zależnościami pochłania czas inżynierów proporcjonalnie do liczby zależności tranzytywnych, a nie bezpośrednich. ↩

  13. Dokumentacja wydajnościowa Next.js od Vercela przyznaje, że domyślne wyniki Lighthouse zależą od złożoności aplikacji, i zaleca konkretne optymalizacje (optymalizację obrazów, ładowanie fontów, konfigurację dzielenia kodu), aby osiągnąć wyniki powyżej 90. Zob. nextjs.org/docs/app/building-your-application/optimizing. Przedział 70-90 odpowiada świeżemu projektowi create-next-app z ustawieniami domyślnymi, przed zastosowaniem tych optymalizacji, co jest zgodne z benchmarkami społeczności zgłaszanymi w dyskusjach Next.js na GitHubie. ↩

  14. Polityka wersjonowania HTMX i zobowiązanie do wstecznej kompatybilności są opisane na stronie htmx.org/migration-guide-htmx-1/. Przewodnik migracji z wersji 1.x do 2.x pokazuje podejście projektu: zmiany łamiące kompatybilność ograniczają się do wersji głównych, są jasno udokumentowane i towarzyszą im narzędzia do migracji. Carson Gross przedstawiał zasadę wstecznej kompatybilności w wielu wystąpieniach konferencyjnych oraz w książce Hypermedia Systems (2023). ↩

Powiązane artykuły

Pipeline oceny sygnałów: deterministyczny triaż wiedzy

733-wierszowy pipeline w Pythonie ocenia notatki w czterech wymiarach i deterministycznie kieruje ponad 7700 elementów. …

15 min czytania

Od 76 do 100: Osiągnięcie idealnego wyniku Lighthouse

Jak strona portfolio przeszła od mobilnego wyniku Lighthouse 76 z CLS 0,493 do idealnego 100/100/100/100 we wszystkich k…

8 min czytania

Pętla Ralph: jak uruchamiam autonomiczne agenty AI na noc

Zbudowałem system autonomicznych agentów z hookami zatrzymania, budżetami spawnowania i pamięcią opartą na plikach. Co z…

9 min czytania