Every adjacent pair in Nolan Lawson's framework cost ranking overlaps. All 11 of them — so his $2.67-to-$4.97 median ladder is real at the ends and noise in the middle.

Lawson did something the frontend world badly needed: he stopped arguing about frameworks from vibes and ran an actual benchmark. He had Opus 5.5 build the same small-but-non-trivial Pokemon app (PokeAPI, search, filter, game data) in 12 frameworks and meta-frameworks, 5 runs each, and reported median cost, tokens, wall time, lines of code, and Lighthouse scores. The post hit Hacker News' front page this weekend, and the headline ranking — Hono+htmx cheapest at $2.67, Angular most expensive at $4.97 — is already being quoted as a leaderboard. I didn't re-run his 60 agent builds (that would cost real money and a weekend). I re-ran his numbers, all 12 medians and all 12 ranges, in Python. The leaderboard mostly does not survive its own error bars.

The ranking that isn't

Here is the cost table, median with the full range of the 5 runs:

Hono+htmx $2.67 ($2.23-$3.19) Astro $2.76 ($2.16-$3.63) Nuxt $2.82 ($2.39-$4.25) Vanilla $2.98 ($2.24-$3.37) Next.js $3.14 ($2.58-$4.13) Qwik $3.27 ($2.35-$3.80) TanStack Start $3.54 ($3.11-$3.96) SolidStart $3.79 ($2.84-$4.81) React Router $3.81 ($2.82-$3.97) SvelteKit $4.28 ($3.59-$4.65) Gracile+Lit $4.65 ($3.92-$5.07) Angular $4.97 ($3.19-$6.82)

I checked each adjacent pair for range overlap — does the cheaper framework's most expensive run exceed the pricier framework's cheapest run? The answer, 11 times out of 11, is yes:

adjacent pairs with overlapping cost ranges: 11 of 11 cheapest single run in the whole table: Astro, $2.16 most expensive single run: Angular, $6.82 single-run spread: 3.16x (vs 1.86x for the medians)

Lawson himself flags one case of this — React Router's cheapest run ($2.82) beats Hono+htmx's most expensive ($3.19) — but the pattern is universal, not anecdotal. The Hono-vs-Astro gap that tops the leaderboard is 9 cents on medians, against ranges nearly a dollar wide. Nobody should switch frameworks over 9 cents.

That does not make the table useless. It makes it a two-tier result, not a twelve-rung ladder. The ends are robust: Angular's $4.97 median sits inside only one other framework's range (Gracile+Lit, up to $5.07), and Hono+htmx's $2.67 median sits inside six frameworks' ranges — meaning the cheap end is a crowded tie and the expensive end is genuinely alone. The defensible claim is "Angular, SvelteKit, and Gracile+Lit cost more to build with an agent than the rest," not "Hono beats Astro."

Code size really does drive agent cost — and unfamiliarity doubles it

Lawson's own thesis, stated in his conclusion, is that code size drives future agent cost because every later edit re-reads the codebase. His medians back him, with a twist. Correlating the 12 framework medians:

lines of code vs build cost: Pearson r = 0.825 lines of code vs tokens used: Pearson r = 0.805, Spearman rho = 0.804 build cost vs tokens used: Pearson r = 0.983 build cost vs wall time: Pearson r = 0.848

Cost is essentially tokens (r = 0.983 — no surprise, Claude Code bills tokens), and tokens track code size. But the interesting column is tokens per line of code, which Lawson doesn't publish:

tokens per line of generated code (median tokens / median LOC): Nuxt 2,721 tok/LOC Astro 2,827 tok/LOC Hono+htmx 3,109 tok/LOC Vanilla 3,351 tok/LOC Next.js 3,242 tok/LOC Qwik 3,234 tok/LOC TanStack Start 4,166 tok/LOC SolidStart 4,374 tok/LOC React Router 4,847 tok/LOC Angular 4,858 tok/LOC Gracile+Lit 5,265 tok/LOC SvelteKit 5,295 tok/LOC

