When Everyone Can Generate Content, What Still Gets Found

Generating a competent 1,200-word article is now a rounding error in compute cost. That doesn’t make writing worthless — it moves the scarcity. Production is no longer the bottleneck. Verifiability, distribution and situated knowledge are.

Why cheap generation pushed the bottleneck downstream

When the marginal cost of producing something falls toward zero, its price collapses and value migrates to whatever constrains it. For written content, three constraints sit downstream of production: can the reader verify the claim, will the right reader ever see it, and does it apply to their exact situation.

Search and recommendation systems don’t rank “quality” as an abstract virtue. They rank predicted satisfaction: the click that doesn’t bounce, the return visit, the citation from somewhere else. Redundant content produces no new satisfaction for a reader who has already seen the original. That is the mechanism, and it has an uncomfortable implication. The thing being filtered is not “AI-written text” — detection is unreliable and mostly beside the point. The thing being filtered is generic text: the kind that restates the consensus without adding anything the index doesn’t already have.

Answer engines apply the same logic from the other side. A retrieval system needs something to quote — a config key, a version string, an exact error, a decision rule. A page of plausible prose with no distinct artefact gives it nothing to extract and nothing to attribute. This is the same reasoning as /blog/what-is-context-engineering/, applied to publishing instead of prompting: what you hand over is only as useful as the specifics in it.

None of this requires you to become a researcher. It requires the page to contain something that is expensive to fake and takes seconds to check.

Tactics that quietly stopped working

Most content tactics were arbitrage on scarcity — scarce keywords, scarce comparisons, scarce links. When the scarce input became free, the arbitrage closed.

None of these are banned. They simply stopped paying, because the condition that made them profitable — that producing the words was the expensive part — no longer holds. The habits that survive are the ones that were always about something other than word count, the same shift described in /blog/ultimate-ai-automation-guide-2026/ for automation work.

The levers a small publisher still controls

Verifiability. Not “we tested it,” but the config, the diff, the failure output. This is the cheapest moat available to one person, because a large team’s advantage in volume does nothing here — the artefact has to come from a real environment.

Distribution you own. An email list, an RSS feed, a repository people watch, a docs site on your own domain. Intermediaries optimise their economics, not yours. Ownership is the only hedge that doesn’t depend on a platform staying friendly.

Specific expertise. Narrow the scope until you are the only plausible source for the answer. Your constraint set — hardware, jurisdiction, tool version, customer segment — is the differentiator. General knowledge is now a commodity; situated knowledge is not.

The first lever is the one you can act on this week without an audience. Record the environment a tutorial was written against, so a reader can reproduce it instead of guessing:

#!/usr/bin/env bash
# repro.sh - snapshot the environment a tutorial was verified against
set -euo pipefail
OUT="repro-$(date -u +%Y%m%dT%H%M%SZ).txt"
{
  echo "## host"; uname -a
  echo "## python"; python3 --version
  echo "## node"; node --version 2>/dev/null || echo "not installed"
  echo "## packages"; python3 -m pip freeze
  echo "## base image"; grep -m1 '^FROM' Dockerfile 2>/dev/null || echo "no Dockerfile"
  echo "## revision"; git rev-parse HEAD
} | tee "$OUT"

The second habit is subtracting claims you cannot show. A short linter over your own drafts catches the sentences that would be quoted and then disputed:

#!/usr/bin/env python3
"""flag sentences that assert a number without a source marker."""
import re, sys

NUMBER = re.compile(r"\b\d+(?:\.\d+)?\s?(?:%|x|ms|s|k|M|USD)\b", re.I)
SOURCE = re.compile(r"\(source:[^)]+\)|https?://\S+")

for line_no, line in enumerate(sys.stdin, start=1):
    for sentence in re.split(r"(?<=[.!?])\s+", line):
        if NUMBER.search(sentence) and not SOURCE.search(sentence):
            print(f"{line_no}: {sentence.strip()[:120]}")

Run it as python3 lint_claims.py < draft.md. Most flags are legitimate — a version number, a price, a documented limit — and you can mark them. The value is in the few that are not.

Why distribution beats publication frequency

Production cost fell, so the constraint moved to consumption. A reader has a fixed reading budget. Doubling output does not double attention; it splits it across pages that compete with each other for the same visit. That is why publishing more is usually the wrong response to a distribution problem.

Two consequences follow. First, invest in the channel that survives an algorithm change: RSS, email, a repository people clone. Second, make your work easy to retrieve and attribute — stable canonical URLs, structured data, versioned headings, short declarative sections, code that a machine can parse. Answer layers do not replace sources; they route around pages with nothing extractable. If your page has a table, a flag and a named version, it has a reason to be cited and opened.

The uncomfortable part is that none of this can be outsourced to a generator. A model can produce the prose around your artefact, but it cannot produce the artefact. That asymmetry is the whole story.

What to do next

1. Pick your best-performing page and add the missing artefact: the exact version, the config file, the failure output you actually saw. One edit, one page.
2. Run the claim linter above over your last three drafts, then either source each flagged number or delete the sentence.
3. Start or restart one channel you own — RSS plus an email capture on your own domain beats another social account you do not control.
4. Narrow one topic to your situation: your stack, your jurisdiction, your customer segment. Rewrite the page so only someone in your position could have written it.
5. If the bottleneck is that your publishing or intake pipeline is still manual, Ship With AI is a four-hour practical course, $39 USD one-time, that takes a non-coder from zero to a first working AI automation project.

This mirrors a pattern worth internalising from /blog/triage-habits-for-automation-that-fails-while-you-sleep/: the system that keeps working is the one whose failures you can see and check.

Get Ship With AI

Ship With AI — $39, one-time payment, instant download. See the full breakdown on the review page.

Related reading

• The Ultimate Guide to AI Automation 2026
• How I Built a 10-Product Digital Business
• Building an AI Content Factory