I Ditched the Modern Stack for Basic HTML Because Debugging AI-Generated React is a Special Kind of Hell

Let me explain the hydration error nightmare for those who haven't experienced it.

React Server Components, Next.js App Router, and the entire "server-first" paradigm are built on a fragile promise: the HTML rendered on the server must exactly match the HTML rendered on the client during the first paint. If there's any mismatch—a different timestamp, a conditional that evaluates differently, a random ID—React throws a tantrum.

When you write React, you learn to avoid these pitfalls. You know not to use Date.now() in a render. You know to wrap client-only code in useEffect.

When AI writes React, it has no such intuition. It sees patterns. It generates code that looks like the training data. But it doesn't understand the hydration contract.

I asked Cursor to build a simple landing page with a "hero section" and a "feature list." It generated 1,200 lines of TypeScript in about 10 seconds. Beautiful. Clean. Typed.

It also:

• Used Math.random() for animation delays (hydration error).
• Conditionally rendered a component based on window.innerWidth without a client check (hydration error).
• Imported a client-only charting library at the top level of a server component (build error).

I spent the next four hours untangling this mess. Four hours to fix a landing page that could have been built with raw HTML in 30 minutes.

This is the debugging AI React components tax. The AI can generate, but it cannot reason. And in a framework as opinionated as React, reasoning is everything.

Open any modern React project's package.json. Count the dependencies. I'll wait.

The last Next.js project I inherited had 147 dependencies. For a marketing website. With five pages.

This is web dev complexity fatigue. We have normalized an insane level of abstraction. We need a build step. We need a bundler. We need a transpiler. We need a linter. We need a type checker. We need a testing framework. We need a component library. We need a state management solution. We need a data fetching library. We need a form library. We need an animation library.

Each of these dependencies has its own dependencies. Each of those has security vulnerabilities. Each of those has breaking changes between minor versions.

And then we hand this teetering Jenga tower to an AI and say, "Make it work."

The AI doesn't know that react-query v5 changed its API. The AI doesn't know that framer-motion has a different syntax for exit animations now. The AI just generates code based on whatever version was most common in its training data—usually 18 months out of date.

The result is a codebase that compiles but doesn't run. Or runs but doesn't work. Or works but throws 47 console warnings that you'll "fix later" (you won't).

Here's the dirty secret that the JavaScript Industrial Complex doesn't want you to know: most websites don't need React.

Your marketing site doesn't need React. Your blog doesn't need React. Your SaaS dashboard with some forms and tables probably doesn't need React.

What do you actually need? You need:

• HTML that describes the structure of your content.
• CSS that makes it look good.
• A way to make parts of the page interactive without reloading.

Enter HTMX.

HTMX is a 14KB library that lets you add interactivity to your HTML using attributes. Want to load a partial without a page refresh? Add hx-get="/partial" to any element. Want to submit a form via AJAX? Add hx-post="/submit". Want to swap content? hx-swap="innerHTML".

There is no build step. There is no hydration. There is no "use client" directive. There is no state management library. There is no bundle analyzer. There is no tree-shaking anxiety.

You write HTML. The server renders HTML. The browser displays HTML. When you click something, HTMX fetches more HTML and swaps it in.

It's so simple it feels illegal.

And here's the kicker: why HTMX is winning—AI can't break it. Because there's nothing to break. You can ask an AI to generate an HTMX partial, and the worst thing it can do is return malformed HTML. That's a 5-second fix, not a 4-hour debugging session.

Here's the stack I now use for 90% of projects. It's boring. It's "outdated." It ships in hours, not weeks.

• Backend: Any server that renders HTML. Python/Flask, Go, Node/Express, PHP—doesn't matter. Pick what you know.
• Frontend: Semantic HTML5. No JSX. No templates. Just <article>, <section>, <nav>.
• Styling: Vanilla CSS with CSS variables. Or Tailwind if you want utility classes. No CSS-in-JS. No styled-components.
• Interactivity: HTMX for AJAX. Alpine.js for small reactive bits. Vanilla JS for everything else.
• Deployment: A $5 VPS. Or Fly.io. Or Railway. No Vercel edge functions. No serverless cold starts.

Total JavaScript shipped to the client: ~20KB.

Time to First Byte: ~50ms.

Largest Contentful Paint: ~200ms.

Hydration errors: 0.

This is the minimalist web development stack. It's not sexy. It won't get you Twitter clout. But it works. Every time. Without surprises.

The React alternatives 2026 conversation is finally happening. Developers are tired. The framework churn is exhausting. And AI—ironically—is accelerating the burnout by generating more broken code faster than ever before.

The solution isn't better AI. The solution is simpler tools.

The Verdict

I'm not saying React is bad. I'm saying React is expensive. Expensive in cognitive load. Expensive in build complexity. Expensive in debugging time. And when you add AI-generated code to the mix, that expense compounds exponentially.

If you're building the next Figma, use React. If you're building a dashboard with real-time collaboration, use React. If you're building a complex SPA with intricate state management, use React.

But if you're building a marketing site, a blog, a documentation page, or a simple CRUD app? Stop. Take a breath. Ask yourself: "Do I actually need 147 dependencies for this?"

The answer is almost always no.

Embrace the boring. Ship the feature. Sleep at night.

The semantic HTML comeback is real. The web dev complexity fatigue is real. And the developers who figure this out first are going to ship circles around the ones still debugging hydration errors at 2 AM.

Made the switch from React to HTMX? Share your "boring stack" wins on Twitter/X @mehitsfine.