Editors have been asking the wrong question.
For three years now, the question has been “was this written by AI.” Commercial detectors stamp a percentage on the page. Newsrooms write policies around that percentage. Writers learn which phrases set off which detector and adjust accordingly. The arms race has produced exactly the result you would predict: detectors that fail on writers whose first language is something other than English, and writers who have learned to launder AI output into prose that no detector flags.
The right question is whether the piece is worth publishing.
That question has two parts. Some of the prose I read every week is unedited LLM output: copied, lightly tweaked, sent on. Some of it is human-written, carefully styled, and carries no claim a reader can disagree with because no claim is being made. Both fail the test, on different axes. A piece can be 100 percent AI-generated and excellent. A piece can be 100 percent human-written and unreadable for the same reason a sales pitch is unreadable: it has nothing to say. Editors know this. Most existing tools force them to pretend they do not.
Slopcheck is the tool I built to ask the right question. It reads submitted content along two axes, separately. The first axis covers AI-provenance signals: patterns that suggest a particular model family produced the text. The second axis covers slop-independence: substance and depth tests that apply regardless of authorship. Both scores show. The editor decides what to do with each.
How it reads in practice
Paste a draft into the web app at tools.synthesiswriting.org/slopcheck/. The tool returns two separate readings. The first is AI-signal: which family the patterns match (Claude, GPT, Gemini, Llama, Grok, DeepSeek, Mistral, Qwen), the confidence level by family, and which specific patterns triggered. The second is slop-independence: a substance reading that runs the deletion test against each paragraph, applies the any-company test if the piece is business writing, counts load-bearing claims, and flags pseudo-profundity and frictionless-transition padding.
A draft can score low-AI and high-slop. That is the styled-empty human writing every editor recognizes. It can score high-AI and low-slop. That is competent LLM-assisted work where the writer added enough substance to carry the piece, but did not strip the model’s fingerprints. It can score high on both axes. That is the failure mode commercial detectors collapse into a single percentage. Or it can score low on both. That is publishable work, by whatever route.
Reporting both axes separately matters because the editorial decision is not the same for each. High-AI / low-slop is sometimes fine: an op-ed from a source who used an LLM to organize their thoughts may be worth running with disclosure. High-slop / low-AI is the version that should not run regardless of who wrote it. The two-axis frame gives editors language for distinctions they were making informally and reluctantly because no tool would name them.
Why the framing matters for writers who refuse AI
A note for the writer who has decided to use no AI assistance, for any reason, in any part of their work. Slopcheck is not for you in the sense that you do not need it for your own drafts. It is for you in another sense: your editor, your publication, your industry colleagues will use it. A tool that conflates “AI-touched” with “bad” punishes legitimate AI assistance and lets styled-empty human writing through. A tool that separates the two axes draws the line where the craft actually lives.
The synthesiswriting.org position has been consistent since the introducing-synthesis-writing pillar: synthesis writing is one form of the craft, available to anyone who wants it. It is not the only form, not the imperative form, not a threat to any other form. A calligrapher is not threatened by a word processor; a writer who works without AI is not threatened by a tool that helps other writers stay honest. The craft is the craft.
Where the catalog comes from
The detection methodology is open source, with a documented compounding-archive principle: patterns are never deleted. When a newer model version trains a pattern out, the catalog tags it with its era and retains it. The “As an AI language model” preamble that defined 2023 ChatGPT output is gone from current GPT-5.1, but it is still in the catalog, flagged Historical, with its years of prevalence noted. The same goes for the early Bard “as a large language model trained by Google” stem, the early Claude over-disclaimer patterns, and the first-generation refusal templates that have been trained out of every major frontier model since 2024.
The compounding archive is what makes the methodology useful for forensic review of older content. A newsroom auditing pieces from 2023 gets the full catalog applied with era-correct calibration. Editors checking today’s drafts get the same fidelity. The catalog does not split into “current” and “archive” versions.
The methodology covers eight LLM families with around one hundred active per-family patterns, plus seventeen substance-and-depth sub-patterns grounded in the academic literature on bullshit (Frankfurt, 2005; Hicks-Humphries-Slater, Ethics and Information Technology, 2024; Pennycook et al., 2015), plus seventy-six refreshed cross-family criteria. The full methodology piece, written for researchers and methodology readers, lives over on synthesisengineering.org.
What slopcheck is and is not
Slopcheck is free. There is no signup, no account, no email harvesting, no analytics on the input you submit. The hosted tier runs on a daily community budget; if you want unlimited use you bring your own API key (BYOK) and the tool routes through your provider without the content ever touching anything I run. For tech-friendly users, the same logic runs as a CLI tool, a browser extension (Chrome and Edge at launch), an Apple Shortcut, a Slack and Discord bot, and an email submission address. For everyone else, the web app and the Slopcheck Custom GPT in the OpenAI store and the Slopcheck Claude Project recipe cover the common workflows.
Slopcheck is not a verdict generator. It does not decide whether a piece should run. It surfaces the signals an editor uses to make that decision, and it surfaces them on the two axes that matter. The decision stays with the human in the editorial role.
Slopcheck does not collect submitted content. No leaderboards, no public archive of analyzed text, no examples gallery, no screenshots of user input in any blog post or social media surface. The privacy stance is auditable because every component is open source. The repos for the web app, the hosted-tier proxy, the tools-router, the browser extension, the CLI, the integrations, and the underlying skill catalog all live publicly on GitHub under permissive licenses.
Voluntary support runs through GitHub Sponsors. One-time or recurring. There is no paywall and no plan to add one. If the tool earns its keep, the way to say so is through sponsorship; if it does not, the public-service framing means it stays free regardless.
How to use it today
The fastest path is the web app: paste, read both scores, decide. The web app accepts up to 200,000 characters per submission, which covers most articles and many long-form pieces in one pass.
If you live in your chat tool, install the Slopcheck Custom GPT or set up the Slopcheck Claude Project recipe (instructions in the repo). Same analysis, inside the chat tool you already use.
If you want frictionless coverage on any web page, the bookmarklet (one-click drag to your toolbar) checks whatever you have selected, or the full visible text if you have nothing selected. The browser extension does the same with one click.
If you read submissions by email, forward them to [email protected]. The Cloudflare email worker replies with the analysis. Per-sender rate limits apply.
If you ship software and want the analysis in your pipeline, the CLI installs via npm install -g @synthesisengineering/slopcheck, brew install synthesisengineering/tap/slopcheck, or the AUR PKGBUILD on Arch. Source is at github.com/synthesisengineering/synthesis-slopcheck.
If you maintain an AI agent (Claude Code, Codex, Cursor, GitHub Copilot, and others), install the skills directly: npx skills add synthesisengineering/synthesis-skills --global --all --copy. The slop-detection capability becomes part of the agent’s editorial repertoire.
The honest case
The detection problem is not solved and will not be solved by a single tool. The arms race between content production and content detection is structural; it does not end. What can be improved is the framing of the question. “Is this AI” is a bad question that produces bad policy. “Is this worth publishing” is a better question, and asking it along two separate axes (AI-provenance signal and slop-independence) is the most honest version of the better question I have been able to formulate.
The companion engineering post covers the architecture: the multi-pass orchestrator, the hosted-tier safety layers, the tools-router pattern, and the open-source license choices that matter when you ship a free-to-use tool that proxies content to LLM providers. The methodology piece linked above covers the catalog structure for anyone who wants to read or extend it.
If the framing lands, try the web app on something you have submitted recently or something you are about to publish. Tell me what fires that should not, or what slips through that you would have caught. The patterns get better the more eyes report on them, and the catalog is open for contribution under the fourteen-field per-pattern template the methodology piece describes.