Posted on Apr 16

The AI bubble is weakening and another one is already 80% in place

#webdev #ai #llm #programming

Hype didn’t die it just got expensive, boring, and quietly replaced by a much riskier mess underneath

Press enter or click to view image in full size

It’s getting harder to ignore the vibe shift.

Not because AI suddenly stopped working. Not because the models got worse. But because the magic wore off and someone finally opened the billing dashboard.

A year ago, everything was AI. Every demo, every startup pitch, every GitHub README. You could slap “powered by LLMs” on a half-baked feature and people would clap like you’d invented electricity. It felt like discovering cheat codes in a game you’d been grinding for years.

Now? The same demos land with a quiet nod. Cool. Interesting. What does it cost? How fast is it? Who maintains it?

That’s usually where the room gets awkward.

Somewhere between “this is insane” and “why is latency 900ms,” the AI hype curve flattened. Not collapsed. Flattened. The novelty tax expired. And once novelty disappears, reality shows up with a calculator and a checklist.

There’s a meme floating around that says, “This could’ve been a cron job.” That joke hurts more now than it did six months ago. Because a lot of AI products aren’t bad they’re just expensive, fragile, and solving problems we already knew how to solve.

Here’s the part nobody’s really talking about though: while everyone was staring at the AI balloon, another one was quietly inflating underneath. Layer by layer. Tool by tool. Abstraction on abstraction. And unlike the AI hype, this one doesn’t explode loudly. It just collapses systems, teams, and careers when the funding music stops.

TL;DR:
AI isn’t dead. The hype phase is fading. The real risk is the mess we’ve built around it and most devs are standing right in the blast radius.

The AI bubble didn’t pop it just stopped impressing

The thing about hype bubbles is that they almost never end with a bang.

They end with silence.

That’s where AI is right now.

Nothing “failed.” Models are better than ever. Context windows got bigger. Reasoning improved. Tool calling works. Half the stuff that sounded impossible two years ago is now an API call away.

And yet… the excitement dropped off a cliff.

Why?

Because novelty expired.

The first time you watched a model write working code, it felt illegal. Like you’d found a dev console in real life. The tenth time, it felt useful. The hundredth time, it felt expected. And now? It’s just another dependency that sometimes breaks in production.

This is the boring phase. And boring is where bubbles quietly deflate.

I remember when spinning up an EC2 instance felt like cheating the universe. No hardware, no waiting, no begging IT. Now nobody brags about EC2. It’s just table stakes. AI is sliding into the same slot. Not because it’s worse but because it’s normalized.

A lot of products didn’t see that coming.

Entire startups were built on “look what the model can do,” assuming that wow factor would last forever. But once every app has autocomplete, chat, summarization, and a sparkly assistant, users stop being impressed and start asking annoying questions like “why is this slow?” and “why does this cost extra?”

That’s when the hype math stops working.

I’ve watched teams ship AI features that demos loved and users ignored. PMs were excited. Investors nodded. Customers tried it once, shrugged, and went back to their old workflow because it was faster and didn’t hallucinate.

That’s not a failure of AI. That’s a failure of expectations.

When everything becomes “AI-powered,” nothing feels special. The bar moves from magic to reliability. From “can it do this?” to “can I trust this at scale?”

And a lot of the current ecosystem was never built for that question.

The bubble didn’t burst. It just stopped being fun.

And when something stops being fun in tech, the funding, patience, and forgiveness disappear right after.

The economics finally showed up with a calculator

AI didn’t get worse. It got measurable.

That’s the part that killed the mood.

In the early days, nobody cared what anything cost. Tokens were cheap. Usage was low. Every demo was a win, every graph went up and to the right, and nobody asked what would happen when real users showed up and started hammering the system like it was a free buffet.

Then production happened.

Suddenly, every clever prompt had a price tag. Every retry loop had a multiplier. Every “just add AI here” decision showed up on a bill someone had to explain in a meeting they didn’t want to be in.

Inference is sneaky like that. It doesn’t look expensive at first. It becomes expensive slowly, then all at once.

You ship a feature. Usage grows. Latency spikes. You add retries. You add fallbacks. You cache a little. Then someone asks why a simple request now costs more than the rest of the backend combined. That’s usually the moment when AI stops feeling like magic and starts feeling like a liability.

