Think about the web in 2011. jQuery was the standard. PHP powered most of the internet. If you wanted a single-page application, you reached for Backbone.js and felt cutting-edge. Mobile-first was a phrase people were just starting to say out loud. The iPhone 4S had just come out. Responsive design was a blog post by Ethan Marcotte that most agencies hadn't read yet.

Now imagine dropping a modern LLM into that world. Not the ecosystem around it, not GitHub Copilot or ChatGPT's UI. Just the raw capability: a system that can generate working code from natural language descriptions, understand context across files, and produce reasonable solutions to most common programming problems.

Would we still have built React?

the spaghetti that would have been fine

The question sounds absurd at first. React solved real problems. Managing UI state in complex applications was genuinely painful in 2011. You had spaghetti jQuery callbacks mutating the DOM in seventeen places, and when something broke, you had to mentally trace through event handlers to figure out which one set the wrong class name on a div four layers deep. React's virtual DOM and component model weren't just convenient. They were a fundamentally better way to think about user interfaces.

But here's the thing. The pain React solved was the pain of humans writing and maintaining complex UI code. If an AI could generate the jQuery spaghetti fresh every time, correctly, from a description of the desired behavior, would the spaghetti still matter? You wouldn't need to trace through event handlers if you could just re-generate the whole interaction from scratch whenever the requirements changed. The virtual DOM solved a human coordination problem. With AI doing the coordination, the problem might never have become acute enough to demand a new paradigm.

fifteen years of bundlers we might never have needed

I think about webpack the same way. Webpack exists because JavaScript grew beyond what a single script tag could handle. We needed modules, and the browser didn't have them. So we built bundlers: first Browserify, then webpack, then Rollup, then Vite. Each generation solving problems the previous one created while adding its own new category of configuration hell. The entire bundler lineage is a fifteen-year arc of tooling built to manage complexity that humans created by writing lots of JavaScript files that needed to work together.

An AI in 2011 wouldn't have needed a bundler. It would have generated a single optimized output file. No import resolution, no tree-shaking, no code-splitting configuration. Just "here's the JavaScript your page needs." The entire concept of a build step for frontend code might never have emerged, because the build step exists to transform human-readable source into machine-optimal output. If the AI writes machine-optimal output directly, the transformation layer is unnecessary.

the world where we still use floats in 2026

CSS tells an even stranger version of this story. In 2011, we didn't have flexbox. We didn't have grid. We had floats. Making two divs the same height required either a JavaScript hack, a table layout that everyone agreed was semantically wrong, or the faux columns technique where you used a background image to simulate equal heights. Actual careers were partially defined by how well someone could wrangle CSS floats into behaving like a layout system.

If an AI could generate the correct float-based, clearfix-laden CSS for any layout description, nobody would have spent years pushing for flexbox. The browser vendors built flexbox because developers were in pain. But if the pain was invisible, absorbed by AI generating whatever horrifying CSS the browser actually needed, the pressure to evolve CSS itself would have been dramatically weaker. We might still be using floats in 2026, and they'd work fine, because no human would have to look at the code.

where my own argument falls apart

Actually, I need to push back on my own argument here. Some of these innovations weren't just about reducing human pain. React's component model changed how people thought about building interfaces. The idea that a button is a self-contained unit with its own state, markup, and behavior, composable like Lego blocks, is genuinely a better abstraction than anything that came before it. That's not a workaround for human limitations. That's a conceptual advance in how we model interactive systems.

The same is true for TypeScript. TypeScript didn't just make JavaScript less error-prone. It made it possible to express contracts between parts of a system in a way that JavaScript fundamentally couldn't. Even if an AI were writing all the code, types would still be valuable as a communication layer between the AI and the humans who need to understand what the system does. Maybe TypeScript would have emerged anyway, just for different reasons.

the tooling graveyard nobody planned

But I keep coming back to the sheer volume of tooling that exists purely because humans needed help managing what other humans wrote. ESLint, Prettier, Babel, PostCSS, Sass, Less, Tailwind, CSS-in-JS, CSS modules. Each of these is a response to a specific human difficulty with writing or maintaining frontend code. If the writing and maintaining were handled by AI, how many of these would exist? I'd guess fewer than a quarter of them.

npm itself is a fascinating case. The node package manager took off because sharing small, reusable modules made individual developers more productive. But the ecosystem it created, with its 2,000-dependency trees and left-pad incidents and supply chain attacks, is a direct consequence of humans optimizing for their own productivity at the module level without anyone designing the system-level outcome. An AI generating code from scratch for each project wouldn't need a package manager at all. It would just write the code. The entire concept of code reuse through distributed packages is a human coordination mechanism.

beautiful scaffolding for brains that couldn't scale

There's something melancholy about this thought experiment. So many brilliant people spent so many years building tools that made the web better, more maintainable, more accessible, more performant. The React team at Facebook. The Angular team at Google. The thousands of open-source contributors who built webpack plugins and Babel transforms and PostCSS configurations. All of that work was real and valuable and moved the industry forward.

And yet, if you step back far enough, a significant portion of it was building scaffolding. Scaffolding for human minds to work at scales that human minds aren't naturally equipped for. The scaffolding is beautiful. Some of it is arguably art. But it's still scaffolding.

The question I can't answer is what percentage. Is it 30%? Is it 60%? Is the component model scaffolding, or is it a genuine architectural insight that would emerge in any timeline? Is the type system a crutch, or is it a fundamental advance in how we think about software? I honestly don't know where the line is, and I'm not sure anyone does.

finding out which layers were always temporary

What I do know is that in 2026, we're starting to find out. Every month, another tool in the frontend ecosystem gets a little less essential because AI can compensate for the problem it was built to solve. Not all of them. Not yet. But enough to make you wonder which layers of the stack are permanent and which ones were always temporary, just waiting for a different kind of intelligence to make them unnecessary.

I don't have a conclusion. I just keep thinking about the 2011 version of me, fighting with IE9 float bugs at 2am, and wondering whether that entire decade of struggle was building toward something lasting or just filling time until the real solution showed up.