O Manifesto No-Build: Publicando Sem um Bundler

O texto a seguir não é um argumento para que você abandone suas ferramentas de build. É uma medição do que acontece quando você as abandona.

blakecrosley.com roda FastAPI + Jinja2 + HTMX + Alpine.js + CSS puro. Sem webpack. Sem Vite. Sem Rollup. Sem compilador TypeScript. Sem Babel. Sem PostCSS. Sem Tailwind. Sem package.json. Sem node_modules/. O site serve 37 posts de blog com 20 componentes JavaScript interativos, 20 guias, traduções em dez idiomas e pontua 100/100/100/100 no Lighthouse. Você mesmo pode verificar a pontuação no Lighthouse: rode o PageSpeed Insights em qualquer página.11

TL;DR

A comunidade HTMX tem defensores de sobra. O que falta é evidência. Os números aqui vêm de um site em produção com conteúdo substancial, recursos interativos e internacionalização, tudo sem uma única ferramenta de build. Os tradeoffs são honestos, e a conclusão é específica: para sites orientados a conteúdo com um desenvolvedor solo ou uma equipe pequena, ferramentas de build resolvem problemas que você não tem e criam problemas que você passa a ter. Para equipes grandes com bibliotecas de componentes compartilhadas e pacotes de design system, ferramentas de build justificam sua complexidade. A fronteira é mais clara do que o debate sugere.


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

Sem transpilação. Sem tree shaking. Sem hot module replacement. Sem source maps. O JavaScript que você escreve é o JavaScript que vai para produção.


Os números

Aqui estão as métricas reais, não estimativas:

Métrica blakecrosley.com Projeto Next.js típico (estimativa do autor)1
Dependências 15 pacotes Python 311 pacotes npm (verificado: npx create-next-app@latest, fev. 2026)1
Arquivos de configuração de build 0 5-8 (next.config, tsconfig, postcss, tailwind, eslint, babel etc.)
Tamanho do node_modules/ Não existe 187 MB de base (verificado), 250-400 MB com acréscimos1
Tempo de instalação pip install -r requirements.txt: 8 segundos npm install: 30-90 segundos
Etapa de build Nenhuma next build: 15-60 segundos
Pipeline de deploy git push → no ar em ~40 segundos git push → install → build → deploy: 2-5 minutos
Arquivos CSS 17 arquivos, 10.846 linhas (CSS puro) Gerados a partir de Tailwind/Sass, saída varia
Arquivos JS 33 arquivos, 8.819 linhas (legíveis por humanos) Empacotados, minificados, divididos em chunks: ilegíveis em produção
Performance no Lighthouse 100 70-90 sem otimização explícita (segundo a própria documentação de performance da Vercel)13

Os 15 pacotes Python incluem FastAPI, Jinja2, Pydantic e outros 12. Nenhum é uma ferramenta de build. Nenhum é um compilador. Nenhum é um bundler.2


O que você perde

Honestidade exige listar os custos reais. E eles são reais.

Sem TypeScript. Cada arquivo .js deste projeto é JavaScript puro. Quem pega erros de tipo são os testes e a análise do Claude Code, não um compilador. A abordagem funciona para um desenvolvedor solo. Não funcionaria para uma equipe de 10 pessoas compartilhando interfaces de componentes entre módulos.

Sem Hot Module Replacement. Quando altero um arquivo CSS, atualizo o navegador manualmente. O hx-boost do HTMX deixa a navegação rápida o bastante para que atualizações completas sejam toleráveis, porque ele busca via AJAX apenas o conteúdo do body e faz a troca sem recarregar a página inteira. Em um projeto em que estou iterando em detalhes visuais a cada 30 segundos, o HMR economizaria um tempo considerável.

Sem tree shaking. Cada byte de JavaScript que escrevo vai para o navegador. Não consigo importar uma única função de uma biblioteca utilitária sem enviar o arquivo inteiro. Tree shaking (eliminação de código morto pelo bundler, que rastreia os caminhos de importação e remove funções que nenhum módulo referencia) exige, por definição, uma etapa de build. A restrição impõe disciplina: arquivos pequenos e focados em vez de grandes módulos utilitários. Os 20 componentes interativos têm em média 130-450 linhas cada, porque precisam ser autocontidos.3

Sem biblioteca de componentes do npm. Sem Radix, sem shadcn/ui, sem Headless UI. Cada elemento interativo (a simulação de boids, o visualizador de código de Hamming, o simulador de consenso) é construído à mão. A abordagem só é viável porque os componentes interativos servem a propósitos pedagógicos específicos, não a padrões genéricos de UI.

