我的個人項目八個月收入仍是 $0，一封凌晨 2 時的憤怒電郵改變一切

For eight months, the most-visited tab in my browser was a Stripe dashboard that said $0.00.

I'd open it first thing in the morning, the way other people check the weather. Refresh. $0.00. Refresh again, because maybe it hadn't loaded. $0.00. Then I'd close it, open my editor, and go do the thing I was sure would finally move that number: ship another feature.

I shipped a lot of features. Dark mode. A second onboarding flow because I didn't like the first. CSV export nobody asked for. A settings page with toggles for things that didn't need toggling. I posted on launch-day forums. I rewrote the landing page headline four times. I A/B tested a button color like the button color was the problem.

Eight months. Roughly thirty features. Exactly zero dollars.

And then, in a single week, it stopped being zero — not because of a feature, a growth hack, or a headline. Because of one furious email at 2am. I want to tell you exactly what that email changed, because it rewired how I think about building anything, and it's the opposite of every "just ship more" post you've ever scrolled past.

The thing I was actually doing for eight months

Here's the uncomfortable reframe, and it took me far too long to see it.

For eight months, I was producing output. A feature is output. A settings toggle is output. A fourth headline is output. Every one of those thirty things was a real, deployed, working piece of software that existed because I typed it into being.

And output — the typing, the scaffolding, the "make a thing that exists" — is the part that got free. I was writing most of that code with an AI by then, shipping faster than I ever had in my life. I could produce a polished feature in an afternoon. I was a one-person feature factory running at full tilt.

$0.00 is exactly what a feature factory running at full tilt is worth, if that's all it is.

Because the number on the dashboard was never waiting on another feature. I kept treating $0 as a production problem — not enough shipped, not polished enough, not enough toggles — when it was never a production problem at all. The hard part of a product was never the code, and it definitely isn't the code anymore. The hard part is a single stranger caring enough to depend on the thing, come back to it, and be genuinely hurt when it breaks. I had compressed the easy 20% — the building — to almost nothing, and spent eight months doing more and more of it, while the impossible 80% sat there untouched.

I wasn't building a business. I was building a very productive graveyard, one tombstone a week.

What the 2am email actually was

I had a free trial. A handful of people had started one over those months — I'd watch them poke around for ten minutes and vanish. Output going out, nobody depending on it. Fine. Zero.

Then one trial user did something none of the others had: they used it. For real. Put their actual work in it, came back the next day, and the day after. One stranger, finally leaning their weight on the thing I'd made.

And the thing I'd made had a bug I'd shipped months earlier and never noticed, because noticing it required someone to actually depend on it. I had a write path that acknowledged the request before it had actually persisted the row. In the demo, in my tests, on my machine — flawless. It had been "flawless" for eight months precisely because no real weight had ever been on it.

Then a retry hit at the wrong moment. The ack went out — saved! — and the save didn't land. This user got locked out of their own account, with no record that they'd ever done the thing they'd just spent an evening doing. Ack-before-persist. Their work, gone, and the app cheerfully telling them it was fine.

The email came in at 2am. It was furious, and it was right to be furious.

And I'll tell you the truth about how that felt, because it's the whole point of this post: it was the first time in eight months that anything I'd built had mattered enough to make someone angry. Thirty features, and not one of them had ever cost a real person a bad night. This one bug had. For the first time, there was a human on the other side of the glass who could be hurt by my mistake — and was.

What I did next was the only thing that ever moved the dashboard

I didn't ship a feature. I was awake anyway.

I found the bug — the ack-before-persist — fixed the write path so the acknowledgement could not possibly go out before the row was durably written, backfilled the data I could recover, and replied to the email. Not a templated apology. The actual explanation: here's what broke, here's why, here's exactly what I changed so it can't happen to you again, here's what I could recover and what I couldn't.

That user wrote back. Stayed. Converted when the trial ended. And — this is the part that still gets me — told two other people, both of whom became the first paying customers I ever got who weren't me testing my own Stripe integration.

The dashboard stopped saying $0.00.

Not because of a feature. Because for the first time I had done the one thing I'd avoided for eight months without even realizing I was avoiding it: I let a real stranger get close enough to hurt me, and then I stood in the consequence instead of shipping away from it.

Output vs. judgment — the distinction that was hiding in the whole thing

Here's the line I wish someone had put in front of me on month one:

Shipping a feature produces output. Shipping to a user who can hurt you produces judgment. Output is free now. Judgment is the entire game.

Thirty features risked nothing. Not one of them could churn, refund, rage-email me, or lock themselves out at 2am. They were safe, which is exactly why they were worthless — I was manufacturing output in a room where nothing could ever go wrong, and calling the $0 a mystery.

The bug was the first thing I ever built that could go wrong on a real person. And the fix — the staying, the reply, the standing-in-it — was the first time I made a judgment that cost me something. That single scar taught me more about my own product than the previous eight months of building combined. It also, not coincidentally, was the first thing that made anyone pay.

That's the math nobody prints on the "ship every week" poster: eight months of output that couldn't hurt me earned $0. One night of judgment that did earned the first real dollar.

To be clear — this is not "stop shipping"

I need to be fair here, because the lazy version of this post is "features are bad, slow down," and that's wrong.

I am not telling you to stop building. I ship constantly. I let an AI write most of my code and I would never go back — it's the reason I could produce thirty features in eight months, and I'm glad I can. Building is fast and cheap and good, and you should do it.

What I'm saying is narrower and, I think, more useful: features were never the bottleneck, so producing more of them was never going to move a number that was stuck for a completely different reason. The scarce thing — the only thing that was ever going to turn $0 into not-$0 — was a real person depending on the thing and me surviving the consequence when it broke. AI made the output free and did absolutely nothing about that. It can't. Nobody can generate another human's dependence on you for free.

So ship. Ship fast, with the machine, joyfully. But know which part is the free part, and do not mistake eight months of the free part for eight months of progress.

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

Here's the part that goes one level up, because it's the same lesson wearing a different hat.

I build an agent platform now, and the whole industry's reflex this year is to celebrate the author — the thing that generates. Look how fast it ships! Thirty features in eight months, a whole app in an afternoon! But an author running at full throttle, with nothing checking it, produces exactly what I produced: infinite output, zero judgment, and a dashboard that says $0. My eight months were a one-person preview of what unchecked generation gets you.

So I never let the thing that writes the code be the thing that blesses it. There's an author that produces the diff — fast, tireless, free. There's a separate skeptic whose only job is to ask the question I never asked for eight months: what does this do if the write gets retried? And there's a human on the merge button who owns the 2am, who can see the blast radius the model can't. Author, skeptic, human. That separation is the entire shape of xenition — and it's the same thing the $0 dashboard taught me the hard way: generating the thing is free and always will be; deciding whether it survives contact with a real person is the whole job, and the only part anyone ever pays for.

My side project didn't make $0 because it was missing a feature. It made $0 because for eight months it was all author and no skeptic, all output and no judgment, and nothing in it could hurt me. The day one thing finally could — and I stood in it — the number changed.

Build one thing that can hurt you. Then stay for the 2am. That's where the dollar is.