No-Build 선언문: 번들러 없이 배포하기

다음은 빌드 도구를 버려야 한다는 주장이 아닙니다. 빌드 도구를 버렸을 때 어떤 일이 일어나는지에 대한 측정입니다.

blakecrosley.com은 FastAPI + Jinja2 + HTMX + Alpine.js + 순수 CSS로 운영됩니다. webpack 없음. Vite 없음. Rollup 없음. TypeScript 컴파일러 없음. Babel 없음. PostCSS 없음. Tailwind 없음. package.json 없음. node_modules/ 없음. 이 사이트는 20개의 인터랙티브 JavaScript 컴포넌트가 포함된 37개의 블로그 포스트, 20개의 가이드, 10개 언어 번역을 제공하며, Lighthouse에서 100/100/100/100을 기록합니다. Lighthouse 점수는 직접 확인할 수 있습니다. 어느 페이지에서든 PageSpeed Insights를 실행해 보십시오.11

요약

HTMX 커뮤니티에는 옹호론이 충분합니다. 부족한 것은 증거입니다. 여기에 제시된 수치는 상당한 분량의 콘텐츠, 인터랙티브 기능, 국제화를 갖추면서도 빌드 도구를 단 하나도 사용하지 않는 프로덕션 사이트에서 나온 것입니다. 트레이드오프는 솔직하게 다루며, 결론의 범위는 좁습니다. 1인 개발자나 소규모 팀이 운영하는 콘텐츠 중심 사이트에서 빌드 도구는 겪지도 않는 문제를 해결하면서 실제로 겪게 될 문제를 만들어냅니다. 공유 컴포넌트 라이브러리와 디자인 시스템 패키지를 갖춘 대규모 팀에서는 빌드 도구가 그 복잡성에 걸맞은 가치를 제공합니다. 그 경계선은 논쟁이 시사하는 것보다 명확합니다.


기술 스택

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)

트랜스파일링 없음. 트리 셰이킹 없음. 핫 모듈 교체 없음. 소스맵 없음. 작성한 JavaScript가 곧 배포되는 JavaScript입니다.


수치로 보는 결과

추정치가 아닌 실제 측정값입니다.

지표 blakecrosley.com 일반적인 Next.js 프로젝트 (저자 추정)1
의존성 Python 패키지 15개 npm 패키지 311개 (검증: npx create-next-app@latest, 2026년 2월)1
빌드 설정 파일 0개 5-8개 (next.config, tsconfig, postcss, tailwind, eslint, babel 등)
node_modules/ 크기 존재하지 않음 기본 187 MB (검증), 추가 패키지 포함 시 250-400 MB1
설치 시간 pip install -r requirements.txt: 8초 npm install: 30-90초
빌드 단계 없음 next build: 15-60초
배포 파이프라인 git push → 약 40초 후 배포 완료 git push → 설치 → 빌드 → 배포: 2-5분
CSS 파일 17개 파일, 10,846줄 (순수 CSS) Tailwind/Sass에서 생성, 출력은 프로젝트마다 다름
JS 파일 33개 파일, 8,819줄 (사람이 읽을 수 있는 코드) 번들링, 압축, 청크 분할: 프로덕션에서 읽기 불가능
Lighthouse 성능 100 명시적 최적화 없이 70-90 (Vercel의 자체 성능 문서 기준)13

15개의 Python 패키지에는 FastAPI, Jinja2, Pydantic 및 12개의 기타 패키지가 포함됩니다. 그중 빌드 도구는 없습니다. 컴파일러도 없습니다. 번들러도 없습니다.2


포기해야 하는 것들

솔직하려면 실제 비용을 나열해야 합니다. 이 비용들은 실재합니다.

TypeScript 없음. 이 프로젝트의 모든 .js 파일은 순수 JavaScript입니다. 타입 오류는 컴파일러가 아니라 테스트와 Claude Code의 분석이 잡아냅니다. 이 방식은 1인 개발자에게는 효과적입니다. 10명이 모듈 간에 컴포넌트 인터페이스를 공유하는 팀에서는 통하지 않을 것입니다.

핫 모듈 교체 없음. CSS 파일을 변경하면 브라우저를 수동으로 새로고침합니다. HTMX의 hx-boost는 AJAX로 본문 콘텐츠만 가져와 전체 페이지를 다시 불러오지 않고 교체하기 때문에, 네비게이션이 충분히 빨라서 전체 새로고침도 견딜 만합니다. 30초마다 시각적 디테일을 다듬는 프로젝트라면 HMR이 의미 있는 시간을 절약해 줄 것입니다.