Sem tokens de design system do npm. Meu design system vive inteiramente em CSS custom properties. Não consigo importá-lo como pacote em outro projeto. Para um sistema de um único site, a restrição é aceitável. Para uma organização com vários produtos, não é.

Esses cinco tradeoffs são aceitáveis para um site orientado a conteúdo com um único desenvolvedor. Seriam inaceitáveis para um produto SaaS com uma equipe de engenharia de 15 pessoas.


O que você ganha

Zero falhas de build. O pipeline de deploy é git push. Nenhum npm install pode falhar por um conflito de peer dependency. Nenhum next build pode falhar por um erro de TypeScript em um arquivo que nem toquei. Nenhum PR do Dependabot atualiza uma dependência transitiva e quebra o build.4

Debug com View Source. O JavaScript que roda no navegador é o JavaScript que eu escrevi. Sem necessidade de source maps. Sem mapeamento da saída compilada para o código original. Quando um bug aparece em produção, leio diretamente o arquivo publicado.

Inicialização local instantânea. uvicorn app.main:app --reload sobe em menos de 2 segundos. Nada de npm run dev instalando, compilando e empacotando antes de mostrar uma página.

Cascata de requisições concreta. A primeira visita a um post do blog carrega: um documento HTML (~15KB com gzip), um arquivo CSS (~8KB), um arquivo CSS específico da página (~2KB), HTMX via CDN (~14KB, em cache), Alpine.js via CDN (~14KB, em cache) e o componente JS interativo da página (~4-8KB). Transferência total: 45-60KB na primeira visita, 15-25KB com cache. Sem divisão de bundle, sem negociação de chunks, sem resolução de módulos em tempo de execução. O navegador solicita exatamente o que a página precisa e nada mais.

Zero ruído do Dependabot. Sem package-lock.json, não há PRs semanais atualizando semver, ansi-regex ou glob-parent: pacotes que nunca importei diretamente, mas que vivem três camadas abaixo na minha árvore de dependências.

Frontend à prova de futuro. O código do lado do cliente vai funcionar daqui a 10 anos. HTML é HTML. CSS é CSS. JavaScript é JavaScript. Não existe migração de Webpack 4 → 5, descontinuação do Create React App ou migração para o App Router do Next.js. A plataforma é o padrão.5 As dependências do lado do servidor (FastAPI, Python, Railway) ainda exigem gerenciamento de versões e atualizações ocasionais: a abordagem no-build elimina a rotatividade do toolchain de frontend, não a manutenção do backend.


HTMX como arquitetura

O debate sobre HTMX se concentra na sintaxe: hx-get, hx-swap, hx-target. Esse é o enquadramento errado. O insight arquitetural é que HTML renderizado no servidor é a API.

Em uma SPA tradicional:

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

Com HTMX:

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

O servidor retorna a representação final. Sem gerenciamento de estado no cliente, sem serialização/desserialização, sem hidratação. O template Jinja2 é o componente. O endpoint FastAPI é a API. Uma camada, não três.6

As implicações arquiteturais se propagam em cascata. São três eliminações, e cada uma remove uma categoria inteira de problemas, não um único bug.

Sem fronteira JSON. Formatos de resposta incompatíveis, ambiguidades entre null e undefined e inconsistências na serialização de datas desaparecem. TypeScript e Zod existem para evitar esses bugs. O HTMX elimina a categoria inteira ao retornar HTML em vez de JSON.

Sem gerenciamento de estado no cliente. Manter o estado do servidor e o estado do cliente consistentes é a parte mais difícil do desenvolvimento de SPAs. O HTMX remove o problema ao ter uma única fonte de verdade: o servidor.

Sem hidratação. O “vale da estranheza”, em que a página renderiza o HTML do servidor e depois pisca enquanto o framework JavaScript a renderiza de novo no cliente, não existe. O HTML do servidor é a saída final.

Uma comparação concreta mostra a diferença. Aqui está um campo de busca com resultados enquanto você digita, construído de duas formas:

Com React + ferramentas de build (JSX, exige transpilação):

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

Com HTMX + renderização no servidor (HTML puro, sem etapa 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})

A versão com HTMX não tem estado no cliente, nem fronteira de serialização, nem etapa de build. O servidor retorna o HTML final. O navegador faz a troca. A interação inteira são oito linhas de template e cinco linhas de Python.

