Three weeks ago I wrote about switching everything to Bun. People told me I was taking a risk on immature tooling.

Today, Anthropic announced their first acquisition ever. They bought Bun.

A $183 billion AI company just bet their fastest-growing product on the “risky” JavaScript runtime. Let me tell you why.

The Claude Code Phenomenon

Claude Code hit $1 billion in run-rate revenue in November 2025. Six months after public launch. That’s not a typo.

The growth trajectory is staggering:

  • April 2025: ~$17.5M annualized
  • July 2025: $400M
  • November 2025: $1B

10x growth in three months. Usage growing faster than they could scale. Netflix, Spotify, KPMG, L’Oréal, Salesforce - all using it in production.

This isn’t API revenue or chat subscriptions. It’s a CLI tool. A terminal application that writes code. And it’s generating a billion dollars a year.

Bun represents exactly the kind of technical excellence we want to bring into Anthropic.

— Mike Krieger, Anthropic CPO

Why Bun Powers Claude Code

Claude Code ships as a Bun executable to millions of developers. The tech stack is deliberately minimal: TypeScript, React, Ink, Yoga, and Bun.

Why Bun? Three reasons:

Single-file executables: bun build --compile turns any JavaScript project into a self-contained binary. No Node installation. No dependency management for end users. Download and run.

Speed at every layer: 4x faster cold starts. 32% faster Docker builds. 2x faster startup with bytecode compilation. When you’re processing 195 million lines of code weekly across 115,000+ developers, these numbers compound.

Distribution simplicity: The native installer they recently launched? Built on Bun’s cross-compilation. One build command, every platform.

The infrastructure play

Jarred Sumner (Bun’s creator) said joining Anthropic lets them skip the “VC-backed startup tries to figure out monetization” chapter. Now they can focus entirely on building the best JavaScript tooling - with AI-native development as the primary use case.

My Container Migration

Since writing the original post, I’ve moved all my containers from Node to Bun. The results are mostly great:

  • Image sizes: Bun’s Debian-based image (~65MB) is 2-3x smaller than node:slim (~200MB). Almost the same compatibility, fraction of the size.
  • CI pipelines: Build times cut by a third. Cold starts 4x faster.
  • Single executables: No more “ensure Node is installed” in deployment scripts. bun build --compile and ship the binary.
  • Cross-compilation: Build Linux binaries from Mac. One dev machine, every target.

But “mostly” is doing some work. Last week I hit a module resolution issue with jose in a Next.js production container. Bun worked perfectly for package management and builds, but the runtime choked. Solution: use Node for the runner stage, Bun for everything else.

# Build stage: Bun (fast installs, fast builds)
FROM oven/bun:1-alpine AS builder
RUN bun install && bun run build

# Runner stage: Node (wider compatibility)
FROM node:22-alpine AS runner
CMD ["node", "server.js"]

This is the reality of Bun in late 2025: it works 90% of the time. The other 10% you fall back to Node for specific stages. Still worth it - the build speed alone justifies the hybrid approach. And the gap is closing fast.

What This Signals

This acquisition isn’t about JavaScript tooling. It’s about AI-native infrastructure.

The companies building the next generation of developer tools - Claude Code, Cursor, FactoryAI, Lovable - they’re not choosing “battle-tested” legacy stacks. They’re choosing tools optimized for their actual constraints: distribution, startup time, bundling, cross-platform delivery.

Bun is now backed by:

  • A $183B company
  • $15B in recent investment (Microsoft/Nvidia)
  • Explicit commitment to keep it open source (MIT license)
  • The fastest-growing AI product as its primary consumer

The “risky new tool” narrative is dead.

Acquisition doesn't fix everything

Bun still has ~90% Node.js API compatibility. Edge cases exist. Some native modules don’t work. The acquisition gives them resources to close gaps faster, but it’s not magic. Test your specific use case.

The Lesson

Three weeks ago: “lol use bun”

Today: Anthropic’s first acquisition in company history.

The conventional wisdom said pnpm was safe and Bun was risky. My experience said the opposite. Now a company valued at $183 billion is betting their fastest-growing product on the same conclusion.

Sometimes the “risky” new tool is the infrastructure for what comes next. And sometimes betting early pays off.

This is a follow-up to Use Bun. The original post covers the practical migration from pnpm and why Bun’s simplicity beats “battle-tested” complexity.

Related Posts