Eternal September, Now With LLMs: Why Geohot's Sloptember Framing Lands

George Hotz published a short piece called The Eternal Sloptember, and the Hacker News thread hit 460 points fast. The title is doing a lot of work. It collapses two ideas that have been circling each other for a while: Eternal September, the 1993 moment when AOL opened Usenet to its subscribers and the influx of newcomers never tapered off, and the more recent coinage of AI slop, the low-effort generated content now saturating search results, social feeds, and developer Q&A sites.

The analogy is tighter than the wordplay suggests. I want to walk through why, and then talk about what it actually changes for people who write code for a living.

What Eternal September was really about

The original Eternal September wasn’t really about volume. Usenet had survived volume before. What broke was the assumption baked into the protocol’s social layer: that new arrivals would trickle in slowly enough to be acculturated by the existing community. Each September brought a wave of university freshmen, and the regulars absorbed them over a few weeks. When AOL turned the trickle into a firehose in September 1993, the absorption mechanism failed. The norms didn’t propagate. The newsgroups didn’t get worse because the new users were bad; they got worse because the ratio of unacculturated to acculturated participants flipped, and the feedback loops that produced the culture stopped working.

This is the part of the story that matters for the LLM era. The web’s content ecosystem also assumed a particular ratio: roughly, that humans producing text were a bottleneck, that publishing implied some baseline of intent, and that the cost of generating a plausible paragraph was high enough to filter out the most cynical actors. SEO farms have been chipping at that assumption for twenty years. Generative models removed the bottleneck entirely.

Why “slop” is the right word

The term slop got picked up because it captures something specific. Spam is content with malicious intent and clear signatures. Slop is content with no intent at all, optimized for a metric that’s only loosely correlated with usefulness. Simon Willison wrote a useful definition back in 2024: slop is AI-generated content that’s published without the publisher checking whether it’s accurate or useful. The author has effectively delegated the question of whether the work should exist to the model.

This matters because slop defeats older filtering heuristics. A traditional spam page is recognizable from its keyword stuffing and template patterns. A well-prompted GPT-class model produces text that passes the surface-level coherence check that humans (and ranking algorithms) use as a first-pass filter. The 2024 study by Originality.AI estimated that over half of long-form English content published in some months was likely AI-generated. Newsguard has been tracking unreliable AI-generated news sites with similar findings.

The developer angle: docs, Stack Overflow, and Show HN

For developers, the most visible degradation has been in the long tail of programming help. Stack Overflow’s traffic dropped sharply starting in late 2022, which most observers attribute to ChatGPT eating the low-difficulty question category. The site banned ChatGPT-generated answers in December 2022, but the damage was structural. The questions that drove ad revenue and trained new contributors are the same ones an LLM answers passably without any human in the loop.

What replaced them, in search results at least, is a layer of slop sites that mirror Stack Overflow content, run it through a paraphraser, and republish it with affiliate links. If you’ve searched for an obscure error message in the last year and ended up on a page that almost-but-not-quite answers your question, in slightly stilted English, with three paragraphs of preamble before the code block, you’ve met it.

The Show HN front page has its own version of this. There’s a recognizable shape to AI-assisted launches: the same landing-page structure, the same gradient hero, the same three-feature grid, the same vague benchmark claims. Geohot’s post gestures at this homogenization. It’s not that the projects are bad, necessarily; it’s that the distribution has narrowed. The tail of weird, idiosyncratic submissions that made Show HN interesting is being squeezed by a median that converges on whatever pattern the assisting model has internalized.

Where the analogy breaks

Eternal September was a one-way ratchet, but it had a ceiling. AOL had a fixed number of subscribers, and Usenet’s degradation eventually stabilized at a new equilibrium before the protocol was abandoned in favor of web forums. The LLM case has no obvious ceiling. The cost of producing slop trends toward zero, and the supply of compute trends upward. Whatever equilibrium emerges will be set by detection and ranking systems, not by the supply of generators.

This is the part of Geohot’s framing I’d push back on. He treats the slop wave as a kind of background radiation that we adapt to, the way Usenet regulars adapted to AOL. I don’t think that’s quite right. The Usenet community had a defensible boundary it lost. The web never had that boundary in the same way; what it had was an economy where attention was scarce and producers had to compete for it. LLMs change the supply side of that economy, not the social layer.

The more useful comparison might be to the pre-Google search era, when AltaVista and Lycos were drowning in keyword-stuffed pages and PageRank rescued the medium by introducing a new signal. We’re plausibly waiting for the equivalent move. Provenance signals like C2PA, trust graphs, and pay-to-post barriers are all being floated. None of them are obviously winning yet.

What to do about it as a developer

A few things I’ve actually changed in the last year:

• Bias toward primary sources. Official docs, RFCs, and the original GitHub issue thread beat the third-party tutorial nine times out of ten now, where it used to be more like six. The variance on third-party content has gotten worse.
• Trust specific people over generic results. Julia Evans, Dan Luu, Simon Willison, Fabien Sanglard. Curated link blogs and personal feeds are recovering some of the function that ranked search used to provide.
• Read the code. For libraries, the source on GitHub is often faster than the rendered documentation, and it’s the one thing that hasn’t been paraphrased into ambiguity. The grep-then-read workflow has gotten more valuable.
• Be skeptical of consensus on new topics. If a technology was released in the last six months, the top search results are now disproportionately likely to be hallucinated. The model has training data from before the thing existed, and it confabulates plausibly.

None of this is novel advice. What’s changed is that the cost of not doing it has gone up. The default path through the web is more contaminated than it was three years ago, and the contamination isn’t going to clear on its own.

Geohot’s piece is short and a little glib, but the framing is durable. Eternal September named a moment when the old equilibrium ended and the new one hadn’t arrived. We’re in the equivalent gap now, and it’s worth giving the gap a name.