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 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.
You don't build a side project for no reason. You build it because you believe one of three things: It'll teach me. ("I'll finally learn Rust / Kubernetes / that framework.") It'll get me hired. ("Recruiters will see this and know I'm serious.") 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.
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.
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.
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.
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.