I wasted years on this one sentence
“If the product is good enough, people will come.”
I believed that line for years. It fits the engineer’s worldview: code is verifiable, performance is measurable, and there’s an objective difference between good and bad. If the difference is objective, then the good thing winning is just a matter of time — the market is efficient, it just needs a while.
That was my logic through my open-source years. Write the project well, keep test coverage high, take the docs seriously, and then wait. Wait for stars, wait for issues, wait for someone to mention it in a blog post somewhere. Sometimes the wait paid off. More often it didn’t. And every time it didn’t, my first reaction was the same one: the thing isn’t good enough yet, go back and keep improving it.
That’s an extremely comfortable attribution. It collapses every problem into the one layer I’m best at — writing code. It lets me keep doing, with a clear conscience, the thing I wanted to do anyway, while dodging the thing I didn’t want to do: going out and telling people what I built.
It took me a long time to see that the attribution structure itself was the problem. It isn’t diligence. It’s a sophisticated way of using what you’re good at to avoid what you’re not.
And what makes it lethal is that the line really did hold some truth in the past — which is why it’s so hard to falsify.
The conditions under which that line used to hold
“If the product is good, people will come” isn’t pure self-deception; there was an era when it worked. The condition it worked under is a hidden premise: good products themselves were scarce.
In the era when building something took three months, a team, and a budget, the number of things that got built — and built well — was limited. That limit itself was doing the filtering. A genuinely useful tool showing up on GitHub didn’t have fifty near-identical alternatives around it; it carried some attention of its own — because scarce things naturally get talked about.
In that era, “making the thing good” was both a product move and a distribution move. They were fused into one act, so you never had to think about distribution separately.
That premise has collapsed.
Once building costs approach zero, good products are no longer scarce. Not slightly-more-numerous; the order of magnitude changed. Whatever need you spotted, dozens of people spotted the same week — and they’re using the same models, the same tools, the same deploy platform you are. You build it well; so do they. You finish in three days; so do they.
Scarcity didn’t disappear. It migrated wholesale — from the product side to the attention side.
That’s the full meaning of the line from the series overview : good products are no longer scarce, being seen is. It’s not a motivational slogan; it’s a description of a supply-demand structure.
Let me put it more harshly: today, a good product with no distribution and a product that doesn’t exist are, at the market level, the same thing. That sounds brutal, but it’s verifiable — if nobody knows it exists, it produces no consequences. It exists only on your own hard drive and in your self-image.
Why distribution is a pure asset
The overview gave a test, and let’s run distribution through it once more:
When this layer of gear improves, does it help only me, or does it help all my competitors at the same time?
The production layer fails this test. One model upgrade, and your coding speed rises together with every rival’s — relative position unchanged. The judgment layer half-passes — part of it can be externalized into rules, part of it can only grow inside your head.
The distribution layer is the cleanest pass of all four.
No model upgrade, ever, will backfill for someone else the readers you spent three years accumulating.
That’s the most essential property of this layer. It’s not “AI can’t do it yet” — it’s structurally outside what AI can cover. Because audience and trust aren’t things that can be computed; they’re functions of time — what slowly crystallizes when the same person is seen, and verified, by the same group of people over a long enough stretch.
And no tool can compress that function.
The most telling experiment (even though you can’t actually run it): take the same article, post it once from a freshly registered account, then post it again from an account that’s been writing for three years. Identical content, not a word changed. The response will differ by one to two orders of magnitude.
What accounts for the gap? Not content quality — the content is the same. The gap is the prior on the receiving end. The three-year account’s readers already know “what this person writes is usually worth finishing,” so they’re willing to spend the first minute of attention. The new account has no such prior; every one of its posts has to prove from zero that it deserves to be read, and in an environment of information overload, most content never gets that first minute at all.
That prior can only be piled up with time and consistency. You can’t buy it (what you buy is exposure, not a prior), can’t generate it with AI, can’t inherit it from someone else. It’s the textbook definition of a pure asset.
AI did two things that necessarily happen together
Now for what I consider the most important mechanism in this essay. Most people only see AI’s first-order effect on content — production got cheap. The real structural change is the second-order one, and the two are necessarily simultaneous.
The marginal cost of content production got pushed to near zero. Writing an article, making a graphic, cutting a video — the time needed went from “days” to “tens of minutes.” Good news, for everyone.
But precisely because it’s good news for everyone, supply explodes. And the total stock of attention — how many hours a day humans have to read things — is a near-constant.
Supply explodes, demand stays flat. The price must rise. And the “price” here is: what it costs to get one person to actually finish reading your thing.
Production cost ↓↓↓ Total attention ≈ constant
(models let everyone produce) (only so many hours in a day)
│ │
▼ │
┌───────────────────┐ │
│ Content supply │ │
│ explodes │ │
└──────┬────────────┘ │
│ │
▼ ▼
┌────────────────────────────────────────────────┐
│ Cost of winning a unit of attention ↑↑↑ │
└──────┬─────────────────────────────────────────┘
│
├──► Cold starts get harder: new content struggles for the first minute
│
├──► Existing assets appreciate: accumulated trust becomes the scarce good
│
└──► Conclusion: the same day production got cheap, distribution got expensive
The most counterintuitive line in this diagram is the one on the lower right: production getting cheap directly causes existing distribution assets to appreciate.
Because when everyone can produce content, the question “who produced this” gains weight. Readers can’t read everything; they have to filter, and the lowest-effort filter is provenance — I know this person, I’ve read their stuff before, so I’ll read them first.
So the spread of AI didn’t weaken distribution assets — it reinforced them. That runs against a lot of intuition. Many people assumed AI would democratize content, make good work surface more easily. What’s actually happening is more likely the opposite: it makes people who already have an audience easier to see, and people without one harder to see.
I don’t think that’s a good thing. But I think it’s the thing that’s happening, and within the thing that’s happening, which side you stand on is what you can control.
fly.pieter.com looks like a production-layer victory on the surface
This case has been cited countless times, and almost every citation gets it wrong.
In February 2025, Pieter Levels built a browser-based flight simulator prototype in roughly three hours, and went from zero to a million dollars in annualized revenue ($87,000 MRR) in 17 days, with 320,000 people having played it. The revenue came mostly from in-game ad placements, not subscriptions.
As the story spread, it got compressed into one sentence: AI let one person build a million-dollar product in three hours.
That sentence is wrong — or rather, it’s only right about the three hours.
The three hours are the production layer. The stretch from three hours to a million dollars is, in its entirety, the distribution layer cashing out.
If the same prototype had come from someone with no audience, what would have happened? It would have appeared in some GitHub repo or on some free hosting platform, maybe a few dozen people would have played it, and then it would have sunk. That’s not a hypothetical — that’s the default outcome playing out every single day. The reason this product ran that curve in 17 days is that it was born already in front of an existing, massive crowd of people who had been watching what this person builds for years.
Put differently: those 17 days didn’t spend 17 days of effort. They spent over a decade of accumulated distribution assets, cashed out in one shot.
Levels’ own numbers make the point even sharper. He’s built 70-plus projects, of which only about 4 ever made real money — a hit rate around 5%. At first glance that number reads as a story about failure rates, but its real meaning is something else: those 66 failed projects weren’t wasted, because every one of them was built in public.
Every public attempt, even the ones that didn’t work out, was depositing into the same account — depositing not money, but the impression, in many people’s heads, that “this person is always building things.” By the time project number 70 showed up, its cold-start cost had already been driven down by the previous 69.
That is the real economics of building in public. It’s not something only extroverts can do, and it’s not self-promotion. It’s the only mechanism that converts failures — which are inevitable — into assets that don’t go to zero.
The failed project goes to zero. The record of the failure doesn’t.
Most people don’t lose on the product
Another dataset confirms this from the opposite direction. ScrapingFish scraped 937 products on Indie Hackers with Stripe-verified revenue, and found: over 54% of them had zero revenue, and only about 5% made more than roughly $8,333 a month.
And this dataset carries severe survivorship bias to begin with — it only includes products that got finished, got listed, and got hooked up to Stripe. The ones abandoned halfway, the ones never shipped at all, aren’t even in the denominator. The real distribution can only be more extreme.
This number usually gets used to talk people out of trying, and I think that’s the least interesting reading. The question I care about is a different one: of that 54%, how many failed because the product was bad, and how many because nobody knew it existed?
Nobody can give a precise split. But based on what I’ve seen and what I’ve built, my judgment is that the second group vastly outnumbers the first. Building a usable small tool that solves a real problem is no longer the hard part today. Getting a hundred people who genuinely need it to know it exists — that’s the hard part.
“AI slop” is the new distribution tax
Once supply explodes, readers’ filtering strategies change. Something rather interesting happened here.
When everyone can one-click-generate an article that’s well-structured, logically clean, and perfectly inoffensive, that kind of text loses all signal value. It no longer proves the author is capable, because it no longer requires capability. It only proves the author has a subscription.
So readers started filtering with a new, extremely low-effort heuristic: does this passage read like it was written by a specific person?
That judgment takes two or three lines, costs almost nothing, and is surprisingly accurate. I read this way now myself — scan the opening, and if every sentence is correctly saying nothing, I close the tab. Not because it’s wrong, but because it contains nothing I couldn’t read anywhere else.
So in 2026, “AI slop” isn’t an aesthetic problem — it’s a distribution problem. It’s a tax: content carrying that flavor has to pay more to win the same attention.
And most people fight AI slop the wrong way. They swap words — “empower” becomes “help,” “deep dive” becomes “let’s talk about,” they tell the model “no parallel constructions.” All surface. After the edits it’s still an article with no author, just wearing a different skin.
There’s only one real solution: write the part that only you have.
Concretely:
- First-hand failure details. Not “this approach has some gotchas,” but “I was stuck here for two days because I assumed X was Y, and it wasn’t.” A model can generate the former; it cannot generate the latter, because it wasn’t there for those two days.
- Concrete numbers, especially the ugly ones. How many people actually use your project, how much money you spent, how much time, what you gave up. Numbers are the hardest specificity to fake.
- The hesitation you felt at the time. What you agonized over between two options, why you picked the one you did, whether in hindsight you picked wrong. AI-generated text is natively in the voice of “already figured out,” because it’s emitted in one pass. Human thinking leaves traces, and the traces themselves are the ID card.
- The detours. Especially the ones that look stupid to you now. Writing them down is a little embarrassing, and that bit of embarrassment is exactly where credibility comes from — nobody fabricates a detail that makes them look dumb.
I’ve found a reliable self-check: delete every sentence in the piece that starts with “I” and carries a specific time, place, or number. If what remains still stands on its own, the piece didn’t need you to write it.
None of this means don’t use AI for writing. I use it heavily. The difference is the division of labor: let the model handle structure, grammar, pacing, translation, expansion — but the specificity only you have must be placed in by your own hand. The model is the editor, not the author. It can make your material read better; it cannot live your experience for you.
Turn the act of building the product into content
This is the one structural distribution advantage a super individual has that a team cannot learn, and I think it’s badly underrated.
In a team, “the person who builds” and “the person who writes” are separate people. Engineers build, marketing writes. There’s inevitable information loss and time delay in between: the engineer finishes, marketing comes asking what happened, the engineer explains, marketing understands part of it, the write-up goes back to the engineer for review, the engineer says that’s not what I meant, several rounds later two weeks are gone. What finally ships is usually abstract, correct, and boring — because all the concrete, flavorful, slightly awkward details got sanded off in transit.
An individual doesn’t have this problem. The builder and the writer are the same person. Every detail is in your head, fresh, unpolished by any round of relay.
This structural advantage doesn’t cash itself in automatically. You have to deliberately design a pipeline for it, or the details simply decay in your head.
The overview said the four layers have a direction: the output of layer four should settle downward into assets for layers two and one. At the distribution layer, that pipeline looks like this:
Layer 4 · one delivery from the production layer
(a feature / a refactor / a pitfall / an abandonment)
│
├──► Leave traces on the spot (the only step requiring discipline)
│ · Decisions: why A and not B
│ · Blockers: where, for how long, how you got out
│ · Numbers: time spent, cost, before/after performance
│ · Detours: the ones that look stupid in hindsight
│
▼
┌────────────────────────┐
│ A rough pile of raw │ ← readable only to you; don't aim for prose
│ material │
└─────────┬──────────────┘
│
├──► One deep long-form piece (the source; your home turf; retrievable long-term)
│ │
│ ├──► Short form: conclusion + one diagram (social platforms)
│ ├──► Long form: add background + data (technical communities)
│ └──► Dialogue form: break it into concrete questions (Q&A venues)
│
└──► Layer 1 · reputation layer: the consistent public output itself
│
└──► Feedback: the next product's cold start costs less
The key is the first step: leave traces on the spot.
It’s the only step in the whole pipeline that requires discipline, and it’s the one most easily skipped. Because in the moment of building, these details feel too trivial to record — and you’re certain you’ll remember them.
You won’t. Three weeks later all you’ll remember is “it got solved eventually.” The specificity that made the content valuable — what exactly you assumed at the time, what you tried, why the attempt was wrong — is all gone. What’s left is an abstract, correct, boring version. The version a team would produce. Your structural advantage is lost right at this step.
My method is crude: one plain-text file, and while working I toss sentences into it as they come — no fluency, no completeness, only the specificity of the moment. The file is legible only to me. When it’s time to write, it’s the raw material — and raw material nobody else could possibly have.
Once you have the raw material, AI can dramatically accelerate every downstream step. Without it, AI only accelerates the output of filler.
Repurposing saves friction, not expression
Turning one source piece into different shapes for different platforms genuinely got much easier after AI. That’s a real efficiency gain, worth taking.
But I want to draw an honest boundary here, because this thing has been oversold.
Cross-platform repurposing lowers friction. It does not replace platform-native expression.
Every platform has its own grammar — not just length limits, but rhythm, how you open, the reader’s state of mind on arrival, what sounds natural here and affected elsewhere. A passage that unfolds beautifully in a long essay, chopped into short lines on a fast-scroll platform, reads as verbose; a judgment that lands sharp on a short-form platform, dropped into a long essay, reads as glib and unargued.
The part that genuinely automates is repackaging information: extracting conclusions, changing length, adjusting format, translating. Hand those to the model, no problem.
The part that doesn’t automate is how this should be said in this context. That takes real felt experience of the platform — you have to have spent time there yourself, read how people talk, know what gets ignored.
So my verdict: repurposing is a labor-saving tool, not a distribution strategy. It lets you spend less time on channels you’ve already chosen; it won’t choose channels for you, and it won’t build presence for you in a place you don’t know at all.
For an individual, the more realistic setup is: one home turf only — the place you fully control, where content persists long-term and stays retrievable (for me, this blog); every other channel is a tributary, each speaking its own language, all pointing back home.
The endpoint of distribution now includes a context window
This is the half of “distribution” that newly grew in 2026, and I don’t think its importance has been fully priced in yet.
In the past, the endpoint of distribution was human eyes. Someone sees what you wrote, and the chain is complete.
Now there’s a second chain: what you wrote gets read by a model, understood, and then cited when it answers someone else’s question.
This chain’s existence no longer needs arguing. The MCP ecosystem’s official figure in December 2025 was 10,000+ published servers; on December 9 of the same year, MCP and AGENTS.md were donated together to the Agentic AI Foundation under the Linux Foundation, with adopters including Claude, Cursor, Microsoft Copilot, Gemini, VS Code, and ChatGPT. The numbers themselves aren’t the point; the point is what they jointly establish: models have become a universal information intermediary layer. More and more people don’t search-then-read; they ask, and read a synthesized answer.
That brings a structural change I want to pull out on its own:
“Being cited” is a brand-new form of distribution — it produces no clicks, but it produces trust.
Traditional distribution is metered in traffic: how many clicked in, how long they stayed, how many converted. Being cited by a model gives you none of that. The user may never open your link; your access logs won’t show a thing.
But in the answer that user received, your name appeared — appeared as the basis for some judgment. What that leaves in their mind is entirely different from an ordinary page visit — because it comes endorsed by a third party. They didn’t find you; a tool they trust cited you.
It’s distribution without a click, and its trust-conversion rate may well be higher than a click’s.
I won’t unpack the how-to here — I have an entire GEO column on the mechanics. Here, just three judgments that bear directly on the distribution layer:
First, structured content is easier to cite. The unit of model retrieval is the paragraph, not the article. So every section should stand on its own out of context — if a passage only makes sense after reading the three before it, it’s broken the moment it gets excerpted.
Second, content with explicit conclusions is easier to cite. The kind of piece that’s wall-to-wall “it depends” and “each has trade-offs” gives the model nothing quotable to extract. Daring to write declarative judgments has become a distribution advantage in the age of AI retrieval. I find that ironic and rather delightful — it takes “speak plainly, land a conclusion,” something that used to be a matter of writing taste, and gives it a measurable payoff.
Third, first-hand beats second-hand. Survey-style content that reorganizes other people’s views is exactly what models generate best on their own; they don’t need to cite you for it. What they need to cite is what they can’t generate: specific data, specific experience, specific judgment.
Notice something — these three points and the conclusions of the “fighting AI slop” section above point in exactly the same direction. What makes humans want to read and what makes models want to cite are, in 2026, largely the same thing. That’s one of the rare pieces of good news in this era: you don’t need to write two versions for two audiences.
Now for the part that doesn’t sound nice
I don’t want this essay to read like motivation, so the hardest part of the distribution layer has to be stated plainly.
The compounding of distribution is real, but its ramp-up is brutally long, and during the ramp-up there is almost no feedback.
That’s its most counterintuitive property. We’re used to stories of exponential growth, but most people have never actually lived through the front half of an exponential curve — it looks exactly like a flat line. Not slowly rising. Indistinguishable from flat.
Compare the production layer: set up an AI coding workflow today, feel faster tomorrow. Feedback cycles are measured in hours, causality is crisp, and that immediacy keeps you investing.
The distribution layer is the exact opposite. You write your first post; maybe three people read it. By the tenth, maybe a dozen. Months have passed, serious time has gone in, and the signal you’re getting is almost identical to the signal you’d get from not doing it at all.
And causality is severed. Even if things pick up six months later, you can’t say which piece did it, can’t tell whether the content improved or luck arrived. You never get that “I did A, therefore B” certainty — and engineers are precisely the type most dependent on that certainty.
Perceived payoff
▲
│ ╱ Distribution layer
│ ╱ (steep after the inflection,
│ Production layer ╱ nearly flat before it)
│ ┌────────────────── ╱
│ ╱ (instant effect, ╲ ╱
│ ╱ then a quick cap) ╲ ╱
│ ╱ ╳
│╱_____________________╱ ╲___________
└────────────────────────────────────────► Time
↑ ↑
Two weeks Most people quit here
(long since invested, signal still ≈ zero)
So most people don’t quit because they “didn’t know distribution matters.” They knew. They started. And they quit on the flat stretch before the inflection. Their conclusion at the moment of quitting is usually “this isn’t for me” or “this path doesn’t work” — when the reality is that the curve, at the moment it was abandoned, hadn’t yet reached the place where it begins.
I have no way to make this sound nicer. This is how the asset is priced: it’s valuable precisely because what it demands — long, feedback-free persistence — is what most people can’t pay. If it paid off in two weeks, it wouldn’t be an asset; it would be a commodity, same as the production layer.
Its painfulness and the width of its moat are two faces of the same thing.
If I have to give one piece of operational advice, it’s this: during the ramp-up, don’t evaluate this work by external feedback. Evaluate it by “did I leave something behind.” Did I turn three pitfalls into three retrievable records this month? That’s something you control, with deterministic feedback, highly correlated with the final outcome. External feedback is lagging; use it for short-term evaluation and you will quit before the inflection, guaranteed.
Being seen, and being trusted
Writing to this point, I realize the distribution layer needs one more boundary drawn, or it gets pushed too far.
Distribution solves “being seen.” It does not solve “being trusted.”
The two get conflated constantly, but their mechanisms are entirely different. Being seen is an exposure problem — it can be optimized, accelerated, and to some degree purchased. Being trusted cannot — it’s about consistency, about whether the things you said over a long time actually came true, about whether people have verified what you claimed.
Someone with distribution but no reputation is a very common creature today. Their content travels well, their headlines land, but nobody actually changes their own judgment because “he said so.” There’s a gap between their reach and their influence.
And that gap will widen in the AI era. Because when content production trends to zero and everyone learns to phrase things beautifully, the signal value of “says it well” keeps falling, and the signal value of “does what they said” rises.
So the relationship between these two layers is clear: distribution is necessary but not sufficient for reputation. Without distribution, no matter how trustworthy you are, nobody knows. With distribution but no reputation, many people see you, but nobody entrusts you with anything that matters.
Distribution decides how many people hear you speak. Reputation decides whether they believe you once they’ve listened.
Back to the opening line.
“If the product is good enough, people will come” — my view now is that the most harmful thing about this sentence isn’t that it’s wrong. It’s that it disguises an action you must actively take as a process that happens on its own.
It makes you feel like you’re awaiting the market’s verdict, when you’re really just avoiding something that makes you uncomfortable. It took me years to see through it, and the things I built in those years were no worse than what I build now — nobody knew about them, that’s all.
Work that never got recorded is, at the market level, equivalent to work that never happened. That’s the most expensive lesson this layer taught me.
The next essay is the last in this series, on Layer 1 · the reputation layer : why trust is the last thing AI can’t flatten, why assets like open-source contributions — the kind that never appear on any gear list — are systematically undervalued, and most importantly, how to wire the four layers into one system that feeds itself, instead of four separate chores.
If the core of this essay is “what you build must be seen,” the core of the next is “once seen, why should anyone believe you.”
The previous essay covered the judgment layer — when execution trends to zero, all the cost lands on judgment. If you entered through this piece, the two together make the complete picture.
Responses