There are two clusters, not a gradient. The cheap frameworks cost the agent roughly 2,700–3,400 tokens per line it eventually ships; the expensive ones cost 4,800–5,300 — about 1.7x more tokens per line. That is the fingerprint of unfamiliarity, not verbosity: Lawson notes SvelteKit agents read the v3 migration guide in every run because SvelteKit 3 is too new for Opus 5.5's training data, and Gracile agents cloned the repo or read compiled source from node_modules. The agent isn't writing more code in the expensive frameworks (LOC spread is only 1.47x, 1,370 to 2,009 lines). It is reading more before it writes each line. Two of his arithmetic claims check out exactly on this point: Hono+htmx's 1,370 lines are 68.2% of Angular's 2,009 — his "~70%" — and the range-width story matches, with Angular's cost range spanning 73% of its median ($3.19–$6.82) versus 24–36% for TanStack Start, SvelteKit, and Hono+htmx.

The user-facing side holds up better

If the cost ranking is shakier than it looks, the performance side is firmer. Lawson's JavaScript bytes shipped (median) run from Astro's 0 KiB to Next.js's 142 KiB, and his claim that LCP is "mostly a function of JavaScript bundle size" survives my check:

shipped JS vs Largest Contentful Paint: Pearson r = 0.849, Spearman rho = 0.881 Astro: 0 KiB -> 810 ms LCP Hono+htmx: 18 KiB -> 978 ms Qwik: 40 KiB -> 979 ms (the exception: SPA speed, MPA numbers) Next.js: 142 KiB -> 2,090 ms Angular: 93 KiB -> 1,954 ms

Qwik is the genuine exception he names: an SPA with client-side routing that scores with the MPA frameworks. Everything else lines up — and note what doesn't vary at all: Lighthouse performance scores are 97–100 and accessibility is 100 across all 12 frameworks on this small app. For a content app like this one, the agent builds something perfectly usable in every framework; the difference is purely what it costs to build and what it ships.

What I would actually take from this

Three things, in order of how much I trust them:

  1. Don't pick a framework on a median gap smaller than its range. The $2.67–$3.81 middle of this table is a tie. Anyone quoting "Hono beats Astro" or "Nuxt beats Vanilla" from these medians is reading noise as signal.
  2. Avoid the expensive tail if agent cost matters. Angular, SvelteKit, and Gracile+Lit are separated from the pack on both cost and tokens-per-line, and the mechanism — agents re-reading unfamiliar docs — is visible in Lawson's own run notes, not just in my correlations.
  3. Code size is a cost lever, but familiarity is the bigger one. The LOC spread is 1.47x; the tokens-per-line spread is up to 1.95x (2,721 to 5,295). A framework the model already knows is cheaper per line than a framework that merely generates fewer lines.

The honest caveats, which Lawson states himself and my re-analysis can't remove: this is one app (a content site, closer to Wikipedia than to Figma), one agent (Opus 5.5, high effort), one browser (Chromium), and 5 runs per framework (3 measurable for Angular, whose SSR builds twice rejected non-localhost behind the proxy). My correlations are computed over 12 medians, not 60 raw runs, so treat the r values as descriptive, not as significance tests. And the benchmark is, by his own admission, largely vibe-coded — he reviewed it, but a different app could reorder the middle completely.

That last caveat is actually the point of his post, and it survives my audit intact: the question "which framework is cheaper for agents?" finally has an experimental shape, with a public repo and a spec suite. The leaderboard will move as frameworks ship better MCPs and skills — Lawson suspects the current crop may be doing more harm than good — and the next person to run it should run more than 5 iterations. But if you re-run it, report the ranges next to the medians. The ranges are the result.

Sources: Nolan Lawson, "The AI cost of JavaScript frameworks" (October 28, 2026) — https://nolanlawson.com/2026/10/28/the-ai-cost-of-javascript-frameworks/ . All medians, ranges, and version numbers above are from that post's tables (framework versions in its addendum: Angular 22.2.3, Astro 7.4.2, Next.js 16.4.3 / React 19.3.1, SvelteKit 3.1.0, Nuxt 4.6.2, Hono 4.13.14 / htmx 2.0.11, and the rest). Correlations, ratios, tokens-per-line, and overlap counts are my own computation from those published tables; I did not re-run the agent builds.