O padrão se encaixa diretamente no princípio da engenharia composta: cada peça de infraestrutura faz exatamente uma coisa, e as peças se compõem sem interferência. Um template renderiza HTML. Uma rota o retorna. O HTMX faz a troca. Nenhuma etapa de build coordena essas peças porque nenhuma coordenação é necessária.

Um exemplo mais complexo: formulário em várias etapas com validação

A busca enquanto você digita é a demonstração canônica do HTMX. Um formulário em várias etapas mostra o padrão com complexidade de produção: validação no servidor, avanço condicional entre etapas e estado preservado entre requisições sem gerenciamento de estado no cliente:

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

O servidor é dono do estado do formulário. A etapa 2 só é renderizada depois que a etapa 1 passa pela validação no servidor: sem renderização condicional no cliente, sem biblioteca de estado de formulário, sem useReducer. Erros de validação substituem a etapa atual pela mesma etapa com as mensagens de erro. O fluxo inteiro, com todas as etapas, usa zero JavaScript no cliente. Em um equivalente em React, o mesmo fluxo exigiria useState para cada campo, um contador de etapas, lógica de renderização condicional, validação no cliente (duplicando a validação do servidor) e uma fronteira de serialização de API. A versão com HTMX elimina essas cinco preocupações ao manter o estado onde a lógica de validação já mora: no servidor.


CSS puro é suficiente

Meu design system usa 10 tokens de cor, 13 passos de escala tipográfica e oito valores de espaçamento, todos como 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;
}

Sem etapa de compilação do Sass. Sem configuração do Tailwind gerando classes utilitárias. Sem plugins do PostCSS transformando sintaxe customizada. O navegador lê esses valores diretamente. CSS custom properties têm capacidades que as variáveis de pré-processadores não têm: elas se propagam em cascata pelo DOM, herdam valores dos elementos pais e podem ser sobrescritas em media queries ou restritas a componentes em tempo de execução. Variáveis do Sass compilam para valores estáticos e desaparecem. Custom properties continuam vivas, o que significa que uma única troca de tema ou de modo escuro altera todos os valores derivados sem recompilação.7

A estética de beleza e brutalismo deste site (branco sobre preto absoluto com quatro níveis de opacidade) nasce da restrição. Quando você não pode recorrer a uma paleta de cores, a tipografia carrega a hierarquia. Quando você não pode recorrer a sombras nos componentes, o espaço em branco cria a estrutura. A restrição é o design.8


A jornada do CLS

A jornada no Lighthouse expôs um custo genuíno do no-build: a extração de CSS crítico exigiu um script Python próprio. Em um projeto Next.js, o framework cuida disso automaticamente.

O bug específico: uma media query mobile sobrescrevia uma CSS custom property (--gutter: 48px → --gutter: 24px). O CSS crítico incluía o valor de desktop, mas não a sobrescrita mobile. No celular, o hero era renderizado com padding de 48px e depois mudava para 24px quando a folha de estilos completa carregava, produzindo um CLS de 0,493.

A correção foram 12 linhas de Python que extraem o CSS crítico incluindo as sobrescritas de media queries:

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

A investigação levou três horas. A correção em si levou 20 minutos. Uma ferramenta de build teria resolvido isso automaticamente.

A contabilidade honesta: ferramentas de build automatizam coisas que você pode fazer manualmente, mas a versão manual custa tempo de debugging quando quebra. A questão é se o custo da automação (complexidade, dependências, falhas de build, migrações constantes) supera o custo manual (sessões ocasionais de debugging).

Para este site, o custo manual tem sido menor. Três anos, um bug de CLS, três horas de debugging.10 A alternativa (manter um pipeline de build) teria consumido mais tempo acumulado em atualizações de dependências, breaking changes e manutenção de configuração.


Quando não usar esta abordagem

A abordagem no-build é a escolha errada para:

Equipes grandes. O valor do TypeScript cresce com o tamanho da equipe.9 Quando 10 desenvolvedores compartilham interfaces de componentes, a checagem de tipos em tempo de compilação evita bugs de integração que os testes em tempo de execução pegam tarde demais. Um desenvolvedor solo guarda o sistema inteiro na cabeça. Uma equipe não consegue.

Pacotes de design system. Se vários produtos consomem o seu design system, ele precisa ser um pacote npm com versionamento adequado, tree shaking e um pipeline de build. CSS custom properties em uma única folha de estilos não se compõem entre repositórios.

