Paul Graham Says Earning a Billion Is Just Math. So Why Aren't Devs Winning?

Paul Graham just stood at the Oxford Union and explained how to earn a billion dollars. The recipe fits on a napkin. Build a thing people love. Grow at a percentage per month for long enough. Don’t cheat — you don’t need to. The math does the work.

I read it on a Monday and felt the quiet, slightly uncomfortable thing the best PG essays make you feel: if it’s really this simple, why aren’t more of us already doing it?

Here’s a partial answer from inside the trenches, where I’ve been bootstrapping a small zoo of products and bumping into the same walls.

The input cost died

PG’s recipe has one input cost he doesn’t dwell on: building the thing.

In 2010, that was the dragon. Hiring, infrastructure, deployment, the unglamorous apparatus that turns code into something a customer can pay for. Half of why YC was so valuable was helping founders get past it.

In 2026 that dragon is mostly dead. An LLM coding agent will absorb the unglamorous 90% of building for you, and “deploy a thing and see if it grows” now costs roughly nothing. I just migrated a dozen-plus side projects from Azure to one VPS in a weekend, not a quarter. The infra got smaller, faster, and cheaper at the same time.

So the input is cheap. The math is timeless. The output should follow.

Except, for most of us, it doesn’t. Why?

What AI actually changed

The honest thing AI changed isn’t speed. It’s the strategy.

PG’s essay implicitly assumes one bet you ride for a decade. That’s still the cleanest path. But when shipping is this cheap, the portfolio approach is finally rational for a solo dev. You can run three or four small bets in parallel and let the market tell you which one wants to compound. The shots-on-goal are functionally free.

Which means the bottleneck has stopped being finding the time to take the shot. It’s three other things AI can’t yet flex for you. They are the entire game now, and almost none of PG’s essay is about them.

Distribution you actually own

I built Career.Coffee, a small careers-focused site, and for most of a year it did exactly what PG describes. It caught Google’s index just right, ranked for a stack of long-tail queries, and the traffic line compounded month over month. Textbook curve. I felt smug.

Then a search algorithm update came through and the traffic line went vertically down to roughly zero. Overnight.

No warning. No appeal. No “growth rate” to even put in the equation anymore, because the channel itself had been switched off. PG’s framework assumes growth-rate × market-duration. Mine just discovered that the second variable can be set to zero by a button I don’t own.

That’s the line PG left off the napkin. The math is real, but only on a channel that can’t be revoked. Sneos taught me a milder version of the same lesson — you can build a genuinely useful multi-LLM comparison tool and still struggle, because the people who’d benefit most don’t know to look for it, and the channels that could tell them aren’t yours either.

So now what? It’s the question I’ve been chewing on. The honest answer is unsexy: build channels nobody else can flip. Email lists. Direct relationships. Products with their own internal gravity. The slow stuff, on purpose, because the fast stuff isn’t yours.

Taste

Codorex makes shipping a small web app about as cheap as describing one. Which sounds great until you notice the new asymmetry: if anyone can ship, the bottleneck is no longer building, it’s choosing. What’s actually worth shipping?

PG’s “build what you need” hits differently in 2026. Every dev need is already over-served by ten SaaS tools. Yours is too. Applied honestly, the rule now points out of the bubble, not deeper into it. The taste worth cultivating is the kind that hunts non-developer pain — friends who run small businesses, parents, your dentist — because that’s where the under-served markets actually live.

Shipping the wrong thing costs nothing now. It also costs everything in lost months. Quietly brutal.

Patience

NestClaw’s micro-plans — $3.99 for two hours, pre-provisioned pool, your own AI agent within seconds — are partly me trying to fight my own impatience. Lower the friction, let people try, give the compounding curve enough activations to actually start compounding.

Because PG’s math only feels exponential at the end. The middle looks like a flat line. Most devs (me on bad weeks) quit the flat line because we assume the curve broke.

Sometimes it really did — Career.Coffee broke. Sometimes it didn’t and you just got tired. The whole discipline is telling those two apart, and most of the time the answer is “keep going” even when it feels stupid to.

What’s actually left

PG handed us the math. AI handed us the input. The work that remains — the part where the billion gets made or doesn’t — is in the muscles AI can’t yet flex for you:

• Owning a channel nobody else can switch off.
• Choosing the right thing to ship in a world where shipping is free.
• Staying on a flat line long enough for it to bend.

Career.Coffee taught me the cost of skipping the first one. I’m not skipping it again.

If you’re a dev sitting on the same math: the path is open, the input is cheap, and the trade isn’t more code. It’s the boring, unglamorous, deeply un-technical work of building something the algorithm can’t take away from you.

Building in public while bootstrapping. If you’ve had your own Career.Coffee moment — a curve that broke through no fault of yours — I’d love to hear how you’re rebuilding from it.