We're in the middle of a really interesting shift in software development, and it's a shift that's happened before. I think we may have forgotten that.
Once upon a time, before I was a junior developer, we wrote in low level languages. Assembler, essentially: languages that sat very, very close to the machine. Then we moved up to C, which was a step up but kept that same close relationship with memory management. Then came the high level languages: Java, VB, and later C# and .NET.
At each of those junctions, a generation of engineers turned around and said "well, nobody understands what's underneath anymore." When Java arrived, we wondered whether we'd still be able to manage memory, and whether everything would become slow and resource-heavy because we'd given up control. We had a bit of a crisis, and then we moved on.
My own route was a little less tidy. I started with BASIC on a VTech computer that told jokes, then as an apprentice I wrote SCL and IDMSX database code for a tax system (if you haven't heard of these, that's a good thing: they're old enough to make COBOL look modern, and they ran on emulators on top of emulators), then Java, then C++, then PHP and Python. These days it's Python and FastAPI, built with agents. So I've lived through a few of those jumps myself, and not always in the right direction.
I'd argue we're seeing the next version of that shift right now. You can write code through an AI prompt or an AI-based tool, and in a growing number of cases the person designing and building the system may never see or read the code it produces.
I don't mean that in a "vibe coding is going to rule the world" kind of way. There are already fully functional tools being built by people who have never read a line of code. That might make those of us who write software feel uncomfortable, but it's the same kind of generational jump we've made before.
It also raises some interesting questions.
If you never read the code underneath, does it matter what language it's written in?
Do the choices we make about languages and technology stacks become largely arbitrary?
Will we see an explosion in languages, or a consolidation, with agents choosing the technology for us (and not always what we would have chosen ourselves)?
Will we still have the open source community we have now, or will people end up writing their own versions of things without realising it, because they don't really know what a library is or what it gives them?
All of this is just the random thoughts you get when your brain is finally quiet. But if you're a software engineer, or you work around software like I do, this one is worth watching for two reasons. It massively changes what we think of as the software development lifecycle. It also changes the skills we teach our junior developers, at the same time as it grows the number of people building software exponentially.
Once upon a time, we were upset that we no longer got so close to the operating system and the memory. Now we're jumping up again.
So buckle up, team. It's going to be a bit of a wild ride.