Programming

While I (almost) agree with the conclusion, there is a lot of bullshit and unproven assumptions in this blog post. I always cringe about the "AI is democratising software development" argument in particular. This is just wrong on so many levels. Software development is not an ivory tower. Everyone with an internet connection had access to all the resources to learn the necessary skills for free, for decades. Everyone who had an interest in actually learning that stuff and putting a bit of effort into it was able to do so. What LLMs provide is not democratising anything but advertising the illusion that everyone can produce software, effortless and without any skills whatsoever. Software development is much more than just churning out lines of code that seem to work. The Vibecoding approach is like trying to build your own car without having the skills and asking an AI to construct it as the sum of individual parts which all come from different car models from a Lada to a Ferrari. The end result might be drivable, but it will be neither secure nor efficient nor fast nor stable nor maintainable etc. A Frankenstein car. Everyone with half a brain would agree that's not a good idea, however with LLMs people just do pretend its fine.

Being able to use an LLM turns a layman into a coder no more than being able to use CAD turns them into an engineer.

It's a real pity that LLMs seem to have taken over as the sole topic of discussion in programming communities such as this one. It might be just me, but I find the whole topic barely interesting at all (ie. not more interesting than the discussions about stackoverflow coding we used to have).

As Cory Doctorow says: code is a liability, not an asset

An interesting way to try to spin disposable spaghetti code as a positive.

It’s easy to overestimate how much of software engineering is about coding, when in truth it’s mostly about the code you don’t write.

I've been saying this for years (maybe I need to start a blog?). Being able to make an app and make a product are completely different things.

If one person can quickly create an app someone else can as easily create open source version and just give it away. To offer a product you need sales, customer service, technical support and so on and creating this organization has nothing to do with writing code. There are exceptions like video games where one person can create and distribute a product but it's because it's more art than engineering. For a SaaS platform to be a "product" it needs to offer functionality that's impossible to implement for a small team in a short period of time or evolve using AI.

This article is quite interesting! There are a few standout quotes for me:

On one hand, we are witnessing the true democratisation of software creation. The barrier to entry has effectively collapsed. For the first time, non-developers aren’t just consumers of software - they are the architects of their own tools.

The democratisation effect is something I've been thinking about myself, as hiring developers or learning to code doesn't come cheap. However, if it allows non-profits to build ideas that can make our world a better place, then that is a good thing.

We’re entering a new era of software development where the goal isn't always longevity. For years, the industry has been obsessed with building "platforms" and "ecosystems," but the tide is shifting toward something more ephemeral. We're moving from SaaS to scratchpads.

A lot of this new software isn't meant to live forever. In fact, it’s the opposite. People are increasingly building tools to solve a single, specific problem exactly once—and then discarding them. It is software as a disposable utility, designed for the immediate "now" rather than the distant "later."

I've not thought about it in this way but this is a really good point. When you make code cheap, it makes it easier to create bespoke short-lived solutions.

The real cost of software isn’t the initial write; it’s the maintenance, the edge cases, the mounting UX debt, and the complexities of data ownership. These "fast" solutions are brittle.

Though, as much as these tools might democratise software development, they still require engineering expertise to be sustainable.