Estado complexo no cliente. Se a sua aplicação tem um estado rico no cliente (interfaces de drag-and-drop, colaboração em tempo real, dados offline-first), um framework como React ou Svelte justifica sua complexidade. O HTMX troca o estado no cliente por idas e voltas ao servidor, o que funciona até a latência começar a importar.

Bibliotecas do ecossistema npm. Se você precisa de primitivas do Radix, Framer Motion ou TanStack Query, você precisa de um pipeline de build. As três pressupõem um bundler. Usá-las sem um vai de doloroso a impossível.

A fronteira é mais simples do que o debate sugere: se a sua aplicação é principalmente conteúdo renderizado por um servidor, ferramentas de build são overhead. Se a sua aplicação é principalmente estado gerenciado por um cliente, ferramentas de build são infraestrutura.

Framework de decisão: você precisa de ferramentas de build?

Responda a estas quatro perguntas:

  1. Mais de cinco desenvolvedores compartilham interfaces JavaScript? Se sim, a checagem de tipos do TypeScript em tempo de compilação evita bugs de integração que os testes em tempo de execução pegam tarde demais. Adicione uma etapa de build.

  2. Sua aplicação gerencia estado complexo no cliente? Se drag-and-drop, colaboração em tempo real ou dados offline-first são recursos centrais (e não apenas desejáveis), um framework como React ou Svelte justifica sua complexidade. Adicione uma etapa de build.

  3. Vários produtos consomem uma biblioteca de componentes compartilhada? Se sim, essa biblioteca precisa de empacotamento npm, versionamento semântico e tree shaking. Adicione uma etapa de build.

  4. Você depende de bibliotecas do ecossistema npm que pressupõem um bundler? Se Radix, Framer Motion, TanStack Query ou bibliotecas semelhantes são centrais para o produto, um pipeline de build é obrigatório.

Se as quatro respostas forem “não”, a abordagem no-build é viável. Se qualquer resposta for “sim”, ferramentas de build resolvem um problema real que você tem. O erro é adicionar ferramentas de build quando as quatro respostas são “não”: resolver problemas que você não tem enquanto cria uma sobrecarga de gerenciamento de dependências que você passa a ter.

Exercício: audite seu projeto atual. Rode du -sh node_modules/ (ou o equivalente) e wc -l package-lock.json. Anote os dois números. Depois, liste os três recursos do seu pipeline de build que servem diretamente aos seus usuários (não à sua experiência de desenvolvimento). Se você não conseguir citar três, o pipeline talvez esteja servindo mais ao toolchain do que ao produto. Os números não são ruins em si: são uma medida de complexidade que precisa se pagar.


Principais conclusões

Para desenvolvedores solo e equipes pequenas:

  • A prova é o site, não o argumento. blakecrosley.com serve 37 posts, 20 componentes interativos, 20 guias e dez idiomas com zero ferramentas de build e pontuações perfeitas no Lighthouse. Os números são verificáveis.

  • O custo honesto do no-build é um debugging ocasional. O bug de CLS levou três horas para ser corrigido. Uma ferramenta de build teria resolvido isso automaticamente. Ao longo de três anos, o tempo acumulado de debugging foi muito menor do que o tempo acumulado de manutenção que um pipeline de build teria exigido.

  • Restrições produzem design. Sem cores, a tipografia teve que carregar a hierarquia. Sem ferramentas de build, o JavaScript teve que ser simples e autocontido. As melhores restrições são aquelas que você escolhe antes de precisar delas.

Para líderes técnicos avaliando escolhas de stack:

  • Ferramentas de build resolvem problemas de escala de equipe. TypeScript, tree shaking e bibliotecas de componentes justificam sua complexidade quando vários desenvolvedores compartilham interfaces. Um desenvolvedor solo construindo sites orientados a conteúdo não tem esses problemas.

  • A contribuição real do HTMX é arquitetural. HTML renderizado no servidor como API elimina o gerenciamento de estado no cliente, a serialização e a hidratação. A sintaxe é secundária em relação ao insight.


Perguntas frequentes

O HTMX está pronto para produção em aplicações web reais?

Sim. O HTMX é estável desde 2020 e é usado em produção por empresas de vários setores. Carson Gross, o criador, mantém a compatibilidade retroativa como princípio central de design, e a documentação do HTMX afirma explicitamente: “o htmx segue o versionamento semântico e não vai quebrar aplicações existentes dentro de uma versão principal.”14 A biblioteca em si tem 14KB minificada e com gzip, zero dependências e segue o versionamento semântico. blakecrosley.com roda HTMX em produção há três anos com zero bugs relacionados ao HTMX: todo problema encontrado estava na lógica da aplicação, não na biblioteca.