트리 셰이킹 없음. 제가 작성한 JavaScript는 한 바이트도 빠짐없이 브라우저로 전송됩니다. 유틸리티 라이브러리에서 함수 하나만 가져오려 해도 파일 전체를 함께 보내야 합니다. 트리 셰이킹(번들러가 import 경로를 추적하여 어떤 모듈도 참조하지 않는 함수를 제거하는 데드 코드 제거)은 정의상 빌드 단계를 필요로 합니다. 이 제약이 규율을 강제합니다. 대규모 유틸리티 모듈 대신 작고 집중된 파일을 만들게 됩니다. 20개의 인터랙티브 컴포넌트는 자체 완결적이어야 하기 때문에 각각 130-450줄 정도입니다.3

npm 컴포넌트 라이브러리 없음. Radix 없음, shadcn/ui 없음, Headless UI 없음. 모든 인터랙티브 요소(보이드 시뮬레이션, 해밍 코드 시각화, 합의 시뮬레이터)는 직접 만들었습니다. 이 접근법이 가능한 이유는 인터랙티브 컴포넌트가 범용 UI 패턴이 아니라 특정한 교육 목적을 위해 존재하기 때문입니다.

npm 디자인 시스템 토큰 없음. 제 디자인 시스템은 전적으로 CSS 커스텀 프로퍼티로 존재합니다. 다른 프로젝트에서 패키지로 가져올 수 없습니다. 단일 사이트 시스템에서는 이 제약을 받아들일 수 있습니다. 여러 제품을 운영하는 조직에서는 그렇지 않습니다.

이 다섯 가지 트레이드오프는 1인 개발자가 운영하는 콘텐츠 중심 사이트에서는 받아들일 수 있습니다. 15명 규모의 엔지니어링 팀이 만드는 SaaS 제품에서는 받아들일 수 없을 것입니다.


얻게 되는 것들

빌드 실패 제로. 배포 파이프라인은 git push입니다. 피어 의존성 충돌로 npm install이 실패할 일이 없습니다. 제가 건드리지도 않은 파일의 TypeScript 오류로 next build가 실패할 일도 없습니다. Dependabot PR이 전이적 의존성을 업그레이드해서 빌드를 깨뜨릴 일도 없습니다.4

소스 보기로 디버깅. 브라우저에서 실행되는 JavaScript는 제가 작성한 JavaScript 그 자체입니다. 소스맵이 필요 없습니다. 컴파일된 출력과 원본 소스를 대응시킬 필요도 없습니다. 프로덕션에서 버그가 나타나면 배포된 파일을 직접 읽으면 됩니다.

즉각적인 로컬 시작. uvicorn app.main:app --reload는 2초 이내에 시작됩니다. 페이지를 보여주기 전에 설치, 컴파일, 번들링을 수행하는 npm run dev가 없습니다.

구체적인 요청 흐름. 블로그 포스트를 처음 방문하면 다음이 로드됩니다. HTML 문서 1개(gzip 압축 시 약 15KB), CSS 파일 1개(약 8KB), 페이지 전용 CSS 파일 1개(약 2KB), CDN의 HTMX(약 14KB, 캐시됨), CDN의 Alpine.js(약 14KB, 캐시됨), 그리고 해당 페이지의 인터랙티브 JS 컴포넌트(약 4-8KB)입니다. 총 전송량은 첫 방문 시 45-60KB, 캐시된 상태에서는 15-25KB입니다. 번들 분할도, 청크 협상도, 런타임 모듈 해석도 없습니다. 브라우저는 페이지에 필요한 것만 정확히 요청하고 그 외에는 아무것도 요청하지 않습니다.

Dependabot 노이즈 제로. package-lock.json이 없으므로 semver, ansi-regex, glob-parent처럼 직접 가져온 적은 없지만 의존성 트리의 세 단계 아래에 자리 잡은 패키지들을 업데이트하는 주간 PR도 없습니다.

