DEV Community

Cover image for AI Got Better While I Was Away. Software Didn't.
NorthernDev
NorthernDev

Posted on AI-assisted

AI Got Better While I Was Away. Software Didn't.

AI speed exposes bad architectural habits

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 (85)

Collapse
 
annavi11arrea1 profile image
Anna Villarreal •

A factory 😂🤣

I laughed out loud in real life and my significant other became concerned.

I needed that. Thank you. 😂😂😂

Collapse
 
the_nortern_dev profile image
NorthernDev •

Hahaha perfect 😂

Tell your significant other the factory was necessary

Collapse
 
francistrdev profile image
FrancisTRᴅᴇᴠ •

How dare dev.to hid this from me for 3 seconds

Collapse
 
annavi11arrea1 profile image
Anna Villarreal •

😂

Collapse
 
leob profile image
leob • • Edited

"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 ...

Collapse
 
the_nortern_dev profile image
NorthernDev •

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.

Collapse
 
leob profile image
leob •

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 ...

Thread Thread
 
the_nortern_dev profile image
NorthernDev •

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.

Thread Thread
 
leob profile image
leob •

This:

"The scary part is that it also makes it much easier to look productive without actually understanding what you’re building"

Thread Thread
 
the_nortern_dev profile image
NorthernDev •

That might actually be the sentence I should’ve built the whole article around.

Thread Thread
 
leob profile image
leob •

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 ;-)

Thread Thread
 
the_nortern_dev profile image
NorthernDev •

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.”

Thread Thread
 
leob profile image
leob •

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 ...

Thread Thread
 
the_nortern_dev profile image
NorthernDev •

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.

Thread Thread
 
leob profile image
leob •

Correct and agreed to all that ...

Collapse
 
gramli profile image
Daniel Balcarek •

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.

Collapse
 
the_nortern_dev profile image
NorthernDev •

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.

Collapse
 
francistrdev profile image
FrancisTRᴅᴇᴠ •

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.

Collapse
 
the_nortern_dev profile image
NorthernDev •

Hahaha, there you are 😄
Feels weird being back in a comment section with you again.
And yeah, i think that’s exactly it. The syntax is rarely the hardest part once you know how to learn.
Design, communication, trade offs, knowing what not to build, that’s where the real difficulty usually is.
AI just makes that more obvious now because the typing part is getting cheaper and cheaper.

Collapse
 
ascendra_ventures_92c21f2 profile image
Ascendra Ventures •

This matches what I see in client work. The models improved a lot, but most of the software problems I get asked to fix were never about typing speed. They were about nobody agreeing what the thing was supposed to do, or what finished looked like.

A stronger model applied to a vague request produces a more convincing version of the wrong thing. Where AI does help is when the problem is already small and clearly defined: one workflow, one integration, one report, with acceptance criteria written down before anyone opens an editor. In that setting the speed gains are real and they stick.

So I would read your observation as a scoping gap more than a tooling gap. Curious what you noticed first on coming back: more code, or more of the same old bugs arriving faster?

Collapse
 
the_nortern_dev profile image
NorthernDev •

Yeah, I think “more of the same old bugs, just faster” is probably the best way to put it.
The code itself is often fine. The problem is when the request is vague to begin with. Then AI just gets you to the wrong thing quicker 😅
I’ve noticed the same as you though, when the task is small, clear and boringly specific, AI is genuinely brilliant.
Feels like the real skill now is getting the problem clear before anyone starts building.

Collapse
 
sylwia-lask profile image
Sylwia Laskowska •

Welcome back!!! "microservices solving problems that did not exist"- this line hit hard 🤣

Collapse
 
the_nortern_dev profile image
NorthernDev •

Thank you! 😂
Somewhere right now, a team is deploying 11 microservices to handle a contact form.

Collapse
 
fgrandon profile image
Francisco Grandón •

That point about friction being a safety mechanism hits straight where it hurts.

In distributed systems, when you increase the ingest throughput by two orders of magnitude without adding backpressure, you don't get a faster pipeline—you just crash the consumer downstream. That's essentially what happened to engineering workflows. The token generator has virtually infinite bandwidth, but human cognitive capacity for reasoning about invariants, edge cases, and failure modes at 3 AM remains strictly single-threaded and bounded.

