A deterministic, fail-closed gate against AI slop in prose. Zero tokens, zero network, zero runtime dependencies — a linter for your writing, not another AI model.
You point it at a piece of writing; it tells you, the exact same way every time, which words, phrases, and shapes give away that a machine wrote it. It never sends your text anywhere and it never "decides" with a model — it matches your draft against fixed lists and simple arithmetic, so the answer is reproducible and free.
Names, quickly. The tool is called
slopfilter— that is the command you run, the npm package, and the Claude skill. It lives in a GitHub repository calledslopgate(ClearMountainDigital/slopgate), which is the larger project. If you see both names, that's why.
There are two ways to use it, and this guide covers both from a cold start:
- As a command-line tool — run
slopfilter draft.mdin a terminal and read the report. Good for a quick check, a git hook, or CI. - As a Claude skill / plugin — inside Claude Code, it runs the check and rewrites what it finds, looping until the draft is clean. Good for actually fixing a draft, not just flagging it.
You do not need to be a programmer for either. If you have never opened a terminal, start with Part 1; it walks through everything.
- What it checks
- Part 1 — Use it as a command-line tool
- Part 2 — Use it with Claude
- How fixing works
- Troubleshooting & FAQ
- Philosophy
- For contributors
- License
slopfilter looks at five things. Four of them can fail a draft (a "hard fail"); one is just a to-do list.
- AI-slop phrases (hard fail) — the stylistic tics that read as AI no matter what you're writing about: "here's the thing," "game-changer," "delve," "at the end of the day," a stray em dash (—), and the colon-led "label: item, item, item" list shape.
- Vague authority (hard fail) — claims that lean on a source nobody can name: "studies show," "experts say," "it's well known." They can never be checked, so they erode trust.
- Operator-address leaks (hard fail) — a sentence written to you, the person who ran the AI, instead of to the reader: "Here's the caption rewritten in your brand voice," "let me know if you'd like changes," "as an AI." This is the tell that a draft went out without a human reading it.
- Reading ease (hard fail, only past ~100 words) — a Flesch Reading Ease score. Prose that's too dense fails; so does prose chopped into robotic monosyllabic fragments. The default target band is 60–75.
- Claims ledger (not a fail — a checklist) — every number, date, attribution ("according to…"), superlative ("the first," "the best"), and named entity. Each is flagged if there's no citation on its line. It's a fact-check worklist, not a reason to block the draft.
Exit code: the command exits 0 if the draft is clean, 1 if it has any hard fail, and 2 if you gave it a bad file or config. (Exit codes are how git hooks and CI know whether to let writing through.)
The "command line" (also called the "terminal") is a text window where you type commands. On a Mac, open the Terminal app (press ⌘+Space, type "Terminal", hit Enter). On Windows, open PowerShell or Windows Terminal from the Start menu.
slopfilter runs on Node.js, a free program that lets your computer run tools like this one. You install it once.
- Go to https://nodejs.org and download the LTS version.
- Run the installer and accept the defaults.
- Confirm it worked. In your terminal, type this and press Enter:
node --versionIf you see a version number like v20.11.0 or higher (anything v18.18 or newer works), you're set. If you get "command not found," restart your terminal and try again.
You do not need to install slopfilter separately. The npx command (which came with Node) downloads and runs it for you. In your terminal, go to the folder with your writing and run:
npx slopfilter my-draft.mdThe first time, it downloads the tool (a few seconds); after that it's instant. my-draft.md is the path to your file — it can be a .md (Markdown), .txt, or any plain-text file. You can check several files at once:
npx slopfilter intro.md pricing.md email.txtPrefer to type just slopfilter? Install it once, globally:
npm install -g slopfilter
slopfilter my-draft.mdWorking inside a code project? Add it as a development dependency so your whole team gets the same version:
npm install --save-dev slopfilter
npx slopfilter my-draft.mdHere's a sample run and what every part means:
my-draft.md
2 load-bearing claim(s) · 1 uncited · 1 vague-authority phrase(s) · 1 AI-slop phrase(s) · 0 colon-list(s) · 1 operator-address leak(s)
reading ease: 72.4 ✓ (in band 60–75)
✗ vague-authority phrases (must be removed or grounded):
L1 "studies show" — Studies show our tool saves teams 40% of their time.
✗ operator-address leaks (a sentence written to you, not the reader — delete it):
L3 "let me know if you'd like" — Let me know if you'd like a punchier intro.
✗ AI-slop phrases (must be rewritten — banned list):
L1 "game-changer" — Studies show our tool saves teams 40% of their time — a real game-changer.
claims ledger (verify each against a source, or flag it):
⚠ L1 [number] 40% — Studies show our tool saves teams 40% of their time — a real game-changer.
- The summary line counts each category.
- reading ease shows the score, a ✓ (in band) or ✗ (out of band), and the target band. Below ~100 words it's marked "advisory" and never fails.
- Each ✗ section is a hard fail.
L1is the line number; the phrase in quotes is what matched; the text after—is the line it's on. - The claims ledger is your fact-check list.
⚠means no citation is on that line. This never fails the draft — it's there so you don't ship an unverified number.
This example exits 1 (three hard fails). Fix the vague-authority phrase, delete the operator-address sentence, and rewrite the hype word, and it exits 0.
slopfilter skips fenced code blocks, Markdown headings, and blockquotes. This matters more than it sounds.
If your document quotes slop words on purpose — a style guide, a tutorial, a "words to avoid" list — the plain lister will flag every example, because a regular expression can't tell "delve" (an example) from "delve" (a real slip). The fix is to wrap those examples in a fenced code block (three backticks above and below):
Avoid borrowed authority like:
```
studies show experts say research suggests
```Everything inside the fences is ignored by the checker. The same is true for anything you quote with a > blockquote — a slop phrase inside a customer quote is the quotee's problem, not yours, so it's skipped. Rule of thumb: if it isn't your own prose, fence it or quote it, and slopfilter will leave it alone.
Every default is adjustable with an optional file named slopfilter.config.json. Put it next to your writing (or anywhere above it in the folder tree — slopfilter searches upward from each file). Here is one with every option shown:
{
"dimensions": {
"slop": true,
"vagueAuthority": true,
"claims": true,
"readability": true,
"operatorAddress": true
},
"ban": ["synergy", "circle back around"],
"allow": ["robust", "em-dash"],
"readability": { "band": [60, 75], "minWords": 100 }
}dimensions— turn any of the five checks off by setting it tofalse. (You rarely need this.)ban— extra phrases to treat as slop, in addition to the built-in list. Use this for your own house tics.allow— built-in entries you disagree with, removed by exact phrase. Two special names switch off non-phrase rules:"em-dash"(stop flagging — characters) and"colon-enumeration"(stop flagging the colon-list shape).readability— move the target band or the word count at which it starts checking.
Common recipe — marketing / plain-language copy. Punchy how-to and sales copy often scores above 75 (very easy to read), which is the goal, not a defect. Widen the band so it doesn't fail on register:
{ "readability": { "band": [55, 90] } }Or point slopfilter at a specific config regardless of location:
npx slopfilter my-draft.md --config ./marketing.slopfilter.config.jsonNote: the tool will not let a config quietly weaken a check to force a pass in the Claude loop (see Part 2). Editing your own config on the command line is fine; that's what it's for.
Add --json to get the full machine-readable report — every hit with line numbers, the claims ledger, and the readability measurement — instead of the human view:
npx slopfilter my-draft.md --jsonUseful if you want to build a dashboard, a custom report, or your own editor integration.
Because it exits 1 on any hard fail, you can make slop impossible to ship.
Pre-commit hook (blocks a commit that contains slop). Create .git/hooks/pre-commit, make it executable (chmod +x .git/hooks/pre-commit), and put this in it:
#!/usr/bin/env bash
# Gather staged Markdown files; if there are any, check them all in one run.
files=$(git diff --cached --name-only --diff-filter=ACM | grep '\.md$')
[ -z "$files" ] && exit 0
npx slopfilter $files # exits 1 on any hard fail, which aborts the commitGitHub Actions (blocks a pull request that contains slop). Add .github/workflows/slop.yml:
name: slop check
on: [pull_request]
jobs:
slopfilter:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with: { node-version: "20" }
- run: npx slopfilter $(git ls-files '*.md') # every tracked Markdown fileClaude Code is Anthropic's coding assistant that runs in your terminal (and in VS Code / JetBrains). slopfilter ships a skill for it — a saved set of instructions Claude follows on its own.
The command-line tool finds slop. The Claude skill fixes it, safely:
- It runs the command-line gate to find every hard fail.
- It rewrites each one by subtraction — cutting the tic and keeping your point — never by swapping in a fancier synonym.
- It hands the rewrite to a separate, fresh evaluator that grades it against a fixed rubric of shape-and-voice problems a word list can't catch (product pivots, triplets, fake-profound endings, and so on).
- It loops — rewrite, re-check — until the gate is clean, every rubric finding is resolved, every fact you wrote survives verbatim, and your voice wasn't flattened. If it can't get there in three rounds, it stops and hands the draft back with the evidence instead of grinding your voice into paste.
The evaluator is deliberately a different agent from the one that did the editing, so nothing "grades its own homework."
Prerequisites for all three options below:
- Claude Code installed and working.
- Node.js installed (see Step 0) — the skill runs
npx slopfilterunder the hood.
Inside Claude Code, run these two commands (type them at the Claude prompt, including the leading /):
/plugin marketplace add ClearMountainDigital/slopgate
/plugin install slopfilter@slopgate
The first command registers this repository as a source of plugins; the second installs the slopfilter plugin from it. Claude may ask whether to install it for just you or for everyone on the project — either is fine.
Check it's there:
/plugin
That opens an interactive menu (move between tabs with Tab). Under Installed you'll see slopfilter.
Use it. You can just ask, in plain English:
Run slopfilter on this draft: (paste your text, or name a file)
Claude recognizes the request from the skill's description and runs the loop. If you'd rather trigger it explicitly, type:
/slopfilter
(If another command ever shares that name, use the fully-qualified /slopfilter:slopfilter.)
This is the most reliable way to get the full loop, because every bundled file sits right where the skill expects it.
git clone https://github.com/ClearMountainDigital/slopgate.git
cd slopgate
npm install
npm run build # compiles the command-line tool into ./distThen start Claude Code from inside that slopgate folder and ask it to "run slopfilter on this draft." Because you're in the repo, the skill, the rubric, and the rewrite guide are all found automatically, and the slopfilter command runs from your local build.
If you want the skill available in every project without installing the whole plugin, copy the skill folder into your personal Claude skills directory:
git clone https://github.com/ClearMountainDigital/slopgate.git
mkdir -p ~/.claude/skills
cp -R slopgate/skills/slopfilter ~/.claude/skills/slopfilter
cp -R slopgate/guide ~/.claude/skills/slopfilter/guideThe second copy matters: the skill reads guide/voice-rubric.md and guide/rewrite-guide.md, so those files have to travel with it. After copying, restart Claude Code; the slopfilter skill will be available in any project. (You still need npx slopfilter to work — see prerequisites.)
This is the fiddliest option: because the skill runs from your project's folder rather than its own, Claude occasionally can't locate the bundled rubric and guide. If it reports a missing file, prefer Option A (a plugin resolves its own files via ${CLAUDE_PLUGIN_ROOT}) or Option B (running from the clone puts them right where the skill looks).
Under the hood, on every draft, the skill enforces four things before it calls a draft done. It stops only when all four hold at once:
- the command-line gate exits
0(no hard fails), - the separate evaluator returns zero rubric findings,
- every load-bearing claim (number, date, name) survived the rewrite word for word, and
- your stance and edge weren't sanded into something bland.
If three rounds go by without hitting all four, it hands the draft back to you with the remaining findings quoted. It will never edit the rubric or your config to fake a pass.
Two bundled documents drive the fixes, and you can read them yourself:
guide/rewrite-guide.md— how to rewrite each category without adding new slop. The rule under all of it is subtraction, not substitution: slop is scaffolding around a point, so remove the scaffolding and let the point stand. Never trade "delve into" for "dive into" — that's the same tic wearing a hat.guide/voice-rubric.md— the "frozen" checklist of shape-and-voice problems no word list can catch: the product pivot, the triplet, the binary contrast, the fake-profound kicker, and more. It's called frozen because the fixing loop is never allowed to edit it to make a draft pass. Every finding it produces names the pattern and quotes the exact line, so it's evidence you can check, not a vibe.
Everything in my document got flagged. You're almost certainly checking a document that quotes slop as examples (a style guide, a tutorial). Wrap the example lists in fenced code blocks; slopfilter skips them. See fence your examples.
My marketing copy fails on reading ease even though it reads great. Plain, punchy copy often scores above the default 75 ceiling — that's a good score, and the default band is tuned for essays. Widen the band in a config: { "readability": { "band": [55, 90] } }.
slopfilter: command not found. You skipped the global install. Either run it with npx slopfilter … (no install needed) or run npm install -g slopfilter first.
"I'm seeing fewer checks than this README describes." You may be running an older published version. Update with npm install -g slopfilter@latest, or run from a clone (Option B) to get the newest checks.
The claims ledger flags ordinary words like "The first" or a brand name. The claims ledger is a worklist, not a failure — those are surfaced so you can glance at them, not blocked. Superlatives and multi-word capitalized names are the noisiest category by design; skim them and move on. They never change the exit code.
Does it send my writing anywhere? No. The command-line tool is pure local computation — no network, no AI model, no telemetry. (The Claude skill runs inside Claude Code, which is a separate AI product you've chosen to use; the underlying gate it calls is still local.)
It flagged an em dash / a colon list I want to keep. Add "allow": ["em-dash"] or "allow": ["colon-enumeration"] to your config.
slopfilter is a detector, not an adjudicator. The guarantee comes from deterministic regular expressions and arithmetic that fail closed — the same input always produces the same output — not from a model's opinion of its own work. That's why it's fast, free, and trustworthy as a gate. The Claude skill layers judgment on top of that floor, but it can only ever add findings; it can never wave away a hard fail the detector found.
Precision over coverage: a check only becomes a hard fail if it almost never misfires on honest writing. Words that have legitimate uses (like "quietly" or "foster") are deliberately left to human or rubric judgment rather than banned outright, so the gate stays trustworthy enough to wire into CI.
git clone https://github.com/ClearMountainDigital/slopgate.git
cd slopgate
npm install
npm test # run the test suite (Vitest)
npm run typecheck # type-check without emitting
npm run build # compile src/ to dist/The detector is a pure, dependency-free TypeScript module in src/ (lint.ts is the engine, lists.ts the phrase lists, config.ts the config layer, cli.ts the command-line wrapper). Design notes and the implementation plan live under docs/superpowers/.
MIT