The dead internet theory is half right

Last year I built a tool that has now shipped 50,000 AI-written articles for paying customers. So when developers post the dead internet theory on Twitter, I am one of the people being accused of killing the web.

After a year of watching how real users actually use the thing (logs, edit patterns, traffic, conversions), I have to admit it: half of the dead internet panic is correct. The other half is a vibes-based moral panic that does not survive contact with data.

This post is the engineering view. The patterns that produce slop versus the patterns that produce content people actually finish reading. With code.

TLDR

• AI content farms got worse. That part of the dead internet theory is real.
• But "AI content" and "AI-assisted content" produce different traffic, conversion, and decay curves. The panic blurs them.
• The technical pattern that separates the two is not which model you use. It is whether you generate as one monolithic prompt or as a chained pipeline with per-section briefs, voice constraints, and fact pinning.
• I will show the difference with actual prompt code below.

Where the dead internet theory is right

Before GPT-3.5, a content farm needed five cheap writers on Upwork. Now it needs one prompt and a CMS.

The volume of low-effort AI text on the open web has roughly 10x'd since November 2022. Google search results page 1 for low-intent queries ("best CRM 2025", "how to drink water", "is X a good idea") is now mostly garbage. Comment sections on big-traffic sites trend 30 to 50 percent bots talking to bots. LinkedIn is a hallucinated thought-leader loop. Reddit is laundering generated content as personal stories.

I do not pretend my tool has nothing to do with this. In the hands of someone who clicks generate, picks the cheapest title, and publishes without reading, my product is part of the problem.

That is not the full picture though.

Where the dead internet theory is wrong

The panic treats every AI-written word as identical garbage. From my logs across 50,000 published articles, that is not what happens.

• 70 percent of articles get manual edits before publish. People rewrite intros, fix specific claims, swap headlines, add personal context.
• The top 20 percent of accounts (by retention and traffic) edit harder than they generate. They use the tool for a 60 percent draft and then spend 45 to 90 minutes on the post.
• The 10 percent who publish raw also see the worst traffic. Google demoted that layer in the September 2024 helpful content update and never undid it.

The internet that pays (places where someone buys something, signs up, or hires you) does not run on raw AI slop. It runs on AI as a draft layer plus a human who knows what they are saying.

The actual technical difference

Here is the part nobody outside the AI writing tools space talks about. There is a difference between AI content and AI-assisted content, and it is not vibes. It is a prompt architecture difference.

The slop pattern: monolithic prompt

This is what the dead internet theory is mostly worried about. It looks like this:

async function generateSlop(topic: string, wordCount = 2000): Promise<string> {
  const prompt = `Write a ${wordCount} word article about ${topic}.
Include an introduction, 5 sections, and a conclusion.
Use SEO best practices. Make it engaging.`;

  const response = await client.messages.create({
    model: "claude-3-5-sonnet",
    max_tokens: 4096,
    messages: [{ role: "user", content: prompt }],
  });
  return response.content[0].text;
}

This produces output that is technically grammatical English and technically about the topic. It also produces output that:

• Drifts off topic between section 3 and section 5 because the model loses attention on long generations.
• Repeats the same generic claims across all sections (it has no shared brief to constrain it).
• Includes hallucinated statistics ("studies show 73 percent of users prefer X").
• Reads identically across topics because the prompt has no voice constraints.
• Cannot be updated without regenerating the entire article.

This is the slop the dead internet panic is rightly angry about. It floods low-intent SERPs. It does not convert. It does not retain readers. It does not build a brand.

The useful pattern: per-section briefs

Same model, same goal, but a chained pipeline with shared state. This is what actually works.

type ArticleBrief = {
  topic: string;
  targetKeyword: string;
  audience: string;
  voiceExamples: string[];
  factualAnchors: string[];
  forbiddenTerms: string[];
};

type SectionBrief = {
  heading: string;
  purpose: string;
  keyPoints: string[];
  targetWords: number;
};

async function generateOutline(brief: ArticleBrief): Promise<SectionBrief[]> {
  const outlinePrompt = buildOutlinePrompt(brief);
  const raw = await callModel(outlinePrompt, { maxTokens: 2000 });
  return parseSections(raw);
}

