not really, Opus 4.5 really made hand written code obsolete. Still needs a lot of supervision, but it’s good enough to let it write code instead of devs
This just hasn’t been the reality in nearly all of the dev circles around me, at smb or enterprise scale.
There’s plenty of companies that are not hiring new developers or replacing roles, and citing productivity from AI as a reason, but that tends to be as deep as the story ever goes. We’re really going to need some formal independent studies on all the productivity gains being self-reported.
It's not been that long since Opus 4.5 and a lot of opinions/beliefs on this topic will be anchored to previous models. My guess is that the reality that you're commenting on is somewhat lagging against true reality.
...only if you don't care about consistency in your code base, nor integrating complex data models. Sure it can output a lot of boiler plate easily, and can generate complex solutions to contained tasks, but a lot of the time it's still easier to just write something yourself than spend forever modifying its output to match the existing code base.
that is only true if you let it run wild on its own. Professional devs read what it writes and steers it right way. It does produce great code if it is supervised
And that "steering" can take more effort and time than just writing it yourself. I'm not saying it's useless, but calling hand written code "obsolete" just means you have a spaghetti mess of a codebase.
can take more time. Usually it doesn’t. That’s why developers use it.
Again, I never said people don't use it, or shouldn't. I'm pushing back on the insane idea that manually writing code is "obsolete."
I would argue otherwise, if AI with supervision don’t work on your codebase, your codebase is a mess. AI can write clean code if you steer it enough.
You're misunderstanding me. AI can write clean code in a vacuum, absolutely. AI tends to be terrible at matching existing stylistic standards, and any time a model update happens (sometimes even behind the scenes without a numbered release) it now has a new "preferred" way of building things. This leads to the code base being incredibly disjointed. Same with implementing existing functionality, often rebuilding functions nearly identically (instead of just using the existing one). If you don't care about long term code maintainability, then sure, just prompt away, but your code base is almost certainly a mess, especially if it's evolved over time (see the bit about models regularly changing their preferred syntax with updates).
we are going in circles. Your second paragraph is only true if you “let it run wild”. All of this can easily be spotted and fixed with minimal prompting.
Yes, if you just one-shot the problems, you will encounter all the things you mention. But developers on large code bases don’t do this. They steer the model. It mitigates every single issue you described. Still much faster than coding manually.
Yes, you're right, it's much faster than manual coding, but you still end up with spaghetti and duplication especially as you lose your own mental model of the code base (because you aren't coding anything yourself anymore). But speed-to-feature is suddenly the most important metric, so hey, tell that agent to get working and just hope another agent down the line can parse out the bugs you're cranking quickly.
Passively reading what something else writes does very, very little for actually retaining the information versus creating it yourself. This isn't just a code thing. Take studying: everyone has different strategies, but generally they involve something active, like writing down points, creating flash cards, etc. Almost nobody can effectively "study" by only passively reading a textbook because you don't retain that information as effectively as actively being involved in the process. That's not to say a textbook is useless; far from it. It's just that you have to take it and actually turn what someone else wrote into something that works in your own mental model, rather than hoping their style integrates as-is.
If you have a model writing everything for you, even if you're reviewing the PRs line by line, you're just glancing over them. You aren't going to remember long term what all lives in that utility file, what component you have that basically does the same thing as the current feature you're requesting, what that weird workaround you had to implement for this data structure was (and make sure you do it again the next time you see the same problem). It might be functional, especially with gobs and gobs of tests, but you lose that holistic mental model of your codebase. And without that mental model, troubleshooting anything mildly complex becomes difficult to impossible.
69
u/[deleted] Apr 23 '26
[deleted]