agentsclimarketplace
Sign in

De slop

Skill isatimur/de-slop

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.From its SKILL.md

Install
npx -y skills add isatimur/de-slop

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

2 things 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.
  • runs commandsInstructs the agent to run 3 commands, including `python3 scripts/flag_slop.py <file>` and 2 more.

What its file declares

Copied from the file, not written here

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, 954 tokens by cl100k_base, 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)

  1. 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.
  2. 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.

What ships with it: 51 files

460.0 KB alongside SKILL.md, 11 of them executable

.claude-plugin/

adapters/

docs/

references/

scripts/

tests/

11 more files not listed here. See all 51 in the repository.

Gives 0 of the 12 instructions most docs writing skills give in 954 tokens

Counted across 1,951 of the 3,904 authors here whose files we hold, read 2026-09-06

  • Use third-person for skill descriptionsin 54 of 1951, across 35 files
  • Start descriptions with Use whenin 43 of 1951, across 29 files
  • Run baseline scenarios before writing any skillin 40 of 1951, across 26 files
  • Use active voicein 40 of 1951, across 36 files
  • Map file responsibilities before defining tasksin 36 of 1951, across 29 files
  • Use checkbox syntax for tracking stepsin 35 of 1951, across 27 files
  • Ask one question at a timein 35 of 1951
  • Offer execution options after saving the planin 33 of 1951, across 24 files
  • Include complete code in every stepin 33 of 1951, across 27 files
  • Design units with clear boundaries and interfacesin 31 of 1951, across 23 files
  • Announce the skill usage at the startin 30 of 1951
  • Verify agent compliance after adding the skillin 29 of 1951, across 17 files

Said here and by no other author read

  • process text paragraph by paragraph
  • run the slop detection script
  • score each paragraph against the rubric
  • rewrite rewordable paragraphs to remove filler
  • flag hollow spans instead of inventing claims
  • return a report instead of overwriting text

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once. Length counted with cl100k_base; the agent that loads this file may tokenize it differently.

Keep looking

Skills are one crate of 325,949. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.