미래에도 작동하는 프론트엔드. 클라이언트 측 코드는 10년 후에도 작동할 것입니다. HTML은 HTML입니다. CSS는 CSS입니다. JavaScript는 JavaScript입니다. Webpack 4 → 5 마이그레이션도, Create React App 지원 중단도, Next.js App Router 마이그레이션도 없습니다. 플랫폼 자체가 표준입니다.5 다만 서버 측 의존성(FastAPI, Python, Railway)은 여전히 버전 관리와 간헐적인 업데이트가 필요합니다. No-build 접근법이 없애는 것은 프론트엔드 툴체인의 변동이지 백엔드 유지보수가 아닙니다.


아키텍처로서의 HTMX

HTMX에 대한 논의는 hx-get, hx-swap, hx-target 같은 문법에 집중됩니다. 이것은 잘못된 관점입니다. 아키텍처적 통찰의 핵심은 서버 렌더링된 HTML이 곧 API라는 것입니다.

전통적인 SPA 방식:

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

HTMX 방식:

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

서버가 최종 표현을 반환합니다. 클라이언트 측 상태 관리 없음, 직렬화/역직렬화 없음, 하이드레이션 없음. Jinja2 템플릿 자체가 컴포넌트입니다. FastAPI 엔드포인트 자체가 API입니다. 세 개의 레이어가 아닌 하나의 레이어입니다.6

아키텍처적 영향은 연쇄적으로 이어집니다. 세 가지가 사라지며, 각각은 버그 하나가 아니라 문제의 범주 전체를 없앱니다.

JSON 경계 없음. 응답 형태 불일치, null과 undefined 사이의 모호함, 날짜 직렬화의 불일치가 사라집니다. TypeScript와 Zod는 이런 버그를 막기 위해 존재합니다. HTMX는 JSON 대신 HTML을 반환함으로써 이 범주 자체를 없앱니다.

클라이언트 측 상태 관리 없음. 서버 상태와 클라이언트 상태를 일관되게 유지하는 것은 SPA 개발에서 가장 어려운 부분입니다. HTMX는 신뢰할 수 있는 정보원을 서버 하나로 두어 이 문제를 제거합니다.

하이드레이션 없음. 페이지가 서버 HTML을 렌더링한 뒤 JavaScript 프레임워크가 클라이언트 측에서 다시 렌더링하면서 화면이 깜빡이는 “불쾌한 골짜기”가 존재하지 않습니다. 서버의 HTML이 최종 출력입니다.

구체적으로 비교하면 차이가 드러납니다. 입력과 동시에 검색하는 입력창을 두 가지 방식으로 만들어 보겠습니다.

React + 빌드 도구 방식(JSX, 트랜스파일링 필요):

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

HTMX + 서버 렌더링 방식(순수 HTML, 빌드 단계 없음):

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

HTMX 버전에는 클라이언트 상태도, 직렬화 경계도, 빌드 단계도 없습니다. 서버가 최종 HTML을 반환합니다. 브라우저가 그것을 끼워 넣습니다. 상호작용 전체가 템플릿 8줄과 Python 5줄로 끝납니다.

이 패턴은 복리 엔지니어링 원칙에 그대로 대응됩니다. 각 인프라 구성 요소는 정확히 하나의 일만 하며, 구성 요소들은 서로 간섭하지 않고 조합됩니다. 템플릿은 HTML을 렌더링합니다. 라우트는 그것을 반환합니다. HTMX가 그것을 끼워 넣습니다. 이 구성 요소들을 조율하는 빌드 단계가 없는 이유는 조율이 필요하지 않기 때문입니다.

더 복잡한 예: 유효성 검사가 있는 다단계 폼

입력과 동시에 검색하는 기능은 HTMX의 대표적인 데모입니다. 다단계 폼은 이 패턴을 프로덕션 수준의 복잡도로 보여줍니다. 서버 측 유효성 검사, 조건부 단계 진행, 그리고 클라이언트 측 상태 관리 없이 요청 사이에 유지되는 상태가 그것입니다.

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

폼 상태는 서버가 소유합니다. 2단계는 1단계가 서버 측 유효성 검사를 통과한 뒤에만 렌더링됩니다. 클라이언트 측 조건부 렌더링도, 폼 상태 라이브러리도, useReducer도 없습니다. 유효성 검사 오류가 나면 현재 단계가 오류 메시지가 붙은 같은 단계로 교체됩니다. 다단계 흐름 전체에서 클라이언트 측 JavaScript는 0줄입니다. React로 같은 흐름을 만들려면 필드마다 useState, 단계 카운터, 조건부 렌더링 로직, 클라이언트 측 유효성 검사(서버 유효성 검사의 중복), 그리고 API 직렬화 경계가 필요합니다. HTMX 버전은 유효성 검사 로직이 이미 있는 곳, 즉 서버에 상태를 둠으로써 이 다섯 가지 문제를 모두 없앱니다.


