Posted on Sep 24

The AI bubble is bursting and devs are back in the game

From hype to hangover, the real winners weren’t who you think.

Remember when AI was supposed to end coding jobs overnight? Recruiters were screaming “learn prompt engineering or get replaced,” Twitter threads were full of “10x AI dev hacks,” and every other VC podcast sounded like Skynet had already filed its IPO. Fast-forward to today and… well, how’s that monkey JPEG portfolio doing?

I’ll be real: I bought into some of the hype too. I once let an AI refactor part of a billing system, thinking I was a genius for “outsourcing” grunt work. It passed tests on Friday, and by Monday our staging env was double-charging customers. I spent two days fixing what should have been a one-hour update. That was my first taste of AI’s 90% correct, 10% catastrophic problem.

Here’s the thing: AI isn’t dead. The tools are powerful and fun to use. But the hype cycle? That bubble is leaking faster than a junior dev’s memory leak in prod. Companies are cutting budgets, AI features keep breaking, and the promise of “no more human devs needed” turned out to be smoke.

TLDR:

AI isn’t replacing devs, it’s just another messy tool in the box.
The bubble is bursting because ROI didn’t match the hype.
Juniors didn’t lose jobs to AI, they lost them to post-COVID budget cuts.
AI is great as a sidekick, terrible as an overlord.
The devs who’ll win are the ones who know fundamentals and use AI smartly.

From hype beast → hangover

The hype cycle around AI in 2023–2024 was absolute chaos. VC money poured in like a busted fire hydrant, companies announced “AI transformations” before they even had working products, and LinkedIn turned into a nonstop carnival of “prompt engineer” job posts. For about six months, it felt like anyone who could type into ChatGPT was suddenly a “10x developer.”

Hiring followed the same frenzy. In late 2023, AI engineers were being snatched up like toilet paper in 2020. Companies over-hired, slapped “AI” into every roadmap, and assumed that dropping millions into GPU clusters would magically 5x productivity. TechCrunch reported on the rush of “AI-first” startups that got nine-figure valuations off slide decks. And according to the Stack Overflow 2024 Developer Survey, AI adoption among devs skyrocketed but satisfaction with the results plateaued almost immediately.

I still remember a recruiter call during lockdowns (pre-AI boom) where they basically said: “If you can spell React, you’re hired.” No joke. It was defensive hiring companies hoarding talent the way my grandma hoarded canned beans in Y2K. When AI hype landed, that defensive energy shifted:

“If you’ve touched LangChain, come onboard, we’ll figure out later what you’ll do.”

But just like the dot-com bubble or the NFT “monkey JPEG” craze, hype has a half-life. The AI hangover came fast. Budgets dried up, hiring slowed, and companies realized their shiny new LLM integrations were more duct tape than digital transformation. The ROI reports started landing, and the math didn’t justify the mania.

Sound familiar? We’ve seen this movie before. Web3, NFTs, metaverse land grabs all promised “the future” and ended up as a cautionary tale on your uncle’s Facebook feed. AI is different in that the tech is genuinely useful, but the hype that it would “replace all devs overnight” has already collapsed.

The lesson? Tech cycles always start drunk and end with a headache. And right now, we’re in the Advil-and-regret stage of the AI hangover.

Brittle by design (the 90/10 trap)

Here’s the brutal truth about AI tools: they’re fantastic at getting you 90% of the way there. But that last 10%? That’s where everything explodes.

It’s the 90/10 trap:

The first 90% feels magical. AI generates a function, a migration, or a regex in seconds.
The final 10% the edge cases, the debugging, the performance quirks still requires a human brain.
And in production, that last 10% isn’t “optional polish.” It’s the difference between working code and a weekend on PagerDuty.

Take this real example from a side project where I let AI handle a database migration script.

AI output: looked fine at first glance

ALTER TABLE users ADD COLUMN is_active BOOLEAN DEFAULT true;
UPDATE users SET is_active = true;

Seems fine, right? Except… it silently failed in staging because half our user records were archived in a separate shard. AI didn’t know that, because AI doesn’t know your system.

Human fix: the boring but safe version

ALTER TABLE users ADD COLUMN is_active BOOLEAN DEFAULT true;

-- Explicitly handle archived users
UPDATE users SET is_active = true WHERE status != 'archived';
-- Add constraint for data integrity
ALTER TABLE users ALTER COLUMN is_active SET NOT NULL;

Three extra lines, but they made the difference between “works in prod” and “oops, we just corrupted a third of our dataset.”

This is the 90/10 trap in action. AI crushed the boilerplate but missed the nuance. And in engineering, nuance is the job.

It’s like your Wi-Fi during a Zoom call: looks stable, then freezes the moment you start presenting. Ninety percent uptime doesn’t matter when the critical ten percent fails.

This brittleness isn’t a dealbreaker it just defines the tool’s ceiling. AI can draft, scaffold, and accelerate, but it can’t replace fundamentals. Debugging, testing, and system awareness are still squarely on us.

And here’s the kicker: that final 10% is often the hardest part to teach juniors, which makes it even clearer why AI isn’t killing dev jobs anytime soon.

AI companies breaking their own toys

If AI was really the flawless future, why does it feel like half the industry is held together with duct tape and patch notes?

Case in point: OpenAI’s GPT-5 rollout. Overnight, they broke custom GPTs the very feature thousands of devs and small startups had built their workflows on. One morning you had a product, the next you had a 404. OpenAI’s own release notes basically confirmed what devs already knew: upstream AI companies will happily refactor their models out from under you, even if it nukes your app.

Imagine if Python decided to ship 3.13 and just removed half of the standard library. You wake up, import datetime no longer works, and your production app collapses. That’s exactly what it felt like when GPT-5 dropped and custom GPTs vanished without warning.

