De slop

Skill isatimur/de-slop/skills/de-slop

Portable Claude Code skill that de-slops AI prose — detect, rewrite to a real point of view, self-score, iterate. Fidelity-first; flags hollow spans instead of faking them.

Install

npx -y skills add isatimur/de-slop --skill de-slop

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

2 stars2 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Use when prose reads like AI — to remove "AI slop" (empty hedging, listicle stems, smooth transitions that hide the absence of a claim, generic filler) and rewrite it into writing with a real point of view. Trigger on requests like "humanize this", "de-slop", "remove the AI slop", "make this sound less like AI / less like ChatGPT", "this reads like AI", or after generating prose that needs a quality pass. Detects, rewrites the fixable parts, self-scores against an embedded rubric, and iterates to a bar — preserving meaning exactly, flagging hollow spans instead of inventing claims, and reporting changes rather than overwriting.

The file declares its own license as MIT. That is the author’s claim about this one file, and it is not the same thing as the license GitHub reports for the repository, which is listed with the other numbers below.

SKILL.md

4.4 KB, as published. Nobody here has run it

De-Slop

Turn AI-slop prose into writing that survives a hostile editor's red pen — without swapping one kind of slop for another.

Two hard rules (read first)

Fidelity over flair. Preserve the original meaning and claims exactly. Only subtract hedging/filler and sharpen what is already there. Never inject stance, edginess, em-dash theatrics, or first-person personality the content did not earn. Swapping AI-slop for edgy-slop is a failure, not a fix.
Flag hollow spans, don't fabricate. Some prose is weak because it has no point to make — rewording cannot save it. Flag those. Do not invent a hot take to make them sound sharp.

The loop

0. Scope. Work paragraph by paragraph. Skip code blocks, blockquotes, headings, and genuine lists.

1. Pre-flag. Run the cheap deterministic pass to narrow attention:

python3 scripts/flag_slop.py <file>     # or: cat text | python3 scripts/flag_slop.py

It returns JSON spans (hedge stems, listicle openers, em-dash density, "in today's…", filler intensifiers, etc.). These are candidates, not verdicts — you still judge every paragraph.

Optionally, python3 scripts/flag_slop.py --score <file> returns a per-paragraph slop_band. Treat it as a surface-tell meter, not a humanness score: it measures how many slop patterns appear, not whether a real claim is present. A paragraph with zero tells can still be hollow and fail the rubric — so a high slop_band never excuses you from step 2. See references/slop-catalogue.md for which tells the detector can and cannot see.

2. Judge. Score each paragraph against references/rubric.md → strong | moderate | weak | fail, with a one-line reason. The bar is the hostile-editor test: would this survive a red pen? does removing it lose anything?

3. Triage each paragraph below strong:

Rewordable — there's a real claim buried under hedging/filler → rewrite.
Hollow — weak because there's no actual point → flag, don't fabricate.

4. Rewrite the rewordable ones, applying references/guardrails.md. Subtract the hedging, sharpen the existing claim, keep the meaning identical.

5. Self-score the rewrite against the rubric again.

Reached strong → lock it in.
Still below → iterate (back to step 4). Maximum 3 passes total.
After 3 passes still not strong → keep the best version and flag it ("couldn't reach strong — may need a real claim, not better words").

6. Report — do not overwrite. Return three things:

Humanized text — rewrites applied; hollow spans left intact.
Change log — per paragraph: before-band → after-band and what changed.
Flags — hollow spans + any span that hit the 3-pass cap.

The human or calling agent decides what to accept.

Properties this loop must preserve

Fail-honest: hollow and capped spans are always surfaced, never quietly "polished."
Idempotent: prose that already scores strong is returned unchanged.
Non-destructive: you produce a report + change log, not an in-place edit.

References

references/rubric.md — the scoring bands, slop indicators, the two tests, and the rewordable-vs-hollow triage rule. Load it for step 2.
references/guardrails.md — fidelity rules and the over-correction anti-pattern catalogue. Apply it for step 4.
references/examples.md — before→after pairs, "flag don't fabricate" cases, and over-correction PASS/FAIL pairs. Consult when a rewrite is non-obvious.
references/slop-catalogue.md — the full taxonomy: every tell, why it reads as AI, the detector type that catches it (or why none can). The map of the detector's blind spots.