Back to the blog
AIBunOpen SourceCareer

Is the AI bubble real? What Bun shows developers

November 10, 2026·6 min read·Diego Horvatti

Every week someone says the AI bubble will pop next Tuesday. Matteo Raso published a post going the other way: I'm not convinced the AI bubble exists. I read it. I agreed with part of it and disagreed with another part. To talk about it, I wanted an example every JavaScript developer knows: Bun.

The reason is simple. Bun is the runtime I use every day, and it ended up inside an AI company. If there's a bubble, it runs through my package.json.

So what is this AI bubble, anyway

A bubble is when the price of something drifts away from the value it creates. If you remember 2000, you remember Pets.com. A pet food site with the valuation of a serious company. It went under in less than a year.

People who call AI a bubble usually bring three arguments:

  • Companies spend far more on GPUs and data centers than they earn.
  • Models become commodities fast, so margins disappear.
  • Lots of startups are just a pretty interface on top of another company's API.

People who say it's not a bubble answer with one thing: people are paying. And paying a lot. Raso's post goes down that path. A bubble needs a product nobody really uses. That's not what's happening in the daily life of people who write code.

Where Bun fits into this story

At the end of 2025, Anthropic bought Bun. Claude Code runs on Bun, and the company chose to own the runtime instead of depending on a third-party project. At the time of the announcement, Anthropic said Claude Code had already passed 1 billion dollars in annualized revenue.

Think about what that number means. It's not investment. It's not a promise for 2030. It's people and companies paying a subscription every month to have an agent writing code. Pets.com never had that.

And there's a detail I find more revealing than the number. Nobody buys a JavaScript runtime for marketing. You buy it because your main product depends on it, and you can't be hostage to a startup that might shut down. It's an infrastructure decision. The kind made by someone who plans to stick around.

A bubble is when nobody uses it. Here the problem is the opposite: everybody uses it and nobody knows what it costs.

So it's not a bubble? Hold on

This is where I push back a little on the optimism. Having revenue doesn't mean the math works.

Running these models costs a fortune. A 20 dollar subscription can be cheap for someone who asks two questions a day. And way too expensive for someone who leaves an agent refactoring a monorepo all night. We've seen it happen: usage limits tightening, plans getting renamed, "fair use" showing up in the fine print.

So here's my take:

  • The demand is real. I use it, my team uses it, clients ask if we use it.
  • Today's price is not the final price. Part of what you pay today is subsidized by investor money.
  • There will be a correction. Not in usage. In valuations and in startups that only exist as wrappers.

This looks more like the internet in 2001 than Dutch tulips. The dot-com bubble popped and the internet still won. The losers were the ones who paid too much at the wrong time.

What this changes in your code

This is where the discussion leaves economics and becomes an engineering problem. Bubble or not, there are three things I'd do today.

1. Treat Bun as a dependency, not a religion. Bun is still open source under the MIT license, and Anthropic said it stays public with the same team. I believe it. But a project's priorities change when it gets an owner with its own product. If the roadmap starts leaning toward what Claude Code needs, you'll notice.

The defense is cheap: write code that runs on more than one runtime. Most of what Bun offers already has an equivalent in standard web APIs.

// Locked into Bun
const file = Bun.file('./config.json')
const config = await file.json()

// Works on Bun, Node and Deno
import { readFile } from 'node:fs/promises'
const config = JSON.parse(await readFile('./config.json', 'utf8'))

Bun.file is faster and nicer. Use it where it matters, on the hot path. Everywhere else, node:fs does the job and doesn't lock you in.

2. Keep a test running on Node in CI. One extra job. Cheap. It just makes sure you can still leave if you need to.

# .github/workflows/ci.yml
jobs:
  test-bun:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: oven-sh/setup-bun@v2
      - run: bun install && bun test
  test-node:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 24 }
      - run: npm ci && npm test

If that second job breaks one day, you find out right away. Not six months later during an emergency migration.

3. Don't tie your product to a single model. This one matters more than the other two. If your app calls an LLM API, put a thin layer in front of it. A function, not a framework.

type Ask = (prompt: string) => Promise<string>

export const ask: Ask = async (prompt) => {
  const res = await fetch(process.env.LLM_URL!, {
    method: 'POST',
    headers: { Authorization: `Bearer ${process.env.LLM_KEY}` },
    body: JSON.stringify({ model: process.env.LLM_MODEL, prompt }),
  })
  return (await res.json()).text
}

When the price changes, and it will, you swap three environment variables instead of rewriting the app.

And your career, is it at risk?

This is the question I get most in my DMs. My honest answer: if the bubble pops, the first to suffer is the "prompt engineer" job at a startup with six months of runway. People who understand databases, deploys, performance and product keep having work. With or without AI.

Bun is actually a good reminder of that. It became valuable because someone solved a boring problem really well: installing dependencies and starting a server fast. There was no hype in that. There were benchmarks, closed issues and a lot of hand-written Zig. AI bought exactly that: solid engineering.

A slightly funny warning: if your career plan depends on AI being a bubble, you're betting against the tool your competitor is using right now. Doesn't sound like a good bet.

My opinion, no hedging

I don't think AI is a bubble in the classic sense. The usage is real, the revenue is real, and a company buying the runtime its product runs on is something you do when you think in decades. But I do think today's prices are a sale that won't last, and that a lot of companies around it will disappear.

For developers, the lesson is the same as always: use the tool, enjoy the subsidy while it lasts, and always keep the exit door unlocked. Running on more than one runtime and swapping models with an environment variable costs little today and can save your project tomorrow.

That's how I've been building things around here. If you want to see it in practice, take a look at my projects.

LinkedIn summary

Everyone swears the AI bubble pops next Tuesday. I look at my package.json and I'm not so sure.

Anthropic bought Bun, the runtime I use every day, because Claude Code runs on it and already brings in more than 1 billion dollars a year.

Nobody buys a JavaScript runtime for marketing. That's a decision made by someone who plans to stick around.

But revenue doesn't mean the math works. Today's prices are subsidized by investors, and they will change.

My take: the usage is real. The correction will hit valuations and startups that are just wrappers. This looks more like the internet in 2001 than Dutch tulips.

For developers, the lesson is simple: use the tool, enjoy the subsidy and keep the exit door unlocked. Code that runs on more than one runtime. A model you can swap with an environment variable.

I wrote the full article with code examples. If it makes sense to you, the link is in the comments.

#ArtificialIntelligence #JavaScript #Bun #SoftwareDevelopment #Career