Spinning Rock

The future of software is not AI

I’ve been a software developer for nearly three decades now, continuously and necessarily learning and adapting to an ever evolving industry that will certainly leave you behind if you don’t keep up, and for the most part progress has been positive.

Software development used to be an arcane endeavour reserved for those who were prepared to learn about the machine and spend countless hours reading the fine manuals, but new tools have lowered the bar for new developers while taking the grunt out of the way we provide instructions to the computer while new working processes have done the same for the way we manage projects and communicate with each other, and we are able to create software more quickly and easily than ever before both individually and in teams that would once have been unwieldy.

What’s the problem?

We’ve made some mistakes along the way and a lot of the things we once thought would revolutionise our work have now fallen by the wayside, but we were always driven by the desire to create software that was well behaved, and generally the next best thing has always arisen to solve problems that we as developers were facing.

In contrast, AI is not solving any problems I’ve ever had in my job. Writing code has never been a problem. The speed at which code is written has never been a problem, and in fact lines of code has never been a performance metric in any job I’ve ever done because it’s meaningless as a measurement of performance. Some code takes longer to write because it requires more time to reason an appropriate implementation. Conversely, some code is easily churned out because it’s following a pattern and the implementation is clear.

Ultimately this perceived speed problem is a management concern that is being pushed onto developers, forcing us to compete against a mediocre boilerplate code generation machine at the cost of correctness and safety.

GPT is a predictive technology

TBD

Reasoning is a misnomer

TBD

The true motive

The solutions being forced upon the software development industry are only solving problems fabricated by the AI industry with the sole purpose of creating dependency and guaranteeing their own income. That’s it. That’s the gig.

The slot machine

So often I’ve seen AI code generation likened to a slot machine where if you spin the reels one more time you might just get the output you hoped for, and in my experience I can’t disagree with this analogy. The AI providers have noticed this, of course, and so now with the advent of agent loops the machine will now spin the reels for you. But this doesn’t solve the problem, it just buries it.

“Don’t worry it’ll never happen”

A few months ago, after having expressed my concerns about vibe coding on LinkedIn, I was told that I’m worrying about nothing because nobody is seriously going to vibe code in reality. It’s just a toy, they said, just a hobby that will never make its way into serious development. Yet here we are, now being told that programming will be solved and vibe coding is the future. I hate being right sometimes.

Tool vs crutch

I’ve seen people talking about the difference between using AI as a tool or as a crutch, but in my experience it’s not very good for either. Auto completion is hit and miss at best, and I am forever having to cancel it because it’s just plain wrong. I’ve actually gone as far as ditching VS Code entirely and reverted to my trusty old Neovim setup because I am sick of being interrupted and having to mentally task switch between writing the code that naturally fits the pattern of implementation in my head to reading the code suggested to me to make sure it makes sense. And actually it’s worse than that, because I first have to loosely parse it to make sure it’s at least in the right ball park, and then I have to evaluate it in the context of the implementation pattern in my head to make sure it’s actually correct. Skipping the first stage just leads to frustration and wasted mental effort because it’s very often wrong.

This is, of course, part of the reason we are being persuaded to generate the code in its entirety, so that rather than solving these problems we can just sweep them neatly under the carpet. And this campaign seems to be having relative success, with some people proudly asserting that they don’t even look at the code.

Testing

And don’t get me started on testing. The fact that people are generating tests with AI in order to verify the behaviour of the code generated by AI should be setting off alarm bells for any and every developer worth their salt.

I could understand it if people were writing tests by hand. Even more so if they were creating new tools and languages specifically to ensure solid communication of intent between the developer and the machine. This is, after all, what we’ve been doing for decades already, and why tools like Cucumber and RSpec exist; to allow a human to write specifications in natural language that translate directly to instructions for the machine by virtue of being a DSL that literally executes code as it’s being evaluated. Those tools exist to bridge the gap between human and machine. I still don’t think the problems would go away, but asking the machine to check its own work is nothing short of lunacy in my opinion.

But compilers generate code, right?

In comparing code generated by a LLM to code generated by a compiler, yes it’s true that compilers can contain bugs, however the opportunity for bugs to arise in any given code is proportional to the size and complexity of the code being generated. A compiler is generating small and highly focused code whereas an LLM is generating comparatively longer code describing more behaviour in a given block of code (say, function). Further to that, a compiler is typically generating code that will be encountered in many places not only across a given codebase, but also any other codebases using a given compiler, which means the opportunity for bugs to be discovered is increased exponentially (assuming, of course, that these bugs are reported to the compiler maintainers).

Conversely the exposure of code generated by by a LLM is unknown and dependent entirely on the specificity of the code to a given project. A simple case with no project specific context may generate identical code across different projects, whereas the more specific a case is to a given project the less chance there is that the same code will be generated in another project. And in either case, when a LLM produces code that contains bugs, who does one report them to? And even if a bug is reported, how would a fix be incorporated into a LLM in order to prevent the same bug being generated in the future? Is it possible for a LLM to learn to not generate these bugs from the publicly available code it’s trained on? Is there a critical mass of code without these bugs required in its training before it tends to ignore the older code it was trained on that contains these bugs?

Read vs write

Without doing the thinking through a task in order to write the code, a developer is reduced to validating LLM generated code based on the feasibility of it being correct, rather than knowing it’s correct by virtue of having arrived there through logical thought processes.


Correctness

Context

Reproducibility

Quality

Availability

Consequences

Unsorted