순수 CSS로 충분합니다

제 디자인 시스템은 10개의 색상 토큰, 13단계의 타입 스케일, 8개의 간격 값을 사용하며, 모두 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;
}

Sass 컴파일 단계 없음. 유틸리티를 생성하는 Tailwind 설정 없음. 커스텀 문법을 변환하는 PostCSS 플러그인 없음. 브라우저가 이 값들을 직접 읽습니다. CSS 커스텀 프로퍼티에는 전처리기 변수에 없는 능력이 있습니다. DOM을 따라 캐스케이드되고, 부모 요소에서 상속되며, 미디어 쿼리에서 재정의하거나 런타임에 컴포넌트 단위로 범위를 지정할 수 있습니다. Sass 변수는 정적인 값으로 컴파일된 뒤 사라집니다. 커스텀 프로퍼티는 살아 있는 채로 남기 때문에, 테마 전환이나 다크 모드 토글 하나로 파생된 모든 값이 재컴파일 없이 바뀝니다.7

이 사이트의 아름다움과 브루탈리즘 미학(완전한 검정 위의 흰색, 네 단계의 불투명도)은 제약에서 탄생했습니다. 색상 팔레트에 기댈 수 없을 때 타이포그래피가 위계를 담당합니다. 컴포넌트 그림자에 기댈 수 없을 때 여백이 구조를 만듭니다. 제약이 곧 디자인입니다.8


CLS 해결 과정

Lighthouse 여정은 no-build의 진짜 비용 하나를 드러냈습니다. 크리티컬 CSS 추출에 직접 만든 Python 스크립트가 필요했던 것입니다. Next.js 프로젝트에서는 프레임워크가 이를 자동으로 처리합니다.

구체적인 버그는 이렇습니다. 모바일 미디어 쿼리가 CSS 커스텀 프로퍼티를 재정의했습니다(--gutter: 48px → --gutter: 24px). 크리티컬 CSS에는 데스크톱 값은 포함되었지만 모바일 재정의는 포함되지 않았습니다. 그래서 모바일에서는 히어로 영역이 48px 패딩으로 렌더링되었다가 전체 스타일시트가 로드되면서 24px로 이동했고, CLS가 0.493이 되었습니다.

수정은 미디어 쿼리 재정의까지 포함해 크리티컬 CSS를 추출하는 12줄의 Python이었습니다.

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

조사에는 3시간이 걸렸습니다. 수정 자체는 20분이었습니다. 빌드 도구였다면 이를 자동으로 처리했을 것입니다.

솔직하게 따져 보면 이렇습니다. 빌드 도구는 수동으로 할 수 있는 일을 자동화하지만, 수동 방식은 문제가 생길 때 디버깅 시간이라는 비용을 치릅니다. 관건은 자동화의 비용(복잡성, 의존성, 빌드 실패, 마이그레이션 변동)이 수동 작업의 비용(간헐적인 디버깅)을 넘어서는가입니다.

이 사이트에서는 수동 작업의 비용이 더 낮았습니다. 3년 동안 CLS 버그 1건, 디버깅 3시간이었습니다.10 대안(빌드 파이프라인 유지)이었다면 의존성 업데이트, 호환성을 깨는 변경, 설정 유지보수에 누적으로 더 많은 시간을 썼을 것입니다.


이 방식을 사용하지 말아야 할 때

No-build 접근법은 다음과 같은 경우에 맞지 않습니다.

대규모 팀. TypeScript의 가치는 팀 규모에 비례해 커집니다.9 10명의 개발자가 컴포넌트 인터페이스를 공유할 때, 컴파일 타임 타입 검사는 런타임 테스트로는 너무 늦게 발견되는 통합 버그를 막아 줍니다. 1인 개발자는 시스템 전체를 머릿속에 담아 둘 수 있습니다. 팀은 그럴 수 없습니다.

디자인 시스템 패키지. 여러 제품이 디자인 시스템을 사용한다면, 그 시스템은 적절한 버전 관리, 트리 셰이킹, 빌드 파이프라인을 갖춘 npm 패키지여야 합니다. 단일 스타일시트 안의 CSS 커스텀 프로퍼티는 저장소를 넘나들며 조합되지 않습니다.

