I haven't written here in a while.
Not because I ran out of opinions.
That would be concerning.
I just got tired of the endless stream of:
- AI will replace developers
- AI will never replace developers
- this model changes everything
- this agent changes everything
- software engineering is dead
- software engineering has never been more important
So I stopped writing for a bit.
AI did not.
And coming back now, one thing feels pretty obvious:
AI got better.
Software didn't.
The models are better.
Coding agents are better.
The amount of code you can generate in an afternoon is honestly ridiculous compared to even a year ago.
And yet somehow we still have:
- overengineered backends
- seven abstractions around a simple database call
- dependency hell
- features nobody asked for
- microservices solving problems that did not exist
- teams proudly shipping complexity at machine speed
So maybe code generation was never the bottleneck.
Maybe we just wanted it to be.
Writing code was never the hardest part
Developers love talking about coding as if typing the implementation is where all the value lives.
I don't think it is.
The hard part has always been deciding:
Should this exist?
Is this actually the right solution?
Are we solving the real problem?
Does this need another layer?
Could this be deleted instead?
AI can give you 600 lines of perfectly respectable-looking code before you've finished your coffee.
That doesn't mean those 600 lines should exist.
And this is where I think AI makes things slightly dangerous.
It removes friction.
Which sounds great.
But friction sometimes saved us from our own terrible ideas.
Before, if you wanted to build an unnecessarily complicated system, you at least had to suffer for it.
Now an agent will enthusiastically help you construct the whole disaster.
AI is extremely good at helping you overengineer
Ask an AI to solve something and it usually wants to be helpful.
Very helpful.
Suspiciously helpful.
You ask for a small feature and suddenly you've got:
- a service layer
- repository pattern
- dependency injection
- validation abstraction
- retry logic
- configuration objects
- three interfaces
- a factory
And everything looks reasonable.
That's the problem.
Bad software rarely starts with something that obviously looks stupid.
It starts with a lot of individually reasonable decisions.
AI can now produce those reasonable decisions much faster than we can regret them.
The better AI gets, the more I want boring software
I wrote before that my 2026 tech stack was boring as hell.
I meant it then.
I mean it even more now.
Because if AI is going to write more of the implementation, I want the surrounding system to be painfully predictable.
Give me:
- boring databases
- boring APIs
- boring frameworks
- boring deployment
- obvious architecture
- code another human can understand without a diagram explaining the diagram
I don't need my stack to be interesting.
I need the product to be interesting.
There is a difference.
And I think we've forgotten that a little.
Code is becoming cheap
This is probably the part that will annoy some people.
I think code itself is becoming less valuable.
Not worthless.
Less valuable.
The ability to produce code is being commoditized incredibly fast.
That does not mean developers are becoming worthless.
It means the valuable part of development is moving somewhere else.
Toward:
- judgment
- architecture
- debugging
- product thinking
- taste
- knowing what to reject
- knowing when the AI is confidently wrong
- knowing when the correct implementation is no implementation
I think "taste" is going to become one of the most important engineering skills.
And it's annoyingly difficult to measure.
You know it when you work with someone who has it.
They remove things.
They simplify.
They ask irritating questions.
They somehow turn your clever 14-step solution into five boring lines.
Those people are going to do very well in an AI-heavy world.
We don't have a code shortage
That's the part I keep coming back to.
We have never really had a shortage of code.
GitHub is not sitting there thinking:
"Please. Somebody. We desperately need more JavaScript."
We have a shortage of good decisions.
AI gives us more output.
More implementations.
More options.
More prototypes.
More code.
Fantastic.
But more is not automatically better.
Sometimes more is just...
more.
And if developers don't get better at filtering what gets generated, we may end up using the most powerful development tools we've ever created to produce the largest pile of mediocre software in history.
Efficiently.
I use AI constantly
This isn't an anti-AI post.
Quite the opposite.
I use AI for coding, debugging, research, writing, exploring ideas and challenging my own solutions.
I don't want to go back.
But I'm less impressed by "AI wrote this entire feature" than I used to be.
Cool.
Was it the right feature?
Is the code maintainable?
Did you understand what it generated?
Did it add complexity you don't need?
Would you have designed it that way yourself?
Those questions matter more to me now.
Maybe the job was never writing code
Maybe that was just the most visible part.
Maybe the job was always making decisions under uncertainty.
Understanding systems.
Making tradeoffs.
Finding the simplest thing that works.
And occasionally telling everyone:
No. We absolutely do not need Kubernetes for this.
AI can generate more software than any of us could ever write manually.
That part is solved.
The interesting question now is whether we're actually getting better at deciding what software deserves to exist.
I'm not convinced we are.
And honestly?
That might be a much bigger problem than AI replacing programmers.
What do you think?
Does AI make developers better engineers — or just faster at producing whatever they were already going to build?
Top comments (28)
Welcome back! I was wondering where good old NorthernDev had disappeared 😂
I think the real impact of AI-generated code and vibe coding will become clear in the next few years (or maybe sooner, given how fast things are moving). Existing projects are already being maintained with AI, but most of their code was originally written by humans. Meanwhile, companies are building and shipping entirely new products with AI-generated code. We'll see in a few years how maintainable those projects really are and how big the mess might be.
Thank you 😂 I apparently needed a small internet hibernation.
And yes, this is exactly the part I’m most curious about.
Right now, a lot of the “AI works great in production” evidence still comes from projects where humans created most of the original architecture and AI is helping with implementation and maintenance.
The really interesting test will be projects that were AI-heavy from day one.
Not whether they ship fast, they obviously can.
But what happens after 18–36 months of changes, edge cases, staff turnover and accumulated “reasonable” decisions.
That’s when we’ll find out whether AI made software development cheaper… or just moved the cost further into the future.
"The value is not in the code" - fine, but the code is the product, unless we give other 'artifacts', like documentation, the same amount of (or more) "love" as the code - but IMO we don't ...
"Maybe the job was never writing code" - but the code is what gets judged in the end ...
I noticed that code written by AI tends to be (not always, but often) more over-engineered than code written by humans ...
So, if it's unavoidable that most of the code will get written by AI (and that probably is unavoidable), then I feel that the human telling the AI "please simplify this over-engineered code" is one of the most important things we can do ...
P.S. I agree that some of the more abstract skills that you mentioned are, in the end, more important than "typing the code" - however:
(a) how are you gonna review whether the code written by AI makes sense if you never learned how to write the code yourself in the first place? You won't know how to properly "read" code if you've never "written" any ...
(b) the more abstract skills that you mentioned aren't developed in a vacuum - one of the best ways to develop them is to actually write, run and debug code yourself (i.e. not outsourcing all of the thinking and implementation to AI) - otherwise we'll forget or "unlearn" the foundations and basics of the "craft" ...
Just a bit of an anti-dote to the sentiment of "writing code doesn't matter anymore" - I still advocate that we keep writing some of the code ourselves ...
Yeah, I think this is the important nuance.
I definitely don't mean that learning to write code no longer matters. Quite the opposite, if you can't read, debug and reason about code yourself, you're in a very weak position to judge what an AI gives you.
I think my point is more that producing code is becoming cheaper, while understanding whether that code should exist, whether it is too complex, and whether it actually solves the right problem is becoming more valuable.
And I completely agree with your point about over-engineering. “Please simplify this” might genuinely be one of the most useful prompts in software development right now 😅
The part I'm still unsure about is what happens to newer developers if they skip too much of the painful manual work we all learned from. A lot of engineering judgment came from writing bad code, debugging it, regretting it, and eventually learning why it was bad.
Agreed on all accounts, especially the last one - I think juniors should still learn the basics and the skills of the trade, which includes writing code the "old fashioned" way, but also knowing the fundamentals - databases, web protocols (HTTP), HTML/CSS/JS, etc - otherwise (just as you said) how are they going to be able to review and judge the stuff AI has generated?
We're going to have to be MORE knowledgeable, not less - I think the bar is gonna be higher, not lower ...
Exactly. I think that’s the part a lot of people underestimate.
AI lowers the barrier to producing code, but it may actually raise the bar for being a good engineer.
If more implementation is generated for you, your value shifts toward understanding systems deeply enough to spot bad assumptions, fragile abstractions and subtle mistakes.
So ironically, the AI era may reward strong fundamentals more, not less.
The scary part is that it also makes it much easier to look productive without actually understanding what you’re building.
This:
"The scary part is that it also makes it much easier to look productive without actually understanding what you’re building"
That might actually be the sentence I should’ve built the whole article around.
Yeah I think that's actually the biggest risk or downside of AI for coding - more speed, more code, but less understanding ...
We need to review what AI produces, but manually reviewing all that might get overwhelming - I'm pretty sure that at some point we have to use AI to help for the reviews as well, so maybe AI can help us solve the problem it created in the first place ;-)
Yep 😂 AI creating review debt and then volunteering to clean it up feels very on-brand.
I think the real danger is when “AI reviewed the AI” becomes enough reassurance that nobody actually understands the system anymore.
At some point we still need a human who can say: “I know why this works.”
Yeah, the AI tool should not (only) say "I approve this" or "I disapprove this", but also detail at length why - what exactly did it review, and how, and what are the issues?
And the human dev should review those detailed explanations, which requires the (in-depth) contextual knowledge that you're hinting at - and then at the end it should be the human giving the thumbs up or down, not the AI ...
But some form of help from AI in doing the grunt work of reviewing all that code seems inevitable, because it's like finding needles in haystacks ...
Yeah, exactly. I think that’s probably where this is heading.
AI does the first-pass review, surfaces the suspicious parts, explains why they might be a problem — and then the human makes the actual call.
Otherwise we end up with AI writing the code, AI reviewing the code, and humans just clicking “approve” on a system nobody really understands 😅
The needle-in-a-haystack problem is very real though. At some scale, manual review of everything just stops being realistic.
Correct and agreed to all that ...
Welcome back!!! "microservices solving problems that did not exist"- this line hit hard 🤣
Thank you! 😂
Somewhere right now, a team is deploying 11 microservices to handle a contact form.
Interesting perspective!With AI generating more code than ever, how do you decide when to trust the generated solution and when to step back and simplify the design yourself?
Good question. I usually trust AI more on implementation details than on design decisions.
If the problem is already well understood and the architecture is simple, I’m happy to let AI move fast.
I step back when the solution starts introducing new abstractions, extra layers, additional dependencies or complexity that I didn’t explicitly ask for.
My rough rule is: if I can’t explain the generated design clearly in a few sentences, it’s probably too complicated.
I also ask myself one boring question a lot
What is the simplest version of this that would still solve the actual problem?
AI is very good at giving you a solution. I still think the human has to decide whether it’s the right amount of solution.
A factory 😂🤣
I laughed out loud in real life and my significant other became concerned.
I needed that. Thank you. 😂😂😂
How dare dev.to hid this from me for 3 seconds
😂
Welcome back my old friend!!
What most people never realized is that being a good developer isn't about coding, but more about design of the software being built and being able to communicate. It's those soft skills that makes a good developer because once you have the design and idea in place, it becomes much easier to build that software regardless of how much you know about its syntax. Anyone can learn programming language when you put your mind into it, but it's only a matter of if you decide to learn and put your mind into it.
This article voices what many people dare to think but not to say, and it does so very candidly.
Several points resonated with me:
“Code generation has never been the bottleneck” - this is the article’s key insight. We’ve always thought that “slow writing” was the main issue in software development, but what truly delays a project is “whether it should be done” and “how it should be done”. AI has made the easiest part free, but the hardest part has become even more expensive.
“Friction used to protect us” - this perspective is quite insightful. In the past, over-design required at least a physical effort, but now intelligent agents are all too eager to help you complete a disaster, even adding three interfaces and a factory. AI is not the danger; it just magnifies our poor decision-making.
“Taste will become a core competitive advantage” - it’s hard to quantify and doesn’t fit on a resume, but “knowing when not to code” is indeed becoming the rarest skill. Many can use AI, but few can reject AI’s outputs.
A minor addition or objection:
The author’s claim that “software hasn’t improved” might be a bit too pessimistic. AI has reduced the cost of prototyping, meaning more ideas can be quickly tested and discarded - this in itself can be a form of refining taste. The issue isn’t with the tool; it’s that most people still use the old adage “more is better” with new tools.
In response to the question at the end of the article:
My answer is: AI won’t automatically make people better engineers, but it will widen the gap - those with good judgment will be even stronger, while those without will only accumulate technical debt more rapidly. Tools are amplifiers, not transformers.
It’s worth sharing with every team member who’s fixated on “AI writing an entire feature in a day”. 👍
@the_nortern_dev , this is one of the most accurate assessments of the current AI development landscape I’ve read.
your point that "ai is extremely good at helping you overengineer" hits perfectly. when you build on constrained hardware (like a $150 android phone with 4gb of ram and spotty 3g), overengineering isn't just a bad architectural choice—it's a fatal one. the hardware physically rejects "suspiciously helpful" abstractions and 14-step microservice patterns.
this is exactly why the "boring stack" is making a comeback. constraints force us to ask the right questions: "does this need another layer?" and "could this be deleted instead?"
i completely agree with the thread about developers needing to learn the fundamentals. you cannot effectively review, debug, or simplify ai-generated code if you don't understand the underlying mechanics. that’s why i spend so much time manually building secure js sandboxes and understanding execution boundaries, rather than just prompting an agent to "make it work."
the most valuable skill right now isn't prompting; it's editing. knowing how to look at 600 lines of "perfectly respectable-looking code" and confidently delete 500 of them because they solve a problem that doesn't exist.
great to have you back. the industry needs this level of pragmatic realism. 🐯
The scary part is how convincing unnecessary complexity looks when AI generates it. Everything has a neat name, clean interfaces, proper structure... and then you realize the whole thing could've been one function.
I use AI a lot, but deleting half of what it writes is becoming a skill of its own 😅
you are alive :). I agree with you completely
Some comments may only be visible to logged-in visitors. Sign in to view all comments.