The worst part is that the costs aren’t just financial. Latency creeps in where users feel it most. A half-second delay in a chat app feels broken. A second delay in a workflow tool feels unusable. You can optimize databases, compress payloads, and tune caches all day, but once you’re waiting on a model call, you’re at the mercy of infrastructure you don’t control.

I’ve sat in reviews where someone said, “Can we make the AI feel instant?” and the room went quiet. Not because it was a bad question but because everyone already knew the answer.

Not without paying for it. And not reliably.

This is where the calculators came out. Token pricing. GPU time. Cold starts. Region availability. Suddenly, teams were reading pricing docs they’d previously ignored and realizing their “cheap MVP” only worked at demo scale.

The shift was subtle but brutal. AI went from “we should use this everywhere” to “where does this actually justify itself?”

That question doesn’t kill bad tech. It kills lazy thinking.

And a lot of AI hype was built on the assumption that nobody would ever ask it.

The quiet bubble forming: abstraction and infra debt

While everyone was busy arguing about whether AI would replace developers, we quietly built something far more dangerous.

A stack nobody fully understands.

This is the part that worries me more than the AI hype cooling off. Because hype fades. Debt sticks around. And right now, we’re stacking abstractions like it’s free, permanent, and someone else’s problem.

Look at a “modern” AI-powered product and trace a single request.

Frontend calls an API.
API hits an AI gateway.
Gateway routes to a model provider.
Model calls tools.
Tools query a vector database.
Vector DB sits behind another service.
Retries fire. Fallbacks trigger.
Logs scatter across three vendors.

And somewhere in that chain, a user is staring at a spinner wondering why typing text feels slower than it did five years ago.

This isn’t innovation. It’s abstraction debt compounding in real time.

We’ve seen this movie before. Microservices promised freedom and delivered distributed debugging. Kubernetes promised consistency and delivered YAML-induced insomnia. Every layer was justified in isolation. Together, they formed a system where nobody could confidently say, “I know how this works end to end.”

AI just accelerated that habit.

Instead of asking “should this exist,” teams ask “which tool should we use?” Instead of simplifying, they add wrappers. Instead of owning complexity, they outsource it to platforms that outsource it again.

I once spent half a day chasing a production issue that turned out to be a prompt change. Not a deploy. Not a config flag. A sentence. But to figure that out, I had to dig through logs from an API service, a model provider, a vector DB, and a tracing tool that only partially agreed with reality.

That’s when it clicked: this isn’t an AI problem. It’s a systems problem.

The scary part is that this bubble doesn’t pop dramatically. There’s no crash. No headline. Just gradual decay. Features become brittle. Onboarding gets harder. Costs rise. Velocity drops. Eventually someone says the magic words: “We need to simplify.”

Which is usually code for rewrites, layoffs, and lost trust.

The bubble is already 80% in place because the habits are locked in. The tools are entrenched. The abstractions are normalized. And everyone assumes future-you will clean it up.

Future-you never does.

This isn’t anti-AI. It’s anti-building towers of glass and hoping they survive real traffic.

And that’s why this bubble scares me more than the last one.

What happens when this bubble deflates

The deflation phase never looks like the crash movies promised.

There’s no panic button. No sudden outage that makes headlines. What happens instead is quieter and way more familiar: priorities change, patience disappears, and everything that once felt “strategic” gets reevaluated under fluorescent lighting.

This is where abstraction bubbles really hurt.

When funding tightens or growth stalls, companies stop asking “what’s cool?” and start asking “what can we remove without breaking production?” That’s a terrifying question if your entire product is a pile of dependencies nobody owns end-to-end.

The first thing to go is experimentation. Then come the freezes. Then the roadmap slides start using words like focus, alignment, and simplification. If you’ve been around long enough, you know what those words mean. They mean fewer people are about to maintain more complexity.

This is also where the value of certain roles flips overnight.

Teams that understood infra, cost modeling, and system boundaries suddenly become critical. The people who can trace a request from browser to backend to model and explain where the money and time go stop being “boring” and start being “essential.”