복잡한 클라이언트 상태. 애플리케이션에 풍부한 클라이언트 측 상태(드래그 앤 드롭 인터페이스, 실시간 협업, 오프라인 우선 데이터)가 있다면, React나 Svelte 같은 프레임워크가 그 복잡성에 걸맞은 가치를 제공합니다. HTMX는 클라이언트 상태를 서버 왕복으로 대체하며, 이 방식은 지연 시간이 중요해지기 전까지만 통합니다.

npm 생태계 라이브러리. Radix 프리미티브, Framer Motion, TanStack Query가 필요하다면 빌드 파이프라인이 필요합니다. 세 가지 모두 번들러를 전제로 합니다. 번들러 없이 사용하는 것은 고통스러운 수준에서 불가능한 수준까지 다양합니다.

경계선은 논쟁이 시사하는 것보다 단순합니다. 애플리케이션이 주로 서버가 렌더링하는 콘텐츠라면 빌드 도구는 오버헤드입니다. 애플리케이션이 주로 클라이언트가 관리하는 상태라면 빌드 도구는 인프라입니다.

판단 기준: 빌드 도구가 필요합니까?

다음 네 가지 질문에 답해 보십시오.

  1. 다섯 명이 넘는 개발자가 JavaScript 인터페이스를 공유합니까? 그렇다면 TypeScript의 컴파일 타임 타입 검사가 런타임 테스트로는 너무 늦게 발견되는 통합 버그를 막아 줍니다. 빌드 단계를 추가하십시오.

  2. 애플리케이션이 복잡한 클라이언트 측 상태를 관리합니까? 드래그 앤 드롭, 실시간 협업, 오프라인 우선 데이터가 (있으면 좋은 기능이 아니라) 핵심 기능이라면, React나 Svelte 같은 프레임워크가 그 복잡성에 걸맞은 가치를 제공합니다. 빌드 단계를 추가하십시오.

  3. 여러 제품이 공유 컴포넌트 라이브러리를 사용합니까? 그렇다면 그 라이브러리에는 npm 패키징, 시맨틱 버저닝, 트리 셰이킹이 필요합니다. 빌드 단계를 추가하십시오.

  4. 번들러를 전제로 하는 npm 생태계 라이브러리에 의존합니까? Radix, Framer Motion, TanStack Query 같은 라이브러리가 제품의 핵심이라면 빌드 파이프라인은 필수입니다.

네 가지 답이 모두 “아니요”라면 no-build 접근법은 실현 가능합니다. 하나라도 “예”라면 빌드 도구는 실제로 겪고 있는 문제를 해결해 줍니다. 실수는 네 가지 답이 모두 “아니요”인데도 빌드 도구를 추가하는 것입니다. 그것은 겪지도 않는 문제를 해결하면서, 실제로 떠안게 될 의존성 관리 부담을 만들어냅니다.

연습: 현재 프로젝트를 점검해 보십시오. du -sh node_modules/(또는 그에 해당하는 명령)와 wc -l package-lock.json을 실행하고 두 숫자를 적어 두십시오. 그런 다음 빌드 파이프라인의 기능 중 (개발자 경험이 아니라) 사용자에게 직접 도움이 되는 기능 세 가지를 나열해 보십시오. 세 가지를 꼽을 수 없다면, 그 파이프라인은 제품보다 툴체인을 위해 일하고 있는지도 모릅니다. 숫자 자체가 나쁜 것은 아닙니다. 그 숫자는 복잡성의 측정값이며, 복잡성은 스스로 존재 가치를 증명해야 합니다.


핵심 요점

1인 개발자와 소규모 팀을 위해:

  • 증거는 논증이 아니라 사이트 그 자체입니다. blakecrosley.com은 37개의 포스트, 20개의 인터랙티브 컴포넌트, 20개의 가이드, 10개 언어를 빌드 도구 없이 완벽한 Lighthouse 점수로 제공합니다. 수치는 검증할 수 있습니다.

  • No-build의 솔직한 비용은 간헐적인 디버깅입니다. CLS 버그를 고치는 데 3시간이 걸렸습니다. 빌드 도구였다면 자동으로 처리했을 것입니다. 3년 동안 누적된 디버깅 시간은 빌드 파이프라인이 요구했을 누적 유지보수 시간보다 훨씬 적었습니다.

  • 제약이 디자인을 만듭니다. 색상을 쓰지 않으니 타이포그래피가 위계를 담당하게 되었습니다. 빌드 도구를 쓰지 않으니 단순하고 자체 완결적인 JavaScript를 쓰게 되었습니다. 최고의 제약은 필요해지기 전에 스스로 선택한 제약입니다.

