Agents Saved React (Unfortunately)

There’s an article making the rounds about AI causing a repeat of frontend’s “lost decade.” The central claim is that agentic coding tools are “deskilling” developers the way JavaScript frameworks did before them.

Half of that is right.

The deskilling argument actually lands for agentic coding. When an AI writes your code and you accept it without reading it, you don’t need to understand what it’s doing to ship something. That’s a real concern.

But applying “deskilling” to React and the framework era? That’s where I disagree. The article’s own list of lost skills is worth reading back: semantic HTML, CSS, browser differences, accessibility, progressive enhancement, network performance. That’s exactly the list of things a good React developer still has to know. React didn’t remove those requirements. It repackaged them into a component model that’s more portable and easier to reason about at scale. The skills didn’t disappear. The syntax changed. That reads more like “old school dev mad at change” than a real critique.

Anyway. The bigger thing I’ve been chewing on is React itself.

DX rules, UX drools

I’ve spent years quietly hoping the frontend world would move on. Not because React is broken. It’s not. The developer experience is genuinely excellent. Component model, unidirectional data flow, a massive library ecosystem. You can build anything with it. Slowly, on a bad connection, but anything.

But “you can build anything” and “you should build this” aren’t the same claim. The answer to the second one is almost never React.

The performance story has been bad since the beginning. Shipping a runtime to the browser to reconcile a virtual DOM with the actual one is a strange thing to make the default, especially once browsers got good at the exact job React was hired to do. The virtual DOM was always a tradeoff, not a free win. And the framework made that tradeoff on the user’s behalf, not the developer’s. Bundle sizes ballooned. Time to interactive got worse. Developer experience kept improving while user experience slid in the other direction.

We were so close

Here’s what’s annoying: fine-grained reactivity has existed for years. Svelte figured this out. You write components, the compiler produces lean output, there’s no virtual DOM to reconcile. It’s faster. The bundles are smaller. The expensive work happens at build time instead of in the user’s browser. Svelte is excellent, and I genuinely enjoy working with it.

Solid went further and asked: what if you got Svelte-level performance but kept React’s mental model? Signals, composable primitives, JSX. Turns out you can have both. Solid routinely lands near the top of the framework benchmarks, right next to vanilla JavaScript. Solid is a great framework. Nobody uses it.

Preact shipped signals for the same reason back in 2022. And the React Compiler that Meta shipped in late 2024 is trying to automate, at build time, the memoization that compiler-first frameworks made unnecessary half a decade earlier. It doesn’t touch the core issue: the runtime and the reconciler still ship to the browser, and the compiler just re-renders less of the tree. It’s a stopgap with good marketing.

Around 2023 and into 2024, there was real momentum behind the idea that React would stop being the default. Not die. Just become one tool among several, chosen when it’s actually the right fit. SvelteKit was getting attention. Solid was maturing. The conversation felt like it was actually happening.

Then agents happened

When an AI is writing your code, it writes what it knows best. Models have more React training data than anything else in the frontend space, the patterns are exhaustively documented, and the community is enormous. Ask an agent to scaffold a component and you’re getting React, a useEffect that fires twice in development, and a package.json with thirty dependencies. That’s not a criticism, it’s just how it works.

It’s not even subtle. Someone asked eight different models and tools to build a frontend: Claude, GPT, Gemini, DeepSeek, Qwen, v0, Lovable, Bolt. They all landed on nearly the same answer. React, Next.js, TypeScript, Tailwind, shadcn/ui. The stack is a property of the training corpus, not a choice. And because the next model trains on the code this one generates, the corpus skews further toward React every cycle. The default reinforces itself.

So instead of the frontend world diversifying, it consolidated. React got a massive tailwind. Not the CSS kind.

Svelte and Solid are still out there and still measurably faster. They’re just not what the agent defaults to.

What bothers me most is the timing. Svelte 5 shipped with runes in October 2024. SolidStart hit 1.0 that May. Real alternatives existed with real communities. The moment when developers might have started making deliberate, performance-conscious framework choices arrived right as the era of developers writing code by hand started winding down.

AI coding tools get marketed as accelerators of innovation. But if you’re generating the same patterns from three years ago at ten times the speed, that’s not innovation. It’s just more of the same, faster.

The lost decade is here. It just comes with better autocomplete.