August 3, 2026
Everyone is panicking that AI will bury us under incomprehensible bugs. Relax. The code is about to get so perfect there will be no bugs left at all, only the business cases nobody documented, or documented badly. The machine builds exactly what you ask for, which turns out to be the terrifying part.
“In the coming few years, most engineers will heavily rely on AI to build software. Loops will produce and review code, while engineers will be out of the loop, figuratively and literally. The final product, which is supposed to be used by humans, is unrecognizable by the engineers who built it. Bugs and performance issues will arise, and the engineers will go back to the loops to fix them. Very few engineers will be able to understand and troubleshoot systems. Those rare engineers who kept their skills sharp will be in high demand when we reach that state.”
I was scrolling my X timeline the other night when I ran into one of those posts that get passed around with a knowing caption. This is what the future may look like. Stay sharp,
said the person sharing it. Attached was a screenshot of a LinkedIn post, and I braced myself for the sacrilege I was about to read. The take above is the whole of it, and it is the fashionable shape of AI doom right now: the machines write everything, the humans forget how any of it works, and a tiny priesthood of engineers who kept their skills sharp gets to charge a fortune to walk into the ruins and read the runes.
I have a different read. I do believe AI is going to move the ground under us into something we do not yet understand, but most of these posts are pure doom written for engagement. The story everyone is selling this year is the lone CEO who does the whole job while the machines handle everything beneath him, Tony Stark closing deals while the suit assembles itself. The reality, at least for the short term, is going to be less cinematic. We will still need those rare engineers
who can understand and troubleshoot a system. I just think they will be troubleshooting something very different from what this post imagines.
What strikes me as genuinely remarkable is the exact opposite of the doom. The agents and the models are going to produce better and better code, and they will avoid bad code the way oil avoids water. Code that is essentially bug free, code that performs the way it is supposed to, is going to become the norm. When something is not performant, no human will be standing there to notice it and kick off the old ritual of fixing it. The loops will review and repair their own output, and yes, the engineer will be out of the loop. That part of the post is correct. Where it goes wrong is the assumption that this produces more bugs to chase. With time, defects and performance problems get rarer, not more common, and the rare engineers move on to new features. The code will most likely come out so clean that there will be no bugs left, only undocumented or badly documented business cases.
The reason is simple. Today’s models lean on human-generated code. They were trained on our history, our habits, and our mistakes, which means they inherited a fair amount of the mess. But once models start building themselves, and that is coming sooner than anyone is comfortable with, humans stop being the teachers. A model will not need some Johnny’s two thousand recursive functions to learn recursion and then dutifully repeat that two-thousand-line pattern in everything it writes afterward. It will find the most mathematically sound way to do the thing and then do it better than the corpus it came from. You will not be in a position to argue with it, because it spent the night building itself into something you cannot follow while you were asleep. Models like OpenAI Astra solved ten decades-old math problems in fields like group theory and high-dimensional geometry for roughly two thousand dollars of compute each. So all the X debates about who writes prettier code, who writes faster code, whose style is cleaner, are going to end up as internet memorabilia, because nobody on earth is going to out-code the next generation of models. They will understand the boundaries of every language we have, and they will very likely design the next one to replace the current status quo. Who knows what they will decide to call it.
Come back to the actual experience of dealing with bugs, because you already know how this goes. A product manager walks over and says there is a bug in the payment system,
and what actually happened is that Danny had a bad day and never documented a corner case that was, in fact, a perfectly valid business rule. Early in my career most bugs came from the simple fact that compiled engineering was not the default. Most code was interpreted and executed by the runtime, which opened an enormous box of ways to fail. One mistake from one engineer, one null nobody accounted for, one payload that arrived from somewhere else without proper validation, and the whole flow came down. We moved away from that over the years, though never completely. We started writing in strongly typed languages, bugs dropped hard, and a lot of us now work in strongly typed, compiled stacks where an entire category of mistake simply refuses to compile. Bugs are rare now, and the pile of trouble is made mostly of missing or badly documented business cases. When something goes wrong today, I will bet you that most of the time it is a false positive or a business rule nobody bothered to write down.
That is exactly what is coming once AI is fully in the game. The code will be close to perfect. It will be so free of defects that there will be nothing to fix in the old sense of the word. What we will actually need is management willing to put real effort into defining the valid business cases and the requirements behind them. And even that is getting easier, because managers are leaning on AI to challenge their own assumptions before they ever reach an engineer. Jira tickets used to be a title and a one-line description, Implement feature X
and good luck to you. Lately I am seeing enormous tickets that read like full specifications of business logic, complex enough that you would struggle to document or even understand them without AI helping on that side of the desk too. So both ends of the work are converging on the same thing. Maybe, before long, AI drives what is best on the business side and on the engineering side at once, and the image of the lone founder closing deals while the machine builds the product around him stops being a meme and quietly becomes the ordinary way software gets made.