기술 스택 선택을 검토하는 팀 리더를 위해:

  • 빌드 도구는 팀 규모의 문제를 해결합니다. TypeScript, 트리 셰이킹, 컴포넌트 라이브러리는 여러 개발자가 인터페이스를 공유할 때 그 복잡성에 걸맞은 가치를 발휘합니다. 콘텐츠 중심 사이트를 만드는 1인 개발자에게는 이런 문제가 없습니다.

  • HTMX의 진정한 기여는 아키텍처에 있습니다. 서버 렌더링된 HTML을 API로 삼으면 클라이언트 상태 관리, 직렬화, 하이드레이션이 사라집니다. 문법은 이 통찰에 비하면 부차적입니다.


자주 묻는 질문

HTMX는 실제 웹 애플리케이션의 프로덕션에서 쓸 만합니까?

그렇습니다. HTMX는 2020년부터 안정적으로 유지되어 왔으며, 여러 산업의 기업들이 프로덕션에서 사용하고 있습니다. 창시자인 Carson Gross는 하위 호환성을 핵심 설계 원칙으로 지키고 있으며, HTMX 문서는 “htmx는 시맨틱 버저닝을 따르며 메이저 버전 안에서는 기존 애플리케이션을 깨뜨리지 않는다”라고 명시합니다.14 라이브러리 자체는 압축 및 gzip 기준 14KB이고, 의존성이 전혀 없으며, 시맨틱 버저닝을 따릅니다. blakecrosley.com은 3년 동안 HTMX를 프로덕션에서 운영하면서 HTMX 관련 버그를 한 건도 겪지 않았습니다. 마주친 문제는 모두 라이브러리가 아니라 애플리케이션 로직에 있었습니다.

빌드 단계 없이 TypeScript를 사용할 수 있습니까?

부분적으로는 가능합니다. TypeScript 파일은 tsc --noEmit으로 출력 파일을 만들지 않고 타입 검사를 할 수 있으므로, 트랜스파일러가 아닌 린터로서 컴파일 타임 타입 검사를 얻을 수 있습니다. 그러나 브라우저는 .ts 파일을 직접 실행할 수 없기 때문에, TypeScript를 브라우저에 제공하려면 여전히 빌드 단계가 필요합니다. 대안은 순수 .js 파일에 JSDoc 타입 주석을 다는 것이며, TypeScript는 이를 컴파일 없이 검사할 수 있습니다. 이 방식은 개발 중에는 타입 안전성을 제공하면서도 배포되는 것은 표준 JavaScript입니다.

이 접근법은 Astro나 11ty와 비교하면 어떻습니까?

Astro와 11ty는 중간 지점에 있습니다. 둘 다 클라이언트 JavaScript가 최소한이거나 아예 없는 순수 HTML을 생성하는 정적 사이트 생성기이지만, 여전히 빌드 단계(Node.js, npm install, 빌드 명령)가 필요합니다. No-build 접근법은 그 빌드 단계를 완전히 없앱니다. 서버가 요청마다 HTML을 렌더링하기 때문입니다. 트레이드오프는 이렇습니다. Astro와 11ty는 더 빠른 정적 페이지를 만들어 냅니다(서버 연산이 없으므로). 반면 FastAPI + HTMX는 동적 콘텐츠(사용자별 데이터, 폼 제출, 실시간 업데이트)를 API 레이어 없이 기본적으로 처리합니다.

웹 개발 팀이 빌드 도구와 npm 없이 배포할 수 있습니까?

팀이 무엇을 만드느냐에 달려 있습니다. 콘텐츠 중심 사이트와 내부 도구라면 2-5명 규모의 팀이 서버 렌더링 HTML과 순수 CSS로 빌드 도구 없이 성공적으로 배포해 왔습니다. 가장 먼저 발목을 잡는 제약은 공유 컴포넌트 인터페이스입니다. TypeScript가 없으면 두 개발자가 어떤 함수의 기대 입력에 대해 서로 다르게 이해하고 있어도 컴파일러가 이를 잡아내지 못합니다. 현실적인 경계는 공유 JavaScript를 다루는 개발자가 5-8명 정도일 때입니다. 그 이상이면 TypeScript와 컴포넌트 라이브러리가 그 복잡성에 걸맞은 가치를 발휘합니다.


