Reinventing the Wheel: A Reflection on Software Development and Open Source

I’m working on an open-source project called Milk Admin: a PHP admin core designed to quickly create supporting administrative backends. The project isn’t ready yet, but if you want to take a look, you're welcome to. A couple of months ago, I published an article introducing it on an Italian forum. I was very surprised by the comments, and I decided to write this article to reflect on how the open-source software landscape has changed.

The Time Before Certainties

When I started developing for the web, the world was split in two: those who used CMSs, and those who wrote everything from scratch. As strange as it may sound today, building from scratch was still a respected approach — also because it showed you knew how to program. The code was often questionable, but there was tolerance; the important thing was that it worked.

A few years later, using Joomla, I developed an open-source component that gained some success. I never knew exactly how many people downloaded or used it, but over time I received thanks, donations, and collaboration proposals.

The Rise of Standards (and a Change in Paradigm)

Then something changed in the PHP world. With WordPress in particular, a different model emerged: open source as a showcase for premium versions. A perfectly legitimate business strategy, but one that deeply transformed community dynamics. In my personal experience, I had a terrible time developing plugins for WordPress — I found the community truly unpleasant and surprisingly uninformed.

Even Richard Stallman had expressed concerns about the open-source model. But the world changes, and we must adapt.

With the rise of frameworks like Laravel and Symfony came a new mantra: don’t reinvent the wheel. Sensible in theory, but it evolved into something more rigid: the belief that there are “right” and “wrong” ways to do things, and that innovation means learning to use existing tools better, not creating new ones.

Companies embraced this approach enthusiastically: standards mean interchangeability, replaceable resources, fast onboarding. Economically, it makes sense. Culturally, however, something may have been lost.

The Trial by Fire

When I decided to present the new project I mentioned earlier, the reaction I received was almost hostile. It struck me, because in the end it’s free code — you can like it or ignore it, but criticizing it felt like an attitude I struggled to understand.

The objections weren’t even about how it worked. They mostly criticized the fact that more sophisticated tools like Filament already existed. Others complained that it didn’t follow modern programming standards. Few seemed to have actually tested the code. The judgment felt preemptive, based on abstract principles rather than concrete issues.

Why Continue Reinventing

I considered abandoning the project. But then I stopped to reflect on what drives me to program. It’s not just solving problems — that’s my job. It’s understanding how things work. It’s exploring. It’s learning by reprogramming the obvious.

Just last week I was explaining why namespaces are supposed to follow folder structure. Logically, organizing them by concept would make more sense. But it’s a standard, so it’s “not up for discussion.” Except — sometimes we should question whether better ways might exist. Reflecting on this now and then is healthy.

If everyone stopped building CMSs because “there’s WordPress,” if no one created new frameworks because “there’s Laravel,” how many opportunities would be lost?

After all, if no one had ever reinvented the wheel, our cars today would still be rolling on stone wheels.