Cursor

git clone https://github.com/MohamedAbdallah-14/unslop.git

Open the folder in Cursor. The project rule at .cursor/rules/unslop.mdc loads automatically.

The repository also contains a Cursor Plugin manifest. Until the Marketplace listing is approved, test the installable plugin from a clone:

cd unslop
mkdir -p ~/.cursor/plugins/local
ln -s "$(pwd)" ~/.cursor/plugins/local/unslop

Restart Cursor or run Developer: Reload Window. The rules and skills appear under Customize. Remove the symlink when local testing is finished.

After Cursor approves the public listing, open Customize, search for unslop, select Install, and choose project or user scope. The listing is not live yet.

Windsurf or Cline

Open the cloned folder in your IDE. The bundled rule files at .windsurf/rules/unslop.md and .clinerules/unslop.md load automatically.

Gemini CLI

git clone https://github.com/MohamedAbdallah-14/unslop.git && cd unslop
gemini extensions install ./

Reads gemini-extension.json and loads GEMINI.md + the unslop skill into context.

OpenAI Codex

Clone the repo and open it in Codex. Codex reads the root AGENTS.md before it starts work, so the repository's writing and review rules apply immediately.

To install the reusable bundle from this repository's marketplace:

codex plugin marketplace add MohamedAbdallah-14/unslop --ref main
codex plugin add unslop@unslop-agents-marketplace

The bundle lives at plugins/unslop/ and follows the Codex .codex-plugin/plugin.json format. Public-directory availability is a separate review; the repository marketplace works without claiming that listing is live.

Claude Code without the plugin system (manual hooks)

For forks, air-gapped setups, or when you want to see exactly which files get written:

git clone https://github.com/MohamedAbdallah-14/unslop.git
cd unslop
bash hooks/install.sh            # macOS / Linux
pwsh hooks/install.ps1           # Windows

What this does:

• Copies hook scripts to ~/.claude/hooks/ (flat, not a subdirectory)
• Registers SessionStart and UserPromptSubmit in ~/.claude/settings.json, merged safely via Node (never clobbers existing hooks)
• Wires the statusline so [unslop:FULL] shows when active

Idempotent. Re-run anytime to upgrade. The bash installer re-verifies settings.json state on each run; the PowerShell installer checks file presence only, so pass -Force on Windows if settings.json was hand-edited.

Standalone CLI (no IDE needed)

pipx install unslop
unslop --deterministic path/to/file.md

For API-backed LLM mode, install the optional SDK with pipx install 'unslop[llm]'. See unslop/README.md for the full CLI surface.

No. It changes how the reply sounds, not what it says. Ask for a cover letter, you still get a cover letter. Ask for feedback on your essay, you still get feedback. The facts, the advice, the answer — all there. Just without "Certainly! What a fantastic question!" around them.

Mostly no, honestly. My own testing against the TMR detector (99.28 % AUROC) shows deterministic surface rewriting moves scores by 0.0–0.2 pp. This matches the Adversarial Paraphrasing paper (NeurIPS 2025) predicting that exact outcome: modern detectors fingerprint on structural signals that synonym-swap rewriting cannot move.

What actually lowers detector scores, in order: (1) paraphrase through a different model family — GPT → Claude → Gemini, (2) burstiness, (3) specificity the model can't fake, (4) contractions and small fragments, (5) breaking predictable structure. Items 2–5 are what /unslop anti-detector does. Item 1 is a workflow you orchestrate.

Detectors also have a big false-positive problem. Liang et al. (Patterns 2023) found >50 % of TOEFL essays flagged as AI-generated. If a reader is running your work through a detector, document your process and keep drafts.

Turn it off for those. unslop trades precision for voice. For anything where a reader needs to follow the text exactly — a lease, a drug interaction warning, a deployment runbook — you want the robotic version. unslop is for text where the reader needs to like the text.

Deterministic mode preserves code blocks, URLs, headings, tables, blockquotes, and YAML frontmatter byte-identical. The risk isn't the tool breaking code; it's the rewriter smoothing a number you misremembered and making the wrong version sound confident. Re-verify facts after humanizing.

Not for the default plugin mode (it uses whatever assistant is already loaded — Claude Code, Cursor, etc.). Not for deterministic CLI mode (--deterministic, pure regex, no network).

You do need ANTHROPIC_API_KEY for: (a) default LLM CLI mode, (b) the evals/ humanness harness, (c) /unslop voice-match and full modes when running outside an assistant.

No telemetry, no analytics, no phone-home. The plugin's hook scripts run locally. The CLI calls whichever API you configured (Anthropic, or none with --deterministic). The voice-match cache is a numeric-only JSON file on disk at mode 0600, stored under $XDG_CONFIG_HOME/unslop/. No prose is persisted anywhere.