JavaScript 의존성의 비용은 이 저자만의 관찰이 아닙니다. Potvin, R.과 Levenberg, J.(2016)의 “Why Google Stores Billions of Lines of Code in a Single Repository”는 대규모 의존성 관리가 조직에 안기는 비용을 기록했습니다.12 개별 프로젝트 수준에서는 npm 생태계의 깊은 의존성 구조가 바로 여기서 설명한 유지보수 부담을 만들어 냅니다. 개발자가 선택한 적 없는 전이적 의존성이, 개발자가 감당해야 하는 업데이트 압박을 만드는 것입니다.

이 글은 블로그의 디자인 섹션과 엔지니어링 섹션을 잇습니다. 디자인 결정은 아름다움과 브루탈리즘, 스타트업을 위한 디자인 시스템, 타입 스케일에서 다룹니다. 엔지니어링 측정값은 Lighthouse 만점과 복리 엔지니어링에 있습니다. 바이브 코딩 포스트에서는 이 철학이 AI 지원 개발의 어디에 적용되는지 살펴봅니다.



  1. “일반적인 Next.js 프로젝트” 열은 저자의 5개 이상 Next.js 프로젝트 경험(2021-2024)과 커뮤니티에서 보고된 일반적인 수치를 반영합니다. 참고로, 새로 만든 npx create-next-app@latest(Next.js 15, 2026년 2월 테스트)는 node_modules/에 311개의 패키지를 설치하며 총 187 MB입니다. 표의 311개 패키지와 187 MB가 바로 이 측정된 기준입니다. 의존성이 추가된 프로덕션 프로젝트는 더 커지는 경향이 있으며, 표의 250-400 MB 범위는 거기에서 나온 것입니다. 개별 프로젝트에 따라 크게 다를 수 있습니다. ↩↩↩

  2. 2026년 2월 기준 전체 의존성 목록: fastapi, uvicorn, starlette, pydantic, pydantic-settings, jinja2, markdown, pygments, beautifulsoup4, lxml, nh3, resend, python-multipart, httpx, analytics-941. 빌드 도구 제로. 컴파일러 제로. 번들러 제로. ↩

  3. 평균 컴포넌트 크기(130-450줄)는 2026년 2월 기준 /static/js/의 20개 인터랙티브 JS 파일에서 측정했습니다. 크기는 132줄(compound-interest-mind.js)부터 450줄(subtraction-machine.js)까지이며, 1,666줄인 arcade.js는 예외적인 값입니다. ↩

  4. 저자의 Next.js 프로젝트 유지보수 경험에 따르면, JavaScript 생태계는 활발한 프로젝트에 대해 월 15-25개의 Dependabot PR을 생성하며, 대부분은 개발자가 직접 가져온 적 없는 전이적 의존성을 업데이트합니다. 이 수치는 직접 관찰에 의한 추정치이며 독립적으로 검증된 벤치마크가 아닙니다. ↩

  5. 웹 플랫폼(HTML, CSS, JavaScript)은 30년 동안 하위 호환성을 유지해 왔습니다. 1996년의 페이지도 2026년의 Chrome에서 여전히 렌더링됩니다. 팀 버너스리는 이를 설계 원칙으로 표현했습니다: “a browser should be backwards-compatible, in that it should be able to read an earlier version of the language.” w3.org/DesignIssues/Principles 참조. ↩

  6. HTMX 창시자 Carson Gross는 이를 “hypermedia as the engine of application state”(HATEOAS)라고 표현합니다. htmx.org 에세이와 Gross, Stepinski, Cotter의 Hypermedia Systems(2023)를 참조하십시오: hypermedia.systems. ↩

  7. CSS 커스텀 프로퍼티(CSS 변수)는 전 세계 브라우저의 97% 이상에서 지원됩니다. 출처: caniuse.com/css-variables. 사용하는 데 컴파일 단계가 필요하지 않습니다. ↩

  8. “디자인 도구로서의 제약”이라는 원칙에는 오랜 역사가 있습니다. 찰스 임스: “Design depends largely on constraints.” 영화의 도그마 95 운동은 도구를 제거하는 것(인공 조명 금지, 후반 작업 금지)이 스토리텔링을 빈약하게 만드는 것이 아니라 더 정직하게 만든다는 것을 증명했습니다. en.wikipedia.org/wiki/Dogme_95 참조. ↩

  9. 2024 Stack Overflow 개발자 설문조사에서 TypeScript는 가장 많이 사용되는 프로그래밍 언어 상위 5위 안에 들었으며, 가장 널리 채택된 JavaScript 상위 집합이었습니다. 설문의 방법론과 전체 결과는 survey.stackoverflow.co/2024/에 있습니다. TypeScript 채택이 팀 규모와 상관관계가 있다는 관찰은 업계 관행에서 저자가 추론한 것이며, 설문의 직접적인 결과가 아닙니다. ↩

  10. 이 사이트의 git 기록은 2023년 3월에 시작됩니다. “3년”이라는 수치는 Railway에 처음 배포한 시점(2023년 3월)부터 2026년 2월까지의 기간을 반영합니다. “CLS 해결 과정” 섹션에 기록된 CLS 버그는 이 기간 동안 프로덕션에 영향을 준 유일한 CSS 문제입니다. ↩

  11. Google PageSpeed Insights(pagespeed.web.dev)는 공개된 모든 URL에 대해 Lighthouse 감사를 실행합니다. 이 도구는 성능, 접근성, 권장사항, SEO를 0-100 척도로 테스트합니다. blakecrosley.com은 2026년 2월 기준 네 가지 범주 모두에서 100점을 받았습니다. 결과는 누구나 검증할 수 있으며 자체 보고된 것이 아닙니다. ↩

  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. Google이 모노레포 방식을 택한 동기의 일부는 수천 개의 프로젝트에 걸쳐 의존성 버전을 관리하는 데 드는 조직적 비용이었습니다. 이는 개별 프로젝트 수준에서 node_modules/ 비대화를 낳는 것과 같은 힘입니다. 이 논문은 의존성 관리가 직접 의존성이 아니라 전이적 의존성의 수에 비례하여 엔지니어링 시간을 소모한다는 점을 기록합니다. ↩

  13. Vercel의 Next.js 성능 문서는 기본 Lighthouse 점수가 애플리케이션의 복잡도에 따라 달라진다는 점을 인정하고, 90점 이상을 얻기 위한 구체적인 최적화(이미지 최적화, 폰트 로딩, 코드 분할 설정)를 권장합니다. nextjs.org/docs/app/building-your-application/optimizing 참조. 70-90이라는 범위는 이러한 최적화를 적용하기 전, 기본 설정 그대로인 새 create-next-app 프로젝트를 반영합니다. 이는 Next.js GitHub 토론에서 보고된 커뮤니티 벤치마크와도 일치합니다. ↩

  14. HTMX의 버전 관리 정책과 하위 호환성 약속은 htmx.org/migration-guide-htmx-1/에 문서화되어 있습니다. 1.x에서 2.x로의 마이그레이션 가이드는 이 프로젝트의 접근 방식을 보여 줍니다. 호환성을 깨는 변경은 메이저 버전으로 한정되고, 명확하게 문서화되며, 마이그레이션 도구가 함께 제공됩니다. Carson Gross는 여러 컨퍼런스 강연과 Hypermedia Systems(2023)에서 이 하위 호환성 원칙을 밝혔습니다. ↩

관련 게시물

신호 점수화 파이프라인: 결정론적 지식 분류

4개 차원에 걸쳐 노트를 점수화하고 7,700개 이상의 항목을 결정론적으로 라우팅하는 733줄의 Python 파이프라인. 알고리즘, 가중치, 그리고 솔직한 결과.

18 분 소요

76점에서 100점으로: 완벽한 Lighthouse 점수 달성기

개인 포트폴리오 사이트의 모바일 Lighthouse 성능 점수를 76점(CLS 0.493)에서 모든 카테고리 완벽한 100/100/100/100으로 개선한 과정을 소개합니다.

9 분 소요

잘못된 데이터베이스 결정의 15배 비용: 결정 타이밍에서 배운 교훈

세 시스템에서 데이터베이스 결정의 비용을 측정했습니다. 마이그레이션 비용은 3년간 15배 증가. 빠르게 결정할 때와 느리게 결정할 때의 프레임워크.

8 분 소요