Frameworks were built for humans. So what are they for now?

Every framework you know was designed for a reader who just stopped mattering: the human typing the code. AI fired that audience. The tempting conclusion is that frameworks are now dead weight — if the machine writes everything, go back to vanilla JS, CSS and HTML.

The conclusion is wrong, because frameworks were doing two jobs at once, and we only noticed one of them.

The job that died

The visible job was ergonomics. Nice syntax, less boilerplate, APIs that were pleasant to type. A whole decade of framework marketing was about "developer joy". JSX so your templates feel like code. Svelte so your components feel like nothing at all.

That job is dead. Nobody needs the code to be pleasant to type if nobody is typing it. Svelte optimized harder for human writability than anyone — and human writability is the criterion that just left the building.

The job that survived

The invisible job was coordination and verification. A React codebase has a predictable shape. Another developer — or another AI session, six months later — can navigate it. Vanilla JS at scale means every app invents its own architecture, and now the AI has to reverse-engineer bespoke conventions from scratch every time. The framework is context compression.

Here's the thing about a series of stateless AI sessions: it behaves exactly like a large team of decent developers with no shared memory. Everything we learned about making codebases survive such teams — strict types, explicit contracts, one way to do things — suddenly stopped being optional discipline and became the whole point.

Six things that matter now

Run any framework through this lens and six criteria keep coming up:

1. Static verifiability. Can correctness be checked without running the code? AI generates fast but can't "feel" that something is off. The compiler has to be the reviewer.
2. Locality of behavior. Everything the code does should be visible in the text near where it's written. Magic is poison — the AI reads the file you show it, and if the behavior lives in a convention somewhere else, it will confidently hallucinate.
3. Small context footprint. How much of the app do you need to load to safely change one file?
4. Training mass and stability. Boring but real: models write React better than Svelte 5 not because React is better, but because there is vastly more of it, and the API hasn't broken in years. A framework that ships breaking changes fights the model's priors forever.
5. Machine-readable feedback loops. The agentic loop is generate → run → read error → fix. Error message quality used to be DX. Now it's literally the AI's perception channel.
6. One way to do things. If the framework blesses five idioms, the AI will use all five across your codebase, one per session.

Notice what's not on the list: elegant syntax, terse APIs, joy.

A quick tour of the damage

JS. React + TypeScript scores surprisingly well — once you strip away Next.js, which is built on file-convention magic and rewards you with hydration errors nobody can read. Angular is the sleeper: its DI magic hurts locality, but at least its magic is checked by a compiler, and "one blessed way" is worth a lot when a hundred stateless sessions touch the code. Vue never beats React on any criterion and blesses two official API styles, so models happily mix them. Svelte is the cautionary tale: great design, tiny corpus, and the 4→5 break means AI keeps confidently writing last year's syntax.

Python. FastAPI and Django are mirror images. Django wins on the past — colossal training mass, an API so stable that 2015 code still runs. FastAPI wins on the present — Pydantic makes types load-bearing, validation errors are precise and machine-readable, wiring is explicit in the function signature. Greenfield with AI as the main author: FastAPI, not close.

Go. Here the framework barely matters, because the language already delivers the six criteria: static types, gofmt, explicit errors, the Go 1 compatibility promise — training data that never rots. stdlib net/http plus chi is probably the most AI-native backend stack that exists, and it got there by accident, by optimizing for large teams at Google with no shared context. Same problem shape.

CSS is the extreme case. CSS has the worst possible property for AI: it cannot fail loudly. Invalid property — silently ignored. Selector matches nothing — silence. The agentic loop breaks at "read error" because there is no error. And the cascade is literally action-at-a-distance as a design principle. BEM and friends were humans inventing discipline conventions to simulate scoping the language didn't have.

Which makes Tailwind the accidental champion. It was mocked for years as "inline styles with extra steps" — the criticism was readability and DRY, both human-typing concerns. The exact properties it was mocked for (everything visible in the element, no cascade, a fixed token vocabulary) are the ones that matter now. Tailwind is less an abstraction over CSS than a firewall against it.

One caveat, to be precise: Tailwind is one pick from a class — atomic CSS with a token-constrained vocabulary. Panda CSS and StyleX are architecturally better (typed tokens, compile-time errors) and practically worse, because their corpus is a rounding error next to Tailwind's. Same shape as Svelte vs React: right design, wrong training mass.

Where this lands

The threshold for "just use vanilla" has genuinely moved up. Small tools, internal dashboards, one-off pages — AI writes competent vanilla instantly, and skipping the build step is a real win. But for anything with state and a maintenance horizon, the logic points the other way entirely.

Frameworks aren't going away. They're changing audience. For twenty years they optimized for the human writing the code. Now they need to optimize for the machine writing it and the human verifying it — which means boring, explicit, statically checkable, stable. The properties that make a framework good for AI are exactly the ones that made it good for a large mediocre team. Nothing here is a new virtue. It's old discipline that stopped being optional.

Frameworks stop being tools for thinking less and become contracts for verifying more. The ones that survive won't be the ones that make typing pleasant. They'll be the ones that make correctness checkable.

And the strongest candidates were never designed for AI at all. They were designed for the second-worst reader of code we knew: a colleague with no context. Turns out we were practicing for this the whole time.