Three differences:

1. It's consistent. A prompt works for one message; the hook activates the rule every session and reinforces it at turns 8/16/24 to beat persona drift (RMTBench / HorizonBench 2026 measure >30 % degradation after 8–12 turns without reinforcement).
2. It's specific. The rule names dozens of patterns to drop (sycophancy openers, stock vocab, hedging stacks, transition tics, significance inflation) and gives structural targets (burstiness CV, sentence-length spread). "Write like a human" relies on the model's guess at what human means.
3. It's measured. The blind LLM-judge test and rule-based AI-ism counter run on every change. The 100 % preference / 92 % reduction numbers come from that harness, not vibes.

Each layer matches its host: Python for the file rewriter (CLI, HuggingFace integration, test ecosystem), JavaScript for Claude Code hooks (that's what the SessionStart / UserPromptSubmit APIs accept), markdown rules for every assistant that reads .cursorrules / CLAUDE.md / GEMINI.md / .windsurfrules. The sync.yml workflow keeps a single source of truth mirrored to every platform-specific location.

"Slop" is the term the LLM-evaluation community converged on for the residue of RLHF preference training — tricolons, sycophancy, stock vocab, tidy five-paragraph shapes. The verb "unslop" is the operation. Name was taken.

The file-rewriter (unslop) placeholder-protects these in deterministic mode and fails the run if the validator detects they changed:

• Fenced code blocks (``` ... ```) — content and structure
• Indented code blocks (4-space)
• Inline code (`foo()`)
• URLs and markdown links
• Headings (whole line, text and level)
• YAML frontmatter at file start (---\n...\n---)
• Blockquotes (> lines and multi-line > blocks)
• Markdown tables (pipe tables)
• Quoted single-word examples — "delve" or "tapestry" stays put, because the word is being discussed, not used (use/mention distinction)

File paths, commands, technical terms, version numbers, and error messages stay exact when they live inside code blocks / inline code / URLs. Bare prose references to them are not separately protected; deterministic regexes only target prose patterns, so they usually pass through, but review the diff if your file mixes prose with identifiers.

LLM mode (default) receives the same preservation list as an explicit instruction. It cannot be byte-enforced the way deterministic mode is, so run the file through python3 -m scripts --deterministic afterwards if you need a hard guarantee.

det = handled by deterministic regex mode. llm = requires LLM mode (semantic rewrite, not regex).

Mode gating. subtle runs stock vocab only. balanced (default) runs everything tagged det plus Phase 1 structural and Phase 5 contractions. full adds filler phrases, negative parallelism, and superficial -ing. Use --no-structural or --no-soul to turn off the newer passes for highly formal content.

Don't humanize everything. Humanization trades precision for voice. For code, legal text, medical advice, security warnings, runbooks — you want robotic. Precision beats voice.

Humanize when a human reader will judge you on how it sounds:

• Resumes, cover letters, personal statements, bios
• College essays and applications
• LinkedIn posts, cold outreach, marketing copy
• Blog posts, newsletters, anything where the voice is the product

The two real levers

After reading the full compendium, it comes back to two moves. Everything else is decoration.

Subtract, don't add. AI tone isn't a thing you layer on top of pretraining. It's a residue from RLHF — the model was trained on preference data that rewards polite, hedged, tricolon-heavy prose. The fastest path to human-sounding text is removing those patterns, not sprinkling in "warmth". Adding warmth just adds sycophancy, and sycophancy is the loudest AI tell there is.

Engineer burstiness. Humans write sentences of wildly uneven length. Seven words. Then a twenty-three word sentence that develops one specific idea with a clause that earns its place. Then four. LLMs default to flat, uniform sentence length, and that's what detectors key on (Category 04). Vary it and half the AI tell disappears on its own.

AI detectors — the honest version

The academic consensus across Categories 05, 15, 16, and 18: the detection arms race is structurally unwinnable for detectors. Adversarial Paraphrasing (NeurIPS 2025) drops every tested detector's TPR by ~87 %. DIPPER did roughly the same thing in 2023. Detectors also have a huge false-positive problem on non-native English writers (Liang et al. Patterns 2023: >50 % of TOEFL essays flagged as AI). A flagged score means less than marketing pages suggest.

What I found running the TMR AI-text detector (99.28 % AUROC on RAID, 125 M-param RoBERTa) against the unslop pipeline on four AI-generated fixtures: deterministic surface rewriting — lexical + structural + contractions, every combination — moves the detector score by 0.0 to 0.2 percentage points. Scores stay pinned above p_ai = 0.98 regardless of what unslop strips. Adversarial Paraphrasing NeurIPS 2025 predicted exactly this: modern detectors fingerprint on structural signal that synonym-swap rewriting cannot move.

So unslop is a polish tool, not a detector-defeat tool. The blind LLM-judge test shows it decisively wins the "reads more human" comparison (100 %, 21/21). It doesn't fool GPTZero. Two different jobs.

What actually lowers detector scores, ordered by strength:

1. Paraphrase through a different model family. If GPT wrote it, have Claude rewrite. Or Gemini. Different stylometric fingerprints. The single strongest lever, and unslop cannot do it alone. TempParaphraser (EMNLP 2025) reports an 82.5 % average reduction in detector accuracy. When the --detector-feedback ladder exhausts, the CLI prints this recommendation explicitly.
2. Burstiness. Span sentence lengths roughly 4 to 35 words inside a paragraph. Phase 1 structural does this when material exists.
3. Specificity the model can't fake. Real dates, real project names, real numbers, first-person anecdotes. Training data doesn't contain your specifics.
4. Contractions and small fragments. "don't", "won't", the occasional start with "And" or "But". Phase 5 soul does the contraction half.
5. Break predictable structure. If every bullet has the same shape (verb + metric + with + tool), vary half of them.
6. One or two rough edges. A slightly awkward phrasing, a parenthetical trail, a non-linear logical jump — all read human.

Commercial humanizer SaaS (Undetectable.ai, StealthGPT, WriteHuman, HIX Bypass, Ryter Pro, Walter Writes AI, GPTHuman.ai — the ~150 products Category 18 audits) mostly don't beat a second pass through a different model plus five minutes of manual editing. Independent audits (DAMAGE COLING 2025 — 19 tools; HumanizerBench — twelve-tool panel; Epaphras & Mtenzi 2026; Turnitin's August 2025 anti-humanizer update) show wide gaps between "99.8 % undetectable" marketing and reality. Jabarian & Imas (Booth 2025) tested StealthGPT only — GPTZero FNR hit 44–77% on humanized text in that study while Pangram stayed near 0–5%.

