Stop building side projects. Nobody cares — and here's the uncomfortable math.

Open your GitHub. Go on. Count the repositories that have a README, a clean commit that says initial commit, maybe a second one that says wip, and then… nothing. No third commit. No user who isn't you. No issue filed by a human you've never met.

I'll wait.

I count nine on mine. Nine little tombstones. A URL shortener. A habit tracker. Two different note-taking apps because I didn't like how the first one turned out. A "Twitter but for X" from a week I should have been sleeping. Each one started on a Saturday with the specific electric feeling that this was the one, and each one died on a Wednesday when the part that was actually hard showed up.

I built the graveyard. Most of us did. And I want to say the thing nobody says at the start of the "build in public, ship every weekend, your portfolio is your résumé" sermon:

Nobody cares about your side project. Not one person. And the math on why is worse than you think.

Stay with me, because this isn't a doomer post. There's exactly one kind of side project that's still worth every hour — and the math is what tells you which one.

The three lies we tell ourselves before the first commit

You don't build a side project for no reason. You build it because you believe one of three things:

1. It'll teach me. ("I'll finally learn Rust / Kubernetes / that framework.")
2. It'll get me hired. ("Recruiters will see this and know I'm serious.")
3. It'll make me money. ("Maybe this one's a business.")

All three are real motivations. All three are, as usually practised, mathematically doomed. Let me take them one at a time, because the doom is instructive — it points straight at the one version that survives.

Lie #2 first, because it's the load-bearing one: nobody is reading your code

Let's do the one everybody believes hardest.

A recruiter has never, in the history of hiring, cloned your repo. They have not read your code. They did not git log your commit hygiene at midnight and think ah, a craftsman. The eye-tracking studies on résumés put the average first pass at somewhere around six or seven seconds — and your GitHub link, if it's clicked at all, gets the profile page, the green squares, and a scroll. That's it.

Here's the part that actually stings, and it's new. The day an AI could scaffold a polished, deployed, nice-looking side project in an afternoon, the signal value of "I built a side project" fell to zero. Not low. Zero. Because the thing the portfolio was supposed to prove — "this person can take an idea to a running app" — is now something a motivated teenager does over lunch with a chat window. You cannot signal scarcity with a thing that just became free.

So the résumé math is: N polished repos × (signal that anyone can now generate for free) = 0. Adding more repos multiplies zero. It's still zero. You cannot out-volume a value that collapsed.

Lie #3: the user math is even more brutal

"But maybe it's a business."

Okay. Count your users. Not signups — the number who came back on day seven and did the thing again. For nine out of ten side projects that number is, precisely, one. You.

10 side projects × 0 real users each = 0. And here's the trap the AI era set: it made the building free and did nothing about the zero. The hard part of a product was never the code. It was getting one stranger to care, come back, and hurt you when it broke. AI compressed the easy 20% — the typing — to nothing, and left the impossible 80% — distribution, retention, trust — exactly as impossible as it always was. So the modern graveyard fills faster than ever, because building the tombstone got cheap and burying it still costs the one thing nobody can generate: another human's attention.

Lie #1 is the only one with a survivor in it

"Fine — but at least I learned something."

Did you? Be honest about what.

If you followed the shape of a tutorial, wired up the same auth-and-CRUD you've wired up before, deployed it, screenshotted it, and moved on — you produced output. A thing that exists. And output, again, is now free. You learned the syntax, the flag order, the incantation. That's recall, and recall is the part AI ate first and you're better off without.

There's a completely different thing hiding inside "I learned something," and it only shows up under one specific condition:

A side project produces output. Only a side project with a real user who can hurt you produces judgment. Output is now free. Judgment is the entire game.

You do not earn judgment by building. You earn it by shipping to someone who can churn, complain, refund, and file a furious bug at 2am — and then living through the consequence. That's the forge. Everything before it is a tutorial with your name on the commit.

The one project that was worth all nine tombstones

I have one repo that isn't in the graveyard. One thing I shipped that a real, paying stranger actually used.

And it taught me something no tutorial could, because it cost me a real person's bad night. I had a write path that acknowledged the request before it had actually persisted the row. In the demo, in the tests, on my machine — flawless. Then one day a retry hit at the wrong moment, the ack went out, the save didn't land, and a paying customer got locked out of their own account with no record that they'd ever done the thing. Ack-before-persist. I can still feel it.

No course gave me that. No amount of scaffolding a tenth side project would have. I earned it the slow, expensive, humiliating way — because there was a real human on the other end of the glass who could be hurt by my mistake, and was. That single scar is worth more than the other nine repos combined, and it's the only line on my GitHub that would have been worth an entire interview.

That's the math nobody puts on the "ship every weekend" poster: nine projects with zero users taught me nine times nothing. One project with one real user taught me the thing I now build my whole career around.

Be clear about what I'm actually saying — because it's not "don't build"

I am not the guy telling you to stop making things. I make things constantly. I let AI generate output all day long — it writes most of my code, and I'd never go back. Building is joyful and you should do it for the joy alone, no defense required.

What I'm saying is narrower and, I think, freeing:

Stop building side projects as a strategy. They were never the scarce thing, and the day AI made them free, "I built ten of these" stopped meaning anything to anyone but you. The strategy that's left is the boring, terrifying one nobody screenshots:

• Build one thing.
• Put it in front of one real stranger who can hurt you — someone who will churn, complain, or ask for their money back.
• Keep it alive. Maintain it through the 2am. Feel the ack-before-persist for yourself.

One shipped-and-maintained thing that a real person depends on will teach you — and, incidentally, show an interviewer — more than a hundred green-squared weekends. Not because it's more impressive. Because it's the only place judgment is actually minted.

Why this is the exact reason I build the way I do

Here's the part that goes one level up, because it's the same math.

I build an agent platform, and the temptation in this whole industry right now is to celebrate the author — the thing that generates. Look how fast it ships! Ten side projects an afternoon! But an author that produces infinite output is producing infinite unblessed diffs. A GitHub graveyard is exactly that: a pile of things generated and never judged, never shipped into contact with a reality that could hurt you. The volume was never the point. The volume is now free.

So I never let the thing that writes the code be the thing that blesses it. There's an author that produces the diff, a separate skeptic whose only job is to try to break it rather than admire it, and a human on the merge button who can see the blast radius the model can't. That separation — author, skeptic, human — is the whole shape of xenition, and it's the same lesson the graveyard teaches: generating a thing is free and always will be; deciding whether it survives contact with a real user is the entire job. Output is cheap. Judgment is the product.

Your GitHub graveyard isn't a sign you're lazy. It's a sign you were optimizing for the free thing. Stop. Build one thing that can hurt you, and stay.

Honest question for the comments: how many tombstones are on your GitHub right now — and which one project, the one you actually shipped to a stranger, taught you something none of the others did? I want to hear about the one that survived. 👇

(If this made you close a few dead tabs with a little less guilt, a ❤️ and a 🔖 help it reach the next person staring at their graveyard on a Saturday.)