And this isn’t unique to OpenAI. Across the board, AI companies have been sprinting to ship features, then quietly ripping them back out when they can’t scale or when the models break. Features appear, disappear, get renamed, or degrade in quality week by week.

For developers, it’s brutal. You’re not just coding against your own bugs anymore; you’re coding against someone else’s unstable roadmap. Building a startup on top of these APIs feels like building a bridge on quicksand. The foundations shift before you even lay the second plank.

I’ve seen devs in Discord communities post screenshots of broken AI workflows that worked on Monday and failed by Friday. No code changes. Just upstream instability. Try explaining that to your PM:

“Yeah, it’s not our bug, it’s OpenAI’s mood this week.”

This is the quiet killer of the AI bubble. Not hallucinations, not hype but the simple fact that the platforms themselves aren’t reliable enough yet to be treated like core infrastructure.

So sure, AI companies love to pitch “production-ready AI.” But when you’re relying on patch notes as your dependency management system? That’s not production. That’s chaos.

Juniors didn’t lose jobs to AI (the real bubble)

One of the laziest narratives that came out of the AI hype wave was:

“Junior devs can’t get jobs anymore because AI replaced them.”

I’ve seen that take plastered across Reddit, Twitter, even LinkedIn thinkfluencers. And to be blunt it’s nonsense.

The real story is much less sci-fi and way more boring: the hiring bubble popped.

During COVID lockdowns, companies were panic-hiring. Defensive hiring was the strategy grab anyone who could spell “React” or type console.log() because nobody knew if the talent market would freeze up. I saw juniors with six months of bootcamp experience getting offers from unicorn startups. Not because they were “future staff engineers,” but because companies wanted warm bodies in case things went south.

Then reality hit. Growth slowed, budgets tightened, and CFOs pulled out the red pen. The result? Tech layoffs, hiring freezes, and teams shrinking back down to lean size. The Wall Street Journal and Bloomberg both reported how post-COVID hiring frenzies reversed into budget cuts across 2023–2024. AI didn’t eat those jobs. Corporate spreadsheets did.

Here’s the vulnerable part: I mentored a junior dev who DM’d me in a panic, convinced ChatGPT had literally killed their chances of landing an internship. They had friends telling them “don’t bother applying, AI already writes code better than you.” It crushed their confidence. The truth? Their rejection had nothing to do with AI. The company had axed all internships that year. No human, no AI, no nothing. Just a budget freeze.

That gaslighting is one of the ugliest side effects of the hype. Juniors believed they were competing with robots, when in reality they were competing with economic downturns and overzealous bean counters.

Let’s be clear: AI isn’t great at mentorship, it isn’t going to guide you through your first messy merge conflict, and it’s definitely not going to help you survive your first on-call rotation. Juniors still matter, but the job market cycle went cold not because AI won, but because the hiring bubble burst.

And here’s the irony: the very juniors who thought AI was stealing their careers are the ones who will probably be best at using AI as a sidekick. They grew up with it, they’re fluent with the tools, and once the market rebounds, they’ll be dangerous in the best way.

The AI sidekick rulebook

Here’s the mental shift that actually works: stop treating AI like your boss, and start treating it like your slightly chaotic sidekick. Batman doesn’t hand Gotham to Robin and walk away same logic here.

I’ve boiled this down into a rulebook I wish someone had handed me the first time I tried building with AI:

1. Use it for boilerplate, never architecture

Perfect for: writing tests, generating docstrings, or scaffolding CRUD endpoints.
Terrible for: designing distributed systems or planning data migrations.

2. Trust but verify (with tests)

If AI spits out a migration or algorithm, don’t just ship it. Wrap it in tests and run it through staging like it came from an intern.

3. Let it summarize, not decide

Research? Great. Summarizing a messy RFC into bullet points? Awesome.
But if you’re letting AI decide your database schema, you’re basically handing your car keys to a toddler with Google Maps.

4. Regex is fair game

Hot take: regex is the perfect AI task. Saves you from the “trial and pray” loop, and you can instantly verify the output.

Decision table (bookmark this)

Mini-example

I once let Copilot generate a unit test suite for a REST endpoint. It covered happy paths beautifully… and ignored every edge case. Would’ve looked fine on a PR at first glance, but when I added one null payload, the whole suite went red. That’s the rulebook in action: AI is your fast-draw partner, not your systems engineer.

Receipts from the field

You don’t have to take my word for it dev forums are full of examples. On r/programming, you’ll find threads where Copilot wrote SQL that looked fine but dropped half a dataset, or where ChatGPT confidently referenced Python functions that don’t exist. Hacker News summed it up best:

“AI is the intern who works fast but lies confidently. You wouldn’t ship their code without a review why ship AI’s?”

Quick example: a dev asked AI to fix a timestamp parser. It generated:

return datetime.strptime(ts, "%Y-%m-%d %H:%M:%S")

It failed whenever a timezone suffix appeared. The human fix? Use datetime.fromisoformat() with a fallback. Two lines of defensive coding, but critical.

The receipts are clear: AI accelerates, but without fundamentals and review, it’s just a confident intern pushing straight to main.

When the dust settles who actually wins

When the hype clears, the winners won’t be the suits dropping “AI” in pitch decks it’ll be the devs who can still debug, design, and ship. Fundamentals like architecture, testing, and debugging never go away.

Hot take: AI is the new Excel. Everyone uses it, but experts still dominate. AI will be everywhere, but the best devs treat it as a multiplier, not a crutch.

Conclusion

The bubble burst because ROI didn’t match hype not because AI is useless. It’s sticking around, just moving into the background like Git or Docker. Use it, learn it, abuse it but don’t fear it. You’re not competing against AI, you’re competing against devs who also have it in their toolbox. And in that race, fundamentals decide who wins.

DEV Community