The right comparison isn't another SaaS. It's Anthropic Custom Styles (shipped November 2025 in Claude.ai) and OpenAI's style-steering prompt patterns — first-party style control from the model vendor, targeted at the same job. unslop is complementary: Custom Styles at generation time, the deterministic + LLM rewriting in this package after generation. The ICLR 2026 Antislop paper formalizes this split as "auto-antislop".

Resume playbook

The canonical case. Full stack in order:

1. Start with raw facts. Before touching an LLM, jot the bullets as notes. What you did, what changed, what the number was. No prose yet.
2. Use the LLM for structure, not voice. Ask it which accomplishment matters most, what's missing, how to order bullets. Don't let it write the final language.
3. Write the bullets yourself. Fast. One pass. Short. Specific numbers. Real tool names. The roughness of your first draft is the feature.
4. Polish grammar only. Tell the model: "fix typos and grammar, don't change word choice, don't smooth the voice, don't add adverbs." It will try to misbehave. Be strict.
5. Vary bullet shapes. Don't let every bullet read "Verb + metric + by using + tool". Some start with context, some with outcome, some with the action.
6. Top summary in your real voice. Not "Results-driven professional with a passion for". Something like: "Backend engineer. Ten years in payments. I like the unsexy systems work nobody volunteers for."
7. Human-read, not detector-read. If a friend says "yeah, that sounds like you", you're done. Detector scores are noisy and change weekly.
8. Optional paranoia pass. If the ATS is known to run detectors, paraphrase once through a different model family, then manually restore any bullet where the paraphrase killed a specific number or tool name. Never trust a paraphrase blind.

Persona drift over long sessions

RMTBench and HorizonBench (arXiv 2604.17283, April 2026) measure >30 % persona-consistency degradation after roughly 8–12 user turns in the same session. Two layers cover this:

• hooks/unslop-mode-tracker.js tracks a per-session turn counter (~/.claude/.unslop-turn-count) and re-emits an expanded reinforcement banner at turns 8, 16, 24, 32, and every 16 thereafter. No opt-in needed; the hook handles it. hooks/unslop-activate.js resets the counter on session start so nothing persists across shells.
• For voice-match, unslop/scripts/style_memory.py stores a numeric stylometric anchor on disk. Pure numbers, no free-text preferences. The MIT/Penn State CHI 2026 paper on "sycophancy memory" links free-text preference storage to amplified sycophancy over time. The cache makes that vector physically unavailable.

The warmth-reliability warning