There's also a statistical trap with "reasonable-looking" code. Language models are probabilistic predictors trained on the entire corpus of public software. And what is the arithmetic mean of enterprise software over the last twenty years? AbstractSingletonProxyFactoryBean and six layers of indirection around a single SQL SELECT query. Radical simplicity is statistically an outlier in the latent space; the gradient naturally rolls down toward boilerplate. If you don't fight that gravitational pull with active, stubborn judgment, you end up shipping an entire distributed architecture just to serve a CRUD dashboard.

Ken Thompson once famously noted that one of his most productive days was throwing away a thousand lines of code. Nowadays, the agent can hand you those thousand lines back in four seconds flat, complete with synthetic unit tests that all pass while asserting precisely nothing.

The real job was never typing syntax anyway; it was acting as a low-pass filter against systemic noise. If we don't treat deletion as a first-class refactoring operation, we’re going to need a PDP-11 memory limit just to force ourselves back into having architectural taste.

Collapse
 
the_nortern_dev profile image
NorthernDev •

Hahaha, this is such a good way to put it.
“Human cognitive capacity is still single-threaded” is probably the cleanest explanation of the whole problem.
And yeah, that point about simplicity being the statistical outlier is interesting too. AI has seen oceans of enterprise boilerplate, so of course it happily reproduces it.
I think that’s why deletion matters so much now. Generating code is cheap. Resisting unnecessary code is the actual work.
Also, “synthetic unit tests that all pass while asserting precisely nothing” hurt more than it should

Collapse
 
mendoncamaria profile image
Maria Mendonca •

This is a very interesting article and the end question makes a lot of sense. From the coding POV, we are getting solution to problem, but sometimes the AI will give unnecessary solution to a problem that can be solved in 3 lines in one file. My personal opinion is the speed of development has gone up, which is a good thing, but the quality of the code in some cases is going down, and it is a very serious thing. I lead a team and sometimes looking at their AI generated code during review gives me a headache because the code is unnecessarily complex, too much of unwanted changes that might not be required, and the review takes more time than writing the code.

To be a better developer you need to be proficient in code reviews and understanding why AI has given certain solution to a problem and if any alternate solution exists. Anyone can generate a code, but only a software developer can review if the generated code actually makes sense and is required.

Collapse
 
the_nortern_dev profile image
NorthernDev •

Yep, this is exactly the kind of thing I keep hearing from people doing reviews now.
The funny part is that AI can save 30 minutes writing the code and then create an hour of review work because it touched five files it didn’t need to touch.
And i agree with your last point completely. Generating code is becoming the easy part. Being able to look at it and say “this is technically valid, but it’s still the wrong solution” is where the real skill is.
That review muscle is probably going to matter more, not less.

Collapse
 
jimmyjams profile image
James •

Well said! This is more or less what I've been saying too. We can produce more code, but we haven't gotten any better at understanding users, customers, stakeholders, etc. Devs are creating tons of code and bringing down GitHub but are they solving problems that need to actually be solved. Companies are forcing devs to produce at an alarming rate with LLMs, but they haven't gotten any better at product management. Companies that were feature factories before still are, they're just producing more.

Collapse
 
the_nortern_dev profile image
NorthernDev •

We’ve gotten much better at producing software, but not necessarily at deciding what users actually need.
And if product thinking stays weak, AI just helps us ship the wrong things faster.

Collapse
 
koda2026 profile image
Harun - solo dev •

@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. 🐯

Collapse
 
the_nortern_dev profile image
NorthernDev •

This is such a good point about constraints.
When the hardware is actually limited, you don’t really get to pretend complexity is free.
And yeah, I’m with you on editing. The ability to look at 600 lines and calmly delete 500 of them is probably more valuable than being able to generate the 600 in the first place.
Appreciate the welcome back too. Feels good to be writing again.

Collapse
 
koda2026 profile image
Harun - solo dev •

northerndev, exactly. when hardware is actually limited, you don’t get to pretend complexity is free.

the ability to look at 600 lines of code and calmly delete 500 of them is the ultimate senior dev superpower. generation is cheap; curation and ruthless editing are where the real engineering happens. glad to have you writing again! 🐯✂️

Thread Thread
 
the_nortern_dev profile image
NorthernDev •

Hahaha, “generation is cheap; curation is the work” pretty much sums it up 😅
And yeah, deleting 500 lines without panicking is definitely a senior dev skill.
Feels like AI is making good editing taste more valuable than ever.

Some comments may only be visible to logged-in visitors. Sign in to view all comments.