Posso usar TypeScript sem uma etapa de build?

Parcialmente. Arquivos TypeScript podem passar pela checagem de tipos com tsc --noEmit sem gerar arquivos de saída, o que transforma a checagem de tipos em tempo de compilação em um linter, e não em um transpilador. Porém, navegadores não executam arquivos .ts diretamente, então uma etapa de build continua necessária para servir TypeScript ao navegador. A alternativa são anotações de tipo JSDoc em arquivos .js comuns, que o TypeScript consegue checar sem compilação. Essa abordagem oferece segurança de tipos durante o desenvolvimento e entrega JavaScript padrão.

Como essa abordagem se compara ao Astro ou ao 11ty?

Astro e 11ty ocupam um meio-termo: são geradores de sites estáticos que produzem HTML puro com pouco ou nenhum JavaScript no cliente, mas ainda exigem uma etapa de build (Node.js, npm install, um comando de build). A abordagem no-build elimina essa etapa por completo: o servidor renderiza o HTML a cada requisição. O tradeoff: Astro e 11ty produzem páginas estáticas mais rápidas (sem processamento no servidor), enquanto FastAPI + HTMX lida nativamente com conteúdo dinâmico (dados específicos do usuário, envio de formulários, atualizações em tempo real) sem uma camada de API.

Uma equipe de desenvolvimento web consegue entregar sem ferramentas de build e sem npm?

Depende do que a equipe está construindo. Para sites orientados a conteúdo e ferramentas internas, equipes de 2-5 pessoas já entregaram com sucesso sem ferramentas de build, usando HTML renderizado no servidor e CSS puro. A restrição que pesa primeiro são as interfaces de componentes compartilhadas: sem TypeScript, dois desenvolvedores podem discordar sobre a entrada esperada de uma função sem que o compilador perceba. O limite prático fica em torno de 5-8 desenvolvedores trabalhando em JavaScript compartilhado. Acima disso, TypeScript e uma biblioteca de componentes justificam sua complexidade.


O custo das dependências de JavaScript não é uma observação exclusiva deste autor. Potvin, R. e Levenberg, J. (2016), em “Why Google Stores Billions of Lines of Code in a Single Repository”, documentaram os custos organizacionais do gerenciamento de dependências em escala.12 No nível de um projeto individual, a profundidade de dependências do ecossistema npm produz exatamente o fardo de manutenção descrito aqui: dependências transitivas que o desenvolvedor nunca escolheu criando uma pressão de atualização que o desenvolvedor precisa administrar.