Meanwhile, products that were built as thin AI wrappers struggle. Not because AI stopped working, but because there’s nothing left once the hype premium disappears. If your differentiation was “we added a model,” you’re now competing with every other team that did the same thing including internal teams who don’t need to pay a margin.

I’ve seen this play out before. Not with AI, but with microservices and cloud-native everything. The survivors weren’t the ones who used the most tools. They were the ones who knew when to delete them.

What makes this phase emotionally rough is that it feels like going backward. Simpler architectures. Fewer features. More manual thinking. But it’s not regression. It’s correction.

The bubble doesn’t pop and leave rubble. It slowly leaks until what’s left has to justify its existence line by line.

And that’s when you find out whether your system was built to impress… or to last.

What devs should do before the pop

This is the part where people usually expect a hot take like “learn AI” or “go all in on infra.”

That’s not it.

The move right now isn’t chasing the next tool. It’s learning how to survive when tools start disappearing.

If you’re a developer, especially one early or mid-career, the safest skill set in the next few years won’t be prompt wizardry or framework hopping. It’ll be understanding where complexity lives, what it costs, and how to remove it without breaking everything.

Start with the boring stuff nobody tweets about.

Read cloud bills. Not summaries the ugly line items. Know what costs money when traffic doubles and what doesn’t. Understand why a single request can fan out into five services and which one you actually control. That knowledge becomes leverage fast when budgets tighten.

Then look at your stack and ask uncomfortable questions. Which parts exist because they genuinely reduce work, and which parts exist because someone once said “best practice” in a meeting? How many layers could disappear if you were forced to run this with half the team?

I’ve watched teams panic during “simplification initiatives” because nobody knew what was safe to remove. The devs who thrive are the ones who can say, calmly, “this service can go,” and be right.

Treat AI the same way you treat any powerful dependency. It’s not special. It’s not sacred. It’s something you measure, isolate, and replace if it stops pulling its weight. The moment you can’t explain what happens when it fails, you’re already in trouble.

There’s also a mindset shift here that matters more than any tool choice. Fewer abstractions. Smaller systems. Clear ownership. Build things you could explain on a whiteboard without apologizing.

When the bubble deflates, nobody gets rewarded for using the most tech. They get rewarded for shipping something that still works when the noise is gone.

That’s not glamorous. But it’s how you stay employed while everyone else is rewriting their rewrite.

This isn’t about fear. It’s about preparation.

And preparation always looks boring right before it pays off.

The bubble lesson we never seem to learn

Every tech bubble starts the same way.

Something genuinely useful shows up. Early adopters win. The rest of the industry rushes in. Money floods the space. Bad ideas get funded alongside good ones. Complexity gets justified as ambition. And somewhere along the way, we stop asking whether we’re building something durable or just something impressive.

AI isn’t special in that sense. It’s just the latest mirror.

What makes this moment uncomfortable is that nothing is obviously broken. The models work. The tooling mostly works. The demos still look good. That’s why it’s tempting to assume the party continues. But the signs aren’t technical they’re emotional. Less excitement. More caution. More questions about cost, ownership, and long-term sanity.

That’s usually when engineers start feeling tired instead of inspired.

The weakening of the AI bubble doesn’t mean the tech disappears. It means it grows up. And growth is painful when it exposes all the shortcuts we took while things were fun. The real danger isn’t that AI fades away. It’s that we carry forward a mess of abstractions, dependencies, and half-understood systems that make everything slower, riskier, and harder to change.

The next bubble isn’t hype-driven optimism. It’s accumulated complexity pretending to be progress.

The good news is that this phase also creates space. Space for fewer tools. Clearer systems. Better engineering judgment. The people who thrive here aren’t the loudest or the trendiest. They’re the ones who understand tradeoffs, can explain systems simply, and know when to say no.

If there’s one lesson worth keeping, it’s this: the best developers don’t chase waves. They learn how the water moves, where it’s shallow, and where it will drag you under if you’re not paying attention.

AI will stay. So will change. The question is whether we keep building towers of glass and hoping they hold or whether we finally get comfortable building things that last even after the hype leaves the room.

If this piece annoyed you a little, good. That usually means we’re close to something honest.

Now I’m curious: where do you think the real cracks are showing up already?