[!WARNING] Training (or prompting) a model to sound warmer raises its error rate 8–13 % and amplifies sycophancy (Ibrahim/Hafner/Rocher 2025, Category 07). Fluent wrongness is worse than stiff accuracy, especially on a resume where a wrong date or an inflated metric can end the interview. After humanizing anything factual, re-verify every number, date, title, and tool name against the source.

/unslop anti-detector mode

An LLM-mode procedure. Covers items 2, 4, 5 from the detector list in one pass: burstiness targeting, contraction lift, structural variance. Item 1 (different-model paraphrase) the skill cannot execute alone — you have to request it. Use this mode when the reader might pipe the text into GPTZero or Turnitin. Skip for code, legal, or anything where precision beats voice.

My own testing: deterministic rewriting moves TMR scores by ~0.0–0.2 pp. Real detector resistance needs the different-model pass that only you can orchestrate. unslop's value in anti-detector mode is doing the local burstiness / contraction / specificity work correctly so the cross-model pass has less to fix.

.
├── skills/                   # SSOT for six agent-facing skills
│   ├── unslop/               — main mode
│   ├── unslop-commit/        — commit messages
│   ├── unslop-review/        — PR comments
│   ├── unslop-help/          — reference card
│   ├── unslop-reasoning/     — reasoning-trace cleanup
│   └── unslop-file/          — generated mirror of the file rewriter
├── unslop/                   # SSOT for the file-rewriter (Python + skill)
│   └── scripts/              — humanize, validate, structural (Ph1),
│                               soul (Ph5), detector (Ph3), stylometry (Ph4)
├── rules/                    # SSOT for the short always-on activation text
├── commands/                 # Claude Code slash commands (TOML)
├── hooks/                    # SessionStart + UserPromptSubmit + statusline + installers
├── .claude-plugin/           # Claude Code marketplace + plugin manifest
├── .cursor-plugin/           # Cursor Plugin manifest
├── .cursor/                  # Cursor rules + skills (mirror)
├── .windsurf/                # Windsurf rules + skills (mirror)
├── .clinerules/              # Cline rules (mirror)
├── .agents/                  # Agents marketplace manifest
├── plugins/unslop/           # Codex plugin bundle
├── tests/                    # pytest unit tests
├── docs/research/            # optional research compendium (not part of the plugin bundle)
├── assets/                   # hero, statusline, section banners, social preview (PNG)
└── .github/workflows/        # CI + sync SSOT to mirrored locations

Source of truth: skills/unslop/SKILL.md, the other authored skills/*/SKILL.md files, rules/unslop-activate.md, unslop/SKILL.md, unslop/scripts/, and root CHANGELOG.md. The sync.yml workflow propagates their generated counterparts on push to main.

• tests/unslop/ — 639 tests collected for file-type detection; every deterministic rule family; structural rewriter (Phase 1); soul contractions (Phase 5); detector feedback loop (Phase 3); stylometry (Phase 4); humanness harness (Phase 6); preservation (code, URLs, headings, YAML, tables, blockquotes); and end-to-end round trips. Paid API and real-model tests remain opt-in.
• tests/test_hooks.py — hook installer (fresh, idempotent, preserves custom statusline), unslop-activate.js banner, unslop-mode-tracker.js slash commands + natural language + stop phrases, statusline badge output, symlink refusal, CLAUDE_CONFIG_DIR honoring.
• tests/verify_repo.py — every SSOT mirror is byte-identical after sync, JSON manifests parse, all JS / Bash / PowerShell scripts are syntax-clean, fixture pairs round-trip, plugin + marketplace manifests are wired.
• benchmarks/run.py — runs humanize_deterministic over a corpus of AI-slop markdown and reports AI-ism reduction, per-paragraph flat count, sentences split, bullet groups merged, per-file structural integrity. --strict fails the build on any regression.
• benchmarks/check_regression.py — compares latest benchmark output against a pinned post-phase*.json baseline. Fails if AI-ism reduction drops > 2 pp, flat-paragraph total rises > 2, or preservation breaks. Runs in CI on every PR.
• benchmarks/detector_bench.py — opt-in AI-detector benchmark (TMR, Desklib). Downloads HF weights on first run. Scheduled weekly via .github/workflows/weekly-detector-bench.yml.
• evals/perceived_humanness.py — blind LLM-as-judge preference harness. New runs default to Claude Sonnet 5; the published 21/21 result remains the archived Sonnet 4.5 run named above.
• evals/ — additional LLM-driven A/B harness (llm_run.py + measure.py) for snapshotting baseline vs deterministic vs LLM unslop on a fixed prompt set.