I have been developing Antsand since 2014. It is my digital garden, a sophisticated personal project that generates federated, static websites, including the blog you are reading right now.

Eleven years is an eternity in software development. Antsand has survived multiple eras of "the next big thing." By 2021, the application had matured into a complex beast powered by Vue 2 on the front end and a heavy Node.js backend ecosystem.

Entering 2025, I made a radical decision. I tore it all down.

I didn't rewrite it in React, Svelte, or Rust. I didn't break it into microservices. I migrated backward. I migrated Antsand to pure ES6 JavaScript, standard PHP, and the Phalcon framework.

Here is why I removed the "stupid frameworks," rejected the microservice hype, and why, after facing the nightmare of upgrading "bloat", I realized that pure ES6 is actually the most powerful framework of all.

The Breaking Point: The Vue 3 Upgrade

The decision wasn't random. It was born out of frustration.

My application had fully migrated to Vue 2 over the years. But then came the inevitable: Vue 2 reached End of Life, and the industry pushed for the Vue 3 upgrade. I sat down to plan the migration, and I hit a wall.

I asked myself: "Why am I spending my limited time upgrading bloat that I don't even fully understand under the hood?"

I looked at the rest of my stack.
  • PHP: Moving from PHP 5 to PHP 8 over the years hardly broke anything.
  • Data: My MySQL schemas and MongoDB collections were solid; they didn't need constant rewriting.
  • Core Logic: The actual business rules of the application worked fine.
The only part of my stack screaming for attention, demanding hours of debugging and rewriting, was the frontend framework. It wasn't adding value; it was demanding tribute. I realized I didn't want to spend my life upgrading crap just to keep the lights on.

So I didn't upgrade to Vue 3. I deleted it.

The "Scale Fallacy" and the Microservice Trap

Throughout the last decade, I stuck to PHP Phalcon and full-stack frameworks, even while the industry screamed that we should all be building microservices.

I never found a good architectural reason to make that jump. When you split everything into microservices, you aren't just splitting code; you are duplicating complexity. You duplicate your ACLs. You duplicate your page logic. Suddenly, every API needs its own authentication, its own bearer tokens, or OIDC handling. Then your frontend ends up with all that business logic rewritten in JavaScript.

To me, it is a stupid design for 99.9% of applications.

I get it, if you are Facebook serving billions of users, saving 1% of server load by offloading logic to the client saves millions of dollars. But for the rest of us? Saving that 1% means nothing. But spending six months fixing dependency chains because your Node package is outdated? That costs everything.

I have seen so many teams lose entire sprints to "technical debt cleanup" just to keep a build pipeline alive. Meanwhile, C, HTML, CSS, Linux, and linear algebra (will talk more about this), what worked 30 years ago works today. A React app built this morning breaks this afternoon. And somehow, we call that "good design."

The Insanity of Rendering a Button

The tipping point for me was realizing the absurdity of the modern frontend toolchain.

To render a button today, the industry tells you that you need TypeScript, Vite, Babel, Gulp, Node, JSX, React, and a structure of 100 nested folders. All of that just to output:

I couldn't justify the bloated crap anymore. I wanted to just type the HTML.

Worst of all, nesting a folder inside a folder inside another folder is not a design. It’s just dumb.

I’ve noticed a toxic cycle in modern development: every new developer who inherits a React application trashes the previous developer. 'Oh, why did they use this library?' or 'Why did they write it like that?' They genuinely believe their new implementation will be the best. What they don't realize is that the next developer will say the exact same thing about their code. They are criticizing the people, but the real problem is the stupid framework they are all coerced into using.

React has no architectural pattern. It has no logic other than 'State.' But a button doesn't need a state, a button needs a link and some decent CSS to look clickable. That is it.

React doesn't provide ACLs, patterns, or structure. So every developer thinks their ad-hoc idea is the standard. You know what is actually tried and tested? Design Patterns. You need to actually study these things, something most React devs avoid.

HMVC, MVC, Dependency Injection, Active Records, these are classical algorithms and patterns that work and will continue to work. That is what a framework is supposed to provide. A real architecture isn't chaining Prisma to Next.js to some bundling tool with 100 dependencies each. A clean framework like Phalcon, Ruby on Rails, or Django provides these details out of the box. You can't just create a folder structure and call it a day. You need a proper Controller, you need logic in Models, and you need Active Records. In Phalcon, this is all based in C. That is why these frameworks don't break easily, because patterns don't break.

The New Stack: Robust and Close to the Metal

So, I upgraded Antsand by simplifying it. I containerized a few necessary parts, but I doubled down on the HMVC (Hierarchical Model-View-Controller) architecture.
  • Frontend: Gone is Vue. Gone are the build steps. It is replaced by pure ES6 JavaScript. I realized that with Modules, ES6 is the framework—and it's the only one that won't break next year.
  • Backend: I returned to the stability of PHP Phalcon. I won't say "returned" but continuing to use it.
  • Performance: I am writing more C code now. Because AI speeds up my workflow, I can afford to go "close to the metal" for performance-critical tasks rather than relying on abstract libraries.

The "Blended" Strategy for Interactivity

The only real question people ask when ditching frontend frameworks is: How do you handle complex interactivity?

My answer is straightforward:
  • Minimal Interactivity: Render everything on the server side. The browser just needs HTML, CSS, and data.
  • High Interactivity: Use a "blended" approach. Load the page with all the initial data the UI needs embedded right there in the DOM. Then, let pure ES6 modules read, parse, and interact with that data.
You don't need a Virtual DOM to toggle a class or filter a list. You just need JavaScript.

Architect over Coder: The AI Shift

The most profound change isn't technical; it's philosophical.

Before, I spent huge amounts of time untangling framework spaghetti. Now, AI generates the boilerplate faster than I can type. When I migrated a Vue component to vanilla ES6, I didn't hand-write every event listener. I described the behavior I wanted, reviewed the output, and refined it. What used to take an afternoon takes twenty minutes.

But here's the paradox: AI made me go deeper, not shallower.

Because I'm not burning hours on syntax, I have time to understand what's actually happening. I'm implementing a transformer inference engine in pure C. I'm building a flight controller from scratch with zero abstractions. I'm upgrading ANTSAND, writing these blogs, and designing systems that would have taken me years to attempt before.

All of these - transformers, attention mechanisms, flight control algorithms - are built on the same 400-year-old foundation: linear algebra and calculus. I'll write more about this, but the most important skill in tech isn't knowing the latest framework. It's knowing the math that every framework poorly abstracts away.

This is how I spend my time now: math, physics, architecture, design, code review, testing. Yes, I still write code - but I write the critical pieces. The parts that require judgment. Then AI completes the rest. When it does something I don't like, I go in and fix it myself. The AI watches, learns, and gets it right the next time.

I am no longer a "coder" fighting dependency chains. I am an Architect.

I don't know what the future holds. But I'm not worried about being replaced by AI. I'm too busy using it to remove abstractions and go closer to the metal - all without a node_modules folder in sight.