Indifference is killing open-source software

Looking at news sources for developers these days is a daunting task. Daily I see new projects and implementations of incredibly ambitious nature. On a typical day you might see announcements of people coding something in assembly, porting language A to platform B, reverse-engineering a large commercial app or some other incredible thing. We see incredible Rust or Zig implementations, iOS running on Android or vice versa, Clojure but better (whatever better might be). The list seems to be endless.

The common factor

I doubt any of these ambitious projects would have started without using an LLM. As LLMs get better at delivering reasonable code, developers seem to become more ambitious in their challenges. A result of this, at least for me, is that all the air is taken out of the room. It becomes nearly impossible to think about new things to build.

Every idea that comes to mind likely already has some LLM implementation scattered on the AI web. And if it exists, why bother attempting to build it yourself, right?

Just because you can

There is something fundamentally wrong with this picture. I'm pretty sure I am not the only one that feels fatigue for the latest shiny announcement of something new. It isn't necessarily the boldness of some ideas. But to me it feels a lot of things that are built now have a single motivation. I am guessing that if you ask someone that has just completed a port of one language into another why he or she had done it, the answer might be because I can.

I have a feeling that one of the reason the open-source community is struggling now, isn't necessarily because LLMs have made it easier to develop new things (I am not talking about quality here), but that so much is developed in such a short time.

A typical LLM supported developer might reverse engineer Adobe Acrobat on Monday, decide to do Microsoft Word on Tuesday, while implementing a much better version of language X or Y on Wednesday. Not because the dev needs it. Not because he feels challenged by it. But because the dev can.

If everything is possible, nothing has value

It seems to me that a real problem of implementing these huge projects in a short time, is that the perceived value of these projects drops to near-zero.

Ignoring the problem that the produced code is likely not readable, maintainable and full of issues, it also communicates that anyone can build anything. And if that were true, then why bother looking in detail at an open-source software project? We can all rebuild it again tomorrow, clearly better than the previous attempt, right?

Not only does it take away the air in the room, but it also leads to something much worse, indifference.

Who cares if someone had a good idea, a novel way of implementing, solves a hard problem? We can all do it tomorrow, in between or during the coffee break and lunch.

Indifference feels like the biggest threat to open-source software. Where it used to be powered by enthusiastic, idealistic, smart people that wanted to make a difference, it is now driven by indifference. We can create it, so we do it, and then we move on to the next thing that can be created too.

The way out

I'm not here to tell you that creating software using LLMs is evil or bad. I am here to tell you that being indifferent when building something that you throw out there is not a good idea. It helps no one, solves nothing and is potentially a complete waste of time, resources and money spent on LLMs. What is the use of creating something cool that no one (including yourself) will ever use?

The way out seems obvious. Take a step back and stop focusing on building stuff because you can.

Instead, think about the challenges you face, the problems you see, the irritations you have, the things that inspire you. And then think about building something that you will use yourself.

Isn't that what open source is about? It needs to solve your own problem first, before it can inspire others to use it as well. It isn't relevant that we can build things with ease. What is relevant is how and why we create it.

Quality matters too. Claiming with some pride that you have no idea of the code quality is any good (I'm surprised how often I read this) but it does the job, does not inspire me to give it a try.

Sharing is caring

Trust matters, and trust starts by showing that you care. Again, that doesn't necessarily mean to avoid using an LLM. But you need to be in control. You might outsource some coding tasks to an LLM, but you cannot outsource your brain.

The LLM is as stupid as the input it receives. Next time, when you decide it would be cool to port language A to language or platform B, you better make damn sure you know what you are doing. If you don't, the result might work, but no one ever will touch it.

If we want to get some oxygen back into the room, we need to work on things we care about. Things that will make a difference for us first. Things we can be proud of. And we need to be in control. You cannot outsource your brain. It is the one thing that makes all the difference.