O artigo faz a ponte entre as seções de Design e Engenharia do blog. As decisões de design aparecem em Beleza e Brutalismo, Design Systems para Startups e Escalas Tipográficas. As medições de engenharia estão em Pontuação Perfeita no Lighthouse e Engenharia Composta. O post sobre vibe coding explora onde essa filosofia se aplica ao desenvolvimento assistido por IA.



  1. A coluna “Projeto Next.js típico” reflete a experiência do autor em mais de 5 projetos Next.js (2021-2024) e normas relatadas pela comunidade. Como referência: um npx create-next-app@latest novo (Next.js 15, testado em fevereiro de 2026) instala 311 pacotes em node_modules/, totalizando 187 MB. Os 311 pacotes e 187 MB da tabela são essa base medida; projetos em produção com dependências adicionais tendem a ser maiores, e é daí que vem a faixa de 250-400 MB da tabela. Projetos individuais variam significativamente. ↩↩↩

  2. Lista completa de dependências em fevereiro de 2026: fastapi, uvicorn, starlette, pydantic, pydantic-settings, jinja2, markdown, pygments, beautifulsoup4, lxml, nh3, resend, python-multipart, httpx, analytics-941. Zero são ferramentas de build. Zero são compiladores. Zero são bundlers. ↩

  3. O tamanho médio dos componentes (130-450 linhas) foi medido a partir dos 20 arquivos JS interativos em /static/js/ em fevereiro de 2026. Os tamanhos variam de 132 linhas (compound-interest-mind.js) a 450 linhas (subtraction-machine.js), com arcade.js, de 1.666 linhas, como ponto fora da curva. ↩

  4. Com base na experiência do autor mantendo projetos Next.js, o ecossistema JavaScript gera 15-25 PRs do Dependabot por mês para um projeto ativo, a maioria atualizando dependências transitivas que o desenvolvedor nunca importou diretamente. O número é uma estimativa de observação direta, não um benchmark verificado de forma independente. ↩

  5. A plataforma web (HTML, CSS, JavaScript) mantém compatibilidade retroativa há 30 anos. Uma página de 1996 ainda renderiza no Chrome de 2026. Tim Berners-Lee articulou isso como um princípio de design: “a browser should be backwards-compatible, in that it should be able to read an earlier version of the language.” Veja w3.org/DesignIssues/Principles. ↩

  6. Carson Gross, criador do HTMX, enquadra isso como “hypermedia as the engine of application state” (HATEOAS). Veja os ensaios do htmx.org e o livro Hypermedia Systems (2023), de Gross, Stepinski e Cotter: hypermedia.systems. ↩

  7. CSS Custom Properties (variáveis CSS) são suportadas por mais de 97% dos navegadores no mundo. Fonte: caniuse.com/css-variables. Nenhuma etapa de compilação é necessária para usá-las. ↩

  8. O princípio da “restrição como ferramenta de design” tem uma longa história. Charles Eames: “Design depends largely on constraints.” O movimento Dogma 95 no cinema provou que remover ferramentas (sem iluminação artificial, sem pós-produção) produzia narrativas mais honestas, não menos. Veja en.wikipedia.org/wiki/Dogme_95. ↩

  9. A Stack Overflow Developer Survey de 2024 constatou que o TypeScript está entre as cinco linguagens de programação mais usadas e é o superset de JavaScript mais amplamente adotado. A metodologia e os resultados completos da pesquisa estão em survey.stackoverflow.co/2024/. A observação de que a adoção do TypeScript se correlaciona com o tamanho da equipe é uma inferência do autor a partir da prática do setor, não uma constatação direta da pesquisa. ↩

  10. O histórico git do site começa em março de 2023. O número “três anos” reflete o período entre o primeiro deploy na Railway (março de 2023) e fevereiro de 2026. O bug de CLS documentado na seção “A jornada do CLS” é o único problema de CSS com impacto em produção nesse período. ↩

  11. O Google PageSpeed Insights (pagespeed.web.dev) executa auditorias do Lighthouse em qualquer URL pública. A ferramenta testa Performance, Acessibilidade, Práticas recomendadas e SEO em uma escala de 0 a 100. blakecrosley.com pontua 100 nas quatro categorias em fevereiro de 2026. Os resultados são verificáveis publicamente, não autodeclarados. ↩

  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. A abordagem de monorepo do Google foi motivada em parte pelo custo organizacional de gerenciar versões de dependências em milhares de projetos: a mesma força que produz o inchaço do node_modules/ no nível de um projeto individual. O artigo documenta como o gerenciamento de dependências consome tempo de engenharia proporcional ao número de dependências transitivas, não ao de dependências diretas. ↩

  13. A documentação de performance do Next.js, da Vercel, reconhece que as pontuações padrão no Lighthouse variam conforme a complexidade da aplicação e recomenda otimizações específicas (otimização de imagens, carregamento de fontes, configuração de code splitting) para alcançar pontuações acima de 90. Veja nextjs.org/docs/app/building-your-application/optimizing. A faixa de 70-90 reflete um projeto create-next-app novo, com configurações padrão, antes de aplicar essas otimizações, o que é consistente com benchmarks da comunidade relatados nas discussões do Next.js no GitHub. ↩

  14. A política de versionamento do HTMX e seu compromisso com a compatibilidade retroativa estão documentados em htmx.org/migration-guide-htmx-1/. O guia de migração da 1.x para a 2.x demonstra a abordagem do projeto: breaking changes ficam restritas a versões principais, são documentadas com clareza e vêm acompanhadas de ferramentas de migração. Carson Gross já declarou o princípio da compatibilidade retroativa em várias palestras em conferências e em Hypermedia Systems (2023). ↩

Artigos relacionados

Pipeline de pontuação de sinais: triagem determinística de conhecimento

Um pipeline de 733 linhas em Python que pontua notas em quatro dimensões e roteia mais de 7.700 itens de forma determiní…

18 min de leitura

De 76 a 100: Alcançando uma Pontuação Perfeita no Lighthouse

Como um portfólio pessoal saiu de 76 no Lighthouse mobile, com CLS de 0,493, para um perfeito 100/100/100/100 em todas a…

9 min de leitura

Engenharia Composta: Como Minha Base de Código Acelera em Vez de Deteriorar

A maioria dos codebases desacelera ao crescer. O meu acelera. 95 hooks, 44 skills e 14 configs tornam cada feature mais …

10 min de leitura