Catches writing that sounds robotic, and shows you why. Then rewrite it in a voice you choose, in any AI agent or from the command line.
Ready to use in:
📐 Verified by Cadence — this README's own prose scores grade A on the detector. The slop quoted in the examples below is there on purpose.
You can usually tell when a machine wrote something. Not from any single word — from the texture. The sentences come out the same length. Every paragraph opens with a transition. The point gets hedged, then the hedge gets hedged. There are three examples where one would have landed harder. You may not be able to underline the broken part, but you feel it, and the moment you feel it you start to skim.
Cadence exists to strip that signature out. The enemy is not machines, it is flat, hollow writing. When a person writes that way it reads just as badly, and Cadence flags it the same. It does not care who wrote the text, only how the text reads.
The hosted score page: paste anything, see the grade and every tell, all in your browser. On a phone, tap Share then Add to Home Screen — it installs as an app and runs offline.
Three of my other projects lean on Cadence for their writing quality:
- linkedin-message-drafter drafts LinkedIn outreach from the command line. It handles the outreach plumbing (batch and CSV input, the hard 300-character connection-note limit) and hands voice-matching and de-slop back to Cadence.
- readme-auto-update builds and refreshes GitHub READMEs from what a repo actually does, then runs the prose through Cadence so it doesn't read robotic.
- elegance builds PHP + Bootstrap websites, and runs the site copy through Cadence so a small-business site reads like a person wrote it, not a machine.
Two things. It scores prose for how machine-made it reads, and it recasts prose so it reads like a person wrote it. The score is your baseline and your to-do list. The recast is the fix.
The one rule it never breaks: Cadence works on the words, not the meaning or the layout. It changes how a sentence reads. It does not touch what the sentence claims, or how the document is built. A smoother line that quietly drops a fact is a failure, not a win.
Three steps, and one rule holding them together.
First, diagnose. The checker reads your text, scores it, and names each tell it found: the flat rhythm, a hedge stacked on a hedge, a point padded out well past where it landed. You see what reads as machine-made, and why.
Second, recast the words, not the meaning. Rewrite the flagged lines yourself, or hand them to an AI writing in a voice you chose. What a sentence claims stays fixed; only how it reads changes.
Third, verify. Score the rewrite. If the rhythm variance hasn't moved, nothing has. You swapped synonyms and stopped. The number has to be earned.
The rule under all three: the checker is deterministic and it shows its work. A low score means the prose genuinely reads like a person wrote it, not that it slipped past a filter. That is the line Cadence stays on. It is here to make honest writing read like you, not to disguise what a machine wrote as something it isn't.
Slop isn't a grammar problem. AI prose is often spotless and still obviously synthetic, because the tell is rhythmic. Real writing breathes — a long, winding clause that earns its commas, then a stop. Machine writing flatlines at one comfortable length, sentence after sentence after sentence.
So the number Cadence watches hardest is rhythm variance (CV). Even, same-length sentences are the loudest fingerprint there is. If a rewrite doesn't move the variance, it didn't rewrite anything; it swapped synonyms and called it done.
Flat prose costs you the reader. People trust writing that sounds like a person meant it. The moment a page reads as generated, your argument inherits the doubt — even a good argument, even a true one.
A clean score is not the goal, though. Clarity is. A spotless score on an empty point is still an empty point. Find the real thing you have to say, say it in a voice, and let the low score fall out as a side effect.
You type these in Claude Code as /cadence <command>:
| Command | What it does |
|---|---|
learn <sample> |
Reads a book/article/URL and extracts a reusable voice profile |
write <brief> |
Drafts new prose in a chosen voice |
recast <text> |
Rewrites existing text into a chosen voice, keeping the meaning |
deslop <text> |
Scores text and reports every AI tell — diagnose, then optionally fix |
voices |
Lists the voices you've learned plus the shipped seeds |
New here? MANUAL.md is the full guide — install, the workflows, and every command and flag, in one place.
Every score below comes straight from skills/cadence/scripts/deslop.mjs. Reproduce them
with the commands shown.
Start with raw model marketing copy:
In today's world, finding the right productivity app can be a daunting task. Our cutting-edge platform leverages powerful AI to seamlessly streamline your workflow. Whether you're a busy professional or a student, our comprehensive solution empowers you to do more. It's not just an app, it's a game-changer. When it comes to getting things done, we've got you covered.
node skills/cadence/scripts/deslop.mjs before.txtCadence de-slop · score 61/100 · grade D
banned-phrase (4): "In today's world", "When it comes to", "game-changer", "Whether you're"
hollow-confidence (5): "seamlessly", "powerful", "comprehensive", "cutting-edge", "streamline"
negation-pivot (1): "It's not just an app, it's a game-changer."
cliche-opener (1): "When it comes to getting things done…"
/cadence recast into the plain voice, fixing each named tell:
Most productivity apps add work instead of removing it. This one starts with your real day. It reads what's due and what's blocking you, then shows the single next thing to do. Students use it. So do people running teams. You won't get a dashboard to admire. You'll get fewer open tabs.
Cadence de-slop · score 0/100 · grade A (61 → 0)
Brief: "reassure someone who feels they're falling behind their peers." Same thought, two profiles. Notice the structure change, not just the wording.
/cadence write --voice counsel (reframes the question; long-wind-then-snap rhythm):
You open the app and everyone is ahead of you. Engaged, promoted, somewhere sunlit. Underneath is a quiet arithmetic: they have more, so I have less, so I must be less.
But notice what that smuggles in. It assumes one shared finish line, and that the people posting are reporting rather than performing. Neither holds. Nobody posts the afternoon they spent staring at the ceiling.
Here is a question to set beside "am I falling behind?" — behind whom, and toward what? Name the finish line and you usually can't. The race dissolves.
score 0/100 · grade A · rhythm CV 0.57
/cadence write --voice reckoning (scene first, hard truth, aphoristic close):
At your ten-year reunion someone will have the house, the title, the symmetrical children, and you will do the math on the drive home. Here is what the math leaves out. Every person in that room ran a different race on a different track, and the clock you keep reading was never theirs to begin with. The comparison isn't wrong. It is measuring nothing. You are not behind. There is no line to be behind.
score 0/100 · grade A
/cadence learn https://example.com/an-essay-you-love
/cadence learn ~/writing/my-best-newsletter.txt
Cadence reads the sample, measures its real rhythm with the detector, and writes a
profile to voices/<name>.md. The shipped counsel voice was built this way.
voices/counsel.md shows what a learned profile looks like.
- counsel — a philosopher answering a private worry; reframes your question into a better one.
- reckoning — scene first, then a hard truth.
- measured-academic — careful first-person reasoning that concedes before it concludes.
- plain — say it once, in the fewest honest words.
- punchy — high contrast; long build, short hit.
- seminar — a professor demystifying a hard text; direct, wry, metaphor-driven.
- dispatch — narrative science-journalism: open on a scene, then land the idea.
- column — calm analytical essay: a fact, the reasoning, a usable principle.
- kin — a parent's unsparing letter to a child; every truth anchored in the body, landing on a short imperative.
- essence — first-principles tech-blog writing: strip a domain to its laws, reason up, and land on conviction.
Add your own with /cadence learn. Profiles are plain markdown in voices/. Read
them, edit them, share them.
The checker is the front door. Try it in five seconds, no install:
npx cadence-deslop draft.txt # any file: .txt .md .pdf .html .docx .epub
npx cadence-deslop ./some-repo # scan a whole folder/repo, ranked worst-first
npx cadence-deslop page.html # scores the visible text of a web page
npx cadence-deslop https://a.blog/post # fetch a live URL and score it
pbpaste | npx cadence-deslop # score whatever's on your clipboard
npx cadence-deslop --json draft.txt # machine-readable JSON
npx cadence-deslop --strict draft.txt # exit 1 if score > 25 (CI gate)Prefer a browser? The hosted score page runs the same checker on anything you paste, entirely on-device. On a phone it installs to your home screen and works offline, so it behaves like a small app.
deslop.mjs is the engine. Pure Node, zero dependencies. It only reaches the
network if you hand it a URL. Run it from a clone the same way:
node skills/cadence/scripts/deslop.mjs draft.txt
cat draft.txt | node skills/cadence/scripts/deslop.mjsIt measures sentence-length variance (the strongest tell), a banned-phrase list, hollow-confidence words, triad density, negation pivots, hedge-stacking, adverb and em-dash rates. It returns a transparent 0–100 score plus a letter grade. Same text, same score, every time.
The score is deterministic. Same text, same number, every time, and it names every tell it found, so you can check its work by eye. That is the honesty: not a confidence percentage you have to take on faith, but a list of exactly what it flagged and where. It is not guessing who wrote your text. It measures how the writing reads.
If you want authorship numbers anyway, they exist. On a 48-sample labeled corpus it
flags machine-written text with about 91% precision and rarely mislabels a human,
though it misses plenty of AI that avoids the common tells. That recall gap does not
worry us, because catching every machine is not the job. Catching slop is, whoever
wrote it. Run npm run bench for the full table, or read benchmark/.
CI fails if the numbers regress.
Once a detector exists, it can become a training signal, and that raises an honest
question worth testing: can a small local model learn to humanize slop as well as a
prompt on a frontier model already does? lora/ puts it to the test. It
fine-tunes a rank-16 QLoRA to rewrite AI slop into clean prose, then grades the
result with the real deslop.mjs.
Why grade it this way. Most self-improvement loops grade their own output,
which proves nothing. Cadence's detector was written before and independently of
this adapter, so it judges the work instead of reflecting it. The rig scores three
arms on the same held-out text (the base model, the adapter, and the prompt-based
recast) and reports the slop score next to rhythm CV and the per-tell breakdown.
That pairing is the honesty check: a lower score that came from deleting flagged
phrases, rather than learning to vary sentence length, shows up as flat rhythm
variance instead of hiding.
Why it is worth doing. A local adapter is private and cheap where an API call is neither, and the result answers something a prompt cannot: whether this skill is learnable, not just promptable. Training pairs are filtered to detector-verified grade-A targets, and a Kaggle notebook runs the whole flow on a free GPU. Whatever the numbers say, a partial or negative result included, that is the reportable outcome. The measurement half needs no GPU and reproduces anywhere Node runs.
Grounding in the literature. The adapter is a QLoRA (Dettmers et al., NeurIPS 2023) over low-rank adapters (Hu et al., 2021). The insistence on an independent grader and verified targets is not fussiness: training on recursively generated data can degrade a model into model collapse, shown by Shumailov et al., Nature 2024. Filtering every synthetic target through a detector the model cannot influence is the disciplined way to train on generated data without inheriting that failure.
The full plugin. It writes in voices and learns new ones from samples. Cadence is a Claude Code plugin, and this repo is its own marketplace; plugins are free, with no store and no fee:
/plugin marketplace add wuisabel-gif/Cadence
/plugin install cadence@cadence
Then /cadence write …, /cadence deslop …, /cadence learn …, etc. are available
in a new session. New voices you create with /cadence learn are written to a
voices/ folder in whatever project you're working in. (Developing on Cadence? Point
the marketplace at a local clone instead: /plugin marketplace add ~/cadence.)
Also in this marketplace: README Auto Update. It builds evidence-based GitHub profile and project READMEs with free structural templates — no agent, no API key — and pairs with Cadence: generate the README's structure there, then humanize its prose here.
/plugin install readme-auto-update@cadence
/cadence not recognized? It runs only in Claude Code — not the claude.ai
website or the desktop app's regular chat. MANUAL.md
covers that and the rest of the activation pitfalls.
In a regular Claude conversation (claude.ai or the desktop app). That chat doesn't read the plugin marketplace — it takes an uploaded skill bundle instead. Build one and drag it in:
npm run build:claude-skill # writes cadence-skill.zip (SKILL.md + scripts + voices)Then Settings → Skills → Add → Upload skill, and drop in cadence-skill.zip. The
voices and de-slop guidance work immediately; the live detector runs only where that
conversation has code execution — otherwise score in a terminal with
npx cadence-deslop.
Just the detector. Score prose anywhere, no plugin needed:
npx cadence-deslop draft.txt # run it without installing
npm install -g cadence-deslop # or install the `cadence-deslop` / `deslop` commandIn Codex. The skill ships an AGENTS.md next to SKILL.md, so the same folder
works in Codex too. The detector is portable as-is (npx cadence-deslop runs in any
shell); to give a Codex agent the voices and writing laws, point it at
skills/cadence/AGENTS.md — drop it into your project's
AGENTS.md, or copy the parts you want.
In Gemini CLI. There's an installable extension at
integrations/gemini/ — symlink it into
~/.gemini/extensions/cadence and the GEMINI.md context loads every session.
In DeepSeek. DeepSeek's Skills are markdown you toggle from the drawer. Paste in
integrations/deepseek/cadence-skill.md and
score drafts in a terminal with npx cadence-deslop.
In VS Code. There's an extension at
integrations/vscode/ — a live grade in the status
bar, the AI tells squiggled inline, and a score-on-demand report. Build it with
npm run build:vscode, then press F5 to try it or package a .vsix to install.
In your inbox and chats. The Chrome extension at
extension/ works in Gmail, WhatsApp Web, Telegram, LinkedIn,
Instagram and Facebook: it scores your reply as you type — on-device — and, with your
own Anthropic key, drafts one in your voice. It writes, scores the draft locally, then
redrafts to clear any AI tells before dropping it in the box. A "Learn my voice"
button reads what you've written on the page — your posts on Instagram, Facebook or
LinkedIn, or your own sent messages on WhatsApp and Telegram — and distills your
sentence-usage traits into that voice profile. Build it with
npm run build:extension, then load the folder unpacked.
| Document | What it covers |
|---|---|
| MANUAL.md | The full guide: install & activation, workflows, and every command, flag, and exit code |
| tutorials/scan-a-repo.md | Tutorial: audit and de-slop an entire repo, then gate it in CI |
| extension/README.md | The Chrome extension — score prose anywhere, plus a live impression check and draft-in-your-voice in Gmail, WhatsApp Web, Telegram, LinkedIn and Instagram |
| integrations/vscode/README.md | The VS Code extension — live grade, inline tells, and a score report |
| benchmark/README.md | The accuracy benchmark: labeled corpus, published precision and recall, and the CI gate |
| lora/README.md | LoRA-Cadence: train a slop-humanizing QLoRA graded by the detector, plus the Kaggle notebook |
| PHILOSOPHY.md | The thinking behind it — The Age of Taste |
| CONTRIBUTING.md | How the project is built and how to add a rule, voice, or command |
| CHANGELOG.md | Version history |
| LICENSE | MIT |
Each of these is scored by the detector on every push and must stay grade A.
cadence/
├── .claude-plugin/
│ ├── plugin.json # plugin manifest
│ └── marketplace.json # marketplace catalog (this repo lists itself)
├── skills/
│ └── cadence/
│ ├── SKILL.md # router, shared writing laws, setup (Claude Code)
│ ├── AGENTS.md # the same skill for Codex
│ ├── reference/ # one file per command + the voice schema
│ └── scripts/
│ ├── deslop.mjs # the detector (real code, tested)
│ └── extract-text.mjs # pure-Node prose extraction from .pdf/.txt/.md
├── voices/ # shipped voice profiles (seed set)
├── check.html # hosted score page, installable as an offline app
├── manifest.webmanifest # PWA manifest + sw.js + assets/icons for the app
├── benchmark/ # accuracy benchmark: corpus + bench.mjs + CI gate
├── lora/ # LoRA-Cadence: eval rig + Kaggle training notebook
├── docs/screenshots/ # example shots used in this README
├── extension/ # the Chrome extension (generated detector)
├── integrations/ # Codex, Gemini, DeepSeek, and VS Code surfaces
│ └── vscode/ # the VS Code extension (generated detector)
└── tests/ # 36 tests — `npm test`
├── deslop.test.mjs
└── extract-text.test.mjs
npm test # 36 tests over the detector, the extractors, and the bundled builds
npm run check:docs # dogfood: the repo's own docs must score grade A
npm run bench # accuracy benchmark: precision, recall, and the tell breakdownv0.2 — the detector and the ten seed voices work and are tested. The detector is on
npm as cadence-deslop, and Cadence runs across seven surfaces: Claude Code,
a regular Claude conversation, Codex, Gemini CLI, DeepSeek, the Chrome extension, and
the VS Code extension.