Slow the fuck down
It's time to ramble about the state of software development in the year 2026. Everyone has their thoughts on this, about the mental overload of one dev owning a full pre-2022 sprint board, about the slop, about the accuracy of AI code, or its ability to fully encompass the context of the project. There's a lot to consider, and many pros and cons. The code side of this has been done to death, and frankly I'm not smart enough, or talented enough at programming to provide any real input into the technical side of this.
What I can offer is the human side of this (okay, I guess I may get slightly technical too). The human cost of every developer being made to feel like a 10x, 100x, 1000x developer.
A brief history of software development
Like many of us, early in my life I discovered the joy of giving instructions to a computer to make it do things! For me
the main thing was being able to play flash games, while in the school computer lab (thank you domain level blocking).
Running my own website, at first just a frontend with embedded flash games from miniclips to let me and my friends,
slack off enjoy our free time. This meant I had a domain, and some hosting, so I ended up doing a lot of dumb shit just
because I had the ability. Chief amongst them was a brief experiment into PHP (yes we were all young once). Being able to
slowly work out, step by painstaking step, that every line I wrote, made the computer do something I wanted (and several things
that I didn't want it to), unleashed something in me.
Like many of us, this love and simple enjoyment is what drew me to the field. Starry eyed I went to study computer science, so that someone would pay me money to write code all day. Very quickly I learned that this was not the case. A developer's job is mostly not writing code. Even before AI the best developers did not produce much code. Our job instead is to understand, to reason, to think of reasons not to write the code. The best code is code that is never written! To validate this, imagine 2 PRs. One with 1,000 lines of additions, one with 1,000 lines of deletions. I'm sure, like you, the 1,000 lines of deletion bring you more joy.
How this has changed
The bottleneck has never been the lines of code written. We've all worked with god-level engineers who spend their days pontificating, thinking, and reasoning about code. People who write one or two lines of very good code a day, at most. People whose job it is to watch everything that's happening, all proposed changes and provide a wider context. AI cannot do this. Even now, AI's that are connected to knowledge bases, slack, code repositories, and have all the context, given the instruction to do the same, fail horribly at this. They provide nonsense noise, writing long prose of irrelevant detail, and missing the forest for the trees.
Now instead all of us are expected to produce massive features in the timeframe of days, if not within the day. I've done that myself, produced an entire product feature, from
- Thinking it should exist
- planning it (plan.md counts right)
- Implementing it
- Testing it (pretty sure {ai_agent} requires this, so it must be done)
- Releasing it to dev environments.
Wow! A whole feature from end to end within a day, that's amazing right?
What's not counted
Seldom counted is the 2 to 3 days of making sure this actually works. This is made infinitely harder by the fact that I as the dev who made this feature, do not understand its inner workings. Sure I know the broad strokes (I wrote some very detailed prompts, and even skimmed the PR, before making someone else approve it). But if something doesn't work quite right (which it won't). Then I have to take the time to fully understand the feature I have just "developed". Some will say this can just be solved by just asking {ai_agent} to fix this, but doesn't that just compound the problem. Eventually someone needs to understand this. A POC becomes a full feature, becomes a full service, becomes a full platform. At some stage someone other than a markdown file needs to understand this, unfortunately that person is you.
This has always been the case. Complex bugs that exist because of strange behaviour, across multiple codebases, multiple services and in such edge cases that even the clanker will struggle.
Eventually, if we continue down this path, we will be left with monkeys and typewriters. A room full of people who bash the keyboard just to get the thing to work right. Is that what we want?
The core of the problem
The real main thing here is; why are any of us doing this? Didn't we start to build stuff cause it was enjoyable? We wanted to bend the computer to our will, spend hours hitting our heads against a roadblock, only for the high of finally figuring it out. Now the thinking machine simply steals the entire internet to give us the most likely solution to our input. Yeah AI is great at debugging, I too use it all the time to shortcut, but isn't there joy in the journey, isn't that how we learn?
Another thing, did you notice I said "Now the thinking machine simply steals the entire internet to give us the most likely solution to our input"? The robot is not magic, it cannot create new ideas, it simply churns out the most likely next word, and goes from there. This cannot be the basis for innovation. Think, this technology has been around for nearly 4 years, GPT-4 came out in 2023, and what has actually been created since then? With years of AI able to write our code, has there been any noticeable improvement in software we use Or has everyone just made the exact same website, with the exact same colour scheme?
The real issue is that AI is able to produce just enough to seem like it is of value, it's effectively the opposite of delayed gratification, in that I can go from 0-70% real fast, and leave it there. Don't get me wrong, there are use cases for this. Scaffolding out a new project, a backend dev with no taste for frontend (who me?), handling the more boring mundane parts; this is all great stuff to delegate to an agent. But too much of software development now relies on crafting a prompt, and letting it run.
Is the cat out of the bag?
Yes.
There's not much more to add here, if you think we can go back, you're wrong. Traditionally it's been pretty hard across most of the industry to try to argue for fixing the final 30% of a feature. Most orgs never wanted devs to spend time addressing tech debt, and rather focused on shiny new features. If AI is able to pile on features that mostly work, then these conversations will get harder.
It's sad that we may be seeing the end of the golden age of developing software, and maybe a better future exists.
How should we use AI?
For me right now, I do use AI. Of course I do. I have a few main use cases, and a few rules with how I interact with it. 1) The AI is something I delegate sub tasks to. I don't just hand it off features 2) Write it an actual plan, don't rely on plan mode; you need to tell it what to do, and how it should be done. 3) Check, check, check, check! 4) Give it CLI tools for debugging, read access to cloud providers and error logs, and it will find root causes pretty quick (this one is actually pretty neat!) 5) Just as you review co-workers' work, review the robot's, dedicate time to actually reading the output.
Okay, I'm done
Sorry this was a somewhat weird post, I have written before, but not here, so this is a pretty weird way to start off. But at least at the end of it we accomplished nothing. I'm not sure if this was just a vent, advice, or maybe even just looking for reassurance that other people feel this same way. Either way, if you managed to make it through that, thanks (and sorry).
hc.