# 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.

- Skill: `isatimur/de-slop` (Agent Skill, multi-file: 11 files)
- Install (CLI): `npx skillmds@latest add isatimur/de-slop`
- Raw SKILL.md: https://api.skillmd.com/api/skills/isatimur/de-slop/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: MIT
- Author: isatimur (https://skillmd.com/u/isatimur)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/isatimur/de-slop

---


# 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.