async function generateSection(
  brief: ArticleBrief,
  section: SectionBrief,
): Promise<string> {
  const prompt = `Write the section "${section.heading}" only.
Target length: ${section.targetWords} words.

Purpose: ${section.purpose}
Key points to cover: ${section.keyPoints.join(", ")}

Voice constraints. Match the rhythm and vocabulary of these samples:
${formatVoiceExamples(brief.voiceExamples)}

Factual anchors. You must cite these or stay silent on the topic:
${formatAnchors(brief.factualAnchors)}

Forbidden terms (rewrite if any appear): ${brief.forbiddenTerms.join(", ")}
`;
  return callModel(prompt, { maxTokens: section.targetWords * 4 });
}

async function generateArticle(brief: ArticleBrief): Promise<string> {
  const sections = await generateOutline(brief);
  const bodies = await Promise.all(
    sections.map((s) => generateSection(brief, s)),
  );
  return stitch(bodies);
}

What this changes:

• Each section gets focused attention because it is a separate model call with a tight word budget.
• The article brief is shared state, so every section knows the voice, the anchors, the banned words.
• The outline step forces a top-down structure before any prose exists.
• You can regenerate one section without trashing the rest.
• Hallucinations drop sharply because the model is constrained to factual anchors.

I built this because I had to. The first version of my pipeline used a monolithic prompt. Customer retention was bad. Traffic was bad. Edit rate was high enough that users complained the tool was not useful. The second version (per-section briefs with shared state) is what 50,000 articles have shipped through.

Why this matters for the dead internet theory

The monolithic pattern produces dead-internet content. The chained pattern produces something closer to a junior writer's first draft. Both use the same underlying model. The technical architecture is what separates them.

When people post the dead internet theory, they are usually reacting to monolithic-prompt output. That is the genre of content that floods low-quality SERPs. They are not usually reacting to chained-pipeline output, because chained-pipeline output gets edited by a human before publish and looks like normal modern writing.

Reality Check (when the dead internet panic IS right)

I am not arguing AI writing is fine. There are categories where it absolutely is the problem.

1. Pure SEO content farms. No human in the loop, no editing, hundreds of articles per week. This is dead internet content even with a chained pipeline. Volume kills value.
2. Astroturf comments. Generated forum posts pretending to be a real user with a story. This is unambiguously bad and the panic is correct.
3. Hallucinated expert content. AI-written medical, legal, financial advice with no human review. The technical pipeline does not save you here. You need a domain expert.
4. AI-on-AI loops. SEO content scraping other SEO content, scoring AI against AI. Eventually the entire signal degrades because nothing in the loop is grounded in reality.

If you are doing any of these, the dead internet theory is your fault and you should stop. My own product has terms against the first two.

The complaint that gets it wrong is the version that says "any AI-written word is killing the web". A human using a per-section pipeline to skip the empty first draft is not the same person running a content farm. The data is not the same. The output is not the same.

What I actually tell customers

Three rules. I repeat them on every onboarding call.

1. The AI does the first draft. You do the last 30 percent. Always.
2. Specific numbers, named people, and personal context are the parts AI cannot fake. Put them in the post yourself.
3. If your edit rate is below 30 percent, you are about to get demoted by the next Google update. Bring it up.

This is also why I do not market my product as "10x content output" or "AI articles on autopilot". Both of those framings produce the bad version of customer behavior. I market it as a draft layer.

So is the internet dead

The cheap layer of it got cheaper, faster, and more annoying. That layer was already empty calories before AI. Now there is more of it.

The parts that pay (specific expertise, real numbers, named people, brand voice, technical depth) are harder to fake. That layer still rewards humans who write things only they can write.

The dead internet theory describes the empty-calories layer of the internet. It does not describe the entire internet, even though the panic says it does. Both of these can be true at the same time:

• AI writing tools have polluted low-intent SERPs.
• AI writing tools, used with a real pipeline and a real human, are a draft layer that helps writers ship more of the work they are already capable of.

If you are building anything in this space, the architecture you ship determines which side of that line your product lands on.

If you are publishing content, your edit rate determines the same thing.

What is your edit rate when you use AI for a draft? Be honest. And if you have shipped a chained-pipeline architecture that works better than per-section briefs, I want to hear about it.