Good news! Software engineering has completely changed.
Software is no longer brittle, fragile, hard to change, unpredictable, confusing, or full of strange emergent behavior.
We no longer need to worry about code rot, accidental coupling, unclear names, hidden assumptions, dependency tangles, edge cases, or systems slowly becoming haunted by ten years of “temporary” decisions.
Why?
Because now we have AI.
And once we get AGI, surely it gets even easier.
We’ll just say:
“Please build software that is clean, maintainable, well-architected, easy to change, and not secretly full of traps.”
And then, naturally, the machine will do that. 🤭
There is one tiny issue with this theory. Okay, there are a ton of not-tiny issues with this theory.
But one of them is that we have always had human-level intelligence working on software.
Literally always. Surprise. 😉
For decades, we have had smart, capable, highly trained engineers working on these exact problems.
We already knew naming was hard.
We knew coupling was problematic on a good day.
We know complexity accumulates quietly. I suppose some of us are rediscovering that… heh.
We know code can rot. It will get worse over time if you don’t actively resist the rotting.
We already knew “temporary” decisions have a funny little habit of buying property and raising children in the codebase.
Entire bookshelves have been written about this: Clean Code. Refactoring. The Pragmatic Programmer. Design Patterns. Working Effectively with Legacy Code. Domain-Driven Design.
Even if you aren’t the team with the hard-core TDD evangelist, you probably had some guidelines close to this:
- Use good names.
- Avoid unnecessary complexity.
- Beware the coupling scourge.
- Write tests.
- Refactor when needed. If you are afraid to refactor, write better tests.
- Avoid duplicating logic.
- Make the system easier for the next person to understand.
This is not forbidden knowledge sealed in a mountain.
So the question is not whether intelligence can recognize bad software.
It can.
The question is why we suddenly think more intelligence automatically removes the underlying difficulty of building evolving systems that model messy reality while requirements change, incentives shift, deadlines loom, and many people keep modifying the same thing over time.
Software engineering was never hard merely because humans were too dim to notice the problems.
That would honestly be much easier.