Spark
Sign In
Skill

Strip AI-isms from docs and memory files

Humanizes AI-isms out of memory files and docs while preserving every code block, URL, path, and command exactly.

Get skill
Works with anthropicclaude
MohamedAbdallah-14
Maintainer?
77
Spark score
out of 100
Updated 27 days ago
Version unslop-v0.6.2
Models
claude
Add to Favorites

Why it matters

Remove sycophantic language, stock vocabulary, and performative structure from natural-language documentation and memory files while preserving every code block, URL, path, command, and technical element exactly as written.

Outcomes

What it gets done

01

Run fast regex pass to strip canonical AI-isms like 'delve', 'tapestry', 'Great question!' without API calls

02

Call Claude LLM to rewrite prose with burstiness and natural voice while keeping all technical content intact

03

Generate audit reports showing every before-after transformation and rule-match counts

04

Validate humanized output for preservation errors and residual AI-isms with automatic retry and rollback

Install

Add it to your toolbox

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/ag-unslop-file | bash

Overview

Unslop Humanize

This skill rewrites natural-language memory files and docs to strip AI-isms (sycophancy, hedging, stock vocabulary, signposting, tricolons) via a fast regex pass or an LLM rewrite, while preserving every code block, URL, path, command, and structural element exactly. Use it to de-slop a markdown or plain-text memory/doc file - it refuses non-prose files, sensitive paths, and files over 500 KB, and never modifies code regions.

What it does

Rewrites natural-language memory files (CLAUDE.md, AGENTS.md, todos, preferences, docs) so they sound human-written - stripping AI-isms and adding burstiness - while preserving every code block, URL, path, command, and heading exactly.

Two modes: --deterministic (a fast regex pass stripping canonical AI-isms and tightening tricolons, no API call or ANTHROPIC_API_KEY needed, best for batch processing and CI), and LLM mode (the default, calling Claude via the Anthropic SDK or a claude --print CLI fallback for a full rewrite that engineers burstiness and restructures performative paragraphs - slower but higher quality). Three intensity levels via --mode: subtle (stock vocabulary only), balanced (the default - sycophancy, hedging, transitions, stock vocab, authority tropes, signposting, performative balance, and an em-dash cap), and full (balanced plus filler-phrase replacement and negative-parallelism tricolon stripping, for marketing copy or slop-heavy LLM output).

humanize --deterministic --report audit.json doc.md     # writes audit + humanized
humanize doc.md                                         # optional LLM polish on top

A two-pass audit runs the deterministic pass first for a report (audit.json lists every rule that fired, each before/after pair, and counts by rule), then optionally an LLM polish on top - useful for reviewing exactly what the regex changed before trusting the diff. A FILE.original.md backup is always written before the original is overwritten; re-running after editing the backup regenerates the humanized version.

Removed categories include sycophancy openers ("Great question!", "Certainly!"), stock vocabulary (delve, tapestry, leverage as a filler verb, robust, seamless, cutting-edge, and similar), hedging openers ("It's important to note that", "Generally speaking"), authority tropes ("At its core,", "Fundamentally,"), signposting announcements ("Let's dive in", "Here's what you need to know"), transition tics ("Furthermore,", "Moreover,"), performative balance (a reflexive "however" appended to every claim), and em-dash pileups (more than two per paragraph); --mode full additionally strips filler phrases ("in order to" to "to", "due to the fact that" to "because") and negative-parallelism tricolons ("No guesswork, no bloat, no surprises."). Tightening rules collapse unnecessary three-item lists to two, merge repetitive bullet soup into one sentence, and vary paragraph length to avoid a mechanical five-paragraph-essay shape.

What's preserved exactly (byte-for-byte): fenced and indented code blocks, inline code, URLs and markdown links, file paths, shell commands, technical terms/proper nouns/API names, dates/version numbers/numerics, and environment variables - plus structural elements like headings, bullet/numbered-list hierarchy, tables (cells compressed but structure kept), and YAML frontmatter. The critical rule: everything inside a fenced or inline code region is strictly read-only - no comment edits, whitespace changes, or line reordering; humanization only touches the prose between code regions.

Processing steps: locate the SKILL.md's adjacent scripts/ directory, run python3 -m scripts <absolute_filepath> (add --deterministic for the regex-only pass), detect file type, write the .original.md backup, humanize, validate (a preserve check plus an AI-ism residual check), retry with a targeted LLM fix call up to twice on validation failure, then report success (humanized file path plus backup path) or restore the original and exit with an error on final failure.

When to use - and when NOT to

Use it to de-slop a natural-language memory or documentation file while guaranteeing every code block, path, command, and structural element survives untouched. It only operates on .md/.txt/.markdown/.rst/extensionless prose files - never on .py/.js/.json/.yaml/.env/etc. or an already-processed *.original.md file, and it refuses sensitive paths (.env*, *.pem, *.key, ~/.ssh/, ~/.aws/) and files over 500 KB before any read or API call.

Inputs and outputs

Input is a filepath to a natural-language file, plus optional --deterministic and --mode flags. Output is the humanized file (overwriting the original), an .original.md backup, and, in deterministic-report mode, an audit.json listing every rule fired with before/after pairs and counts.

Integrations

LLM mode calls Claude via the Anthropic SDK or a claude --print CLI fallback; its AI-ism vocabulary was cross-referenced against blader/unslop's skill listing and Wikipedia's "Signs of AI writing" taxonomy, with a full comparison in docs/research/IMPLEMENTATION_TRACE.md.

Who it's for

Teams maintaining CLAUDE.md-style memory files or documentation who want AI-generated tone stripped out automatically, with a guarantee that code, commands, paths, and structure are never touched in the process.

Source README

Unslop Humanize

When to Use

Use this skill when you need humanize natural-language memory files (CLAUDE.md, todos, preferences, docs) by removing AI-isms and adding burstiness while preserving every code block, URL, path, command, and heading exactly. Two modes: --deterministic (fast, regex-based, no API) and LLM (default, calls Claude for...

Purpose

Rewrite natural-language memory files (CLAUDE.md, AGENTS.md, todos, preferences, docs) so they sound human-written: no sycophancy, no stock vocab, no five-paragraph essay shape, no tricolon padding. Everything technical stays exact: code blocks, inline code, URLs, file paths, commands, headings, tables.

Two modes:

  • --deterministic - fast regex pass that strips canonical AI-isms and tightens tricolons. No API call, no ANTHROPIC_API_KEY needed. Best for batch processing and CI.
  • LLM mode (default) - calls Claude (via Anthropic SDK or claude --print CLI fallback) to do a full rewrite that engineers burstiness, restructures performative paragraphs, and matches voice. Slower but better quality.

Humanized version overwrites the original. A FILE.original.md backup is written first. Re-run after editing the .original.md to regenerate.

Intensity levels (--mode)

Mode What runs Use when…
subtle Stock vocab only. Structure is fine; you just want AI vocabulary gone.
balanced (Default.) Sycophancy, hedging, transitions, stock vocab, authority tropes, signposting, performative balance, em-dash cap. Everyday docs / READMEs / CLAUDE.md.
full Balanced + filler phrases + negative-parallelism tricolons + stronger LLM prompt. Marketing copy, release notes, slop-heavy LLM output.

Two-pass audit

Use the deterministic pass to get a report, then fix anything that slipped:

humanize --deterministic --report audit.json doc.md     # writes audit + humanized
humanize doc.md                                         # optional LLM polish on top

audit.json lists every rule that fired, every before → after pair, and counts_by_rule. Great for reviewing what the regex changed before trusting the diff to merge.

Trigger

/unslop-file <filepath>, /unslop:humanize <filepath>, or "humanize memory file", "de-slop this doc", "strip AI tone from this file".

Process

The scripts live in a scripts/ directory adjacent to this SKILL.md.

Common layouts:

  • Full repo: unslop/SKILL.md + unslop/scripts/
  • Synced mirror: skills/unslop-file/SKILL.md + skills/unslop-file/scripts/
  • Codex bundle: plugins/unslop/skills/unslop-file/SKILL.md + sibling scripts/

Always prefer the scripts/ sibling of the currently loaded SKILL file.

Steps:

  1. Locate the directory containing this SKILL.md and its scripts/ sibling.
  2. Run from that directory: python3 -m scripts <absolute_filepath> (LLM mode), or add --deterministic for the regex pass.
  3. CLI flow: detect file type → write .original.md backup → humanize → validate (preserve check + AI-ism residual check) → on validation error: targeted fix call (LLM mode) → retry up to 2 times.
  4. On final failure: report errors, restore original, exit 2.
  5. On success: report path of humanized file and .original.md backup, exit 0.
  6. Return result to user.

Humanization Rules

Remove (canonical AI-isms)

  • Sycophancy openers: "Great question!", "Certainly!", "Absolutely!", "Sure!", "I'd be happy to help", "What a fascinating..."
  • Stock vocab: delve, tapestry, testament (praise form), navigate/embark/journey (figurative), realm, landscape (figurative), pivotal, paramount, seamless, holistic, leverage (filler verb), robust (filler), comprehensive (when "complete" works), cutting-edge, state-of-the-art (filler), interplay, intricate, vibrant, underscore(s)/d/ing (figurative), crucial, vital (role/importance/part), ever-evolving, ever-changing, in today's (digital) world/age, dynamic landscape.
  • Hedging openers: "It's important to note that", "It's worth mentioning", "Generally speaking", "In essence", "At its core", "It should be noted that", "It's also worth pointing out".
  • Authority tropes (sentence start): "At its core,", "In reality,", "Fundamentally,", "What really matters is", "The heart of the matter is", "At the heart of X is/lies".
  • Signposting announcements: "Let's dive in(to ...)", "Let's break this down", "Here's what you need to know", "Without further ado", "In this article, I'll ...", "Buckle up".
  • Transition tics (sentence start): "Furthermore,", "Moreover,", "Additionally,", "In conclusion,", "To summarize,".
  • Performative balance: "however" / "on the other hand" appended to every claim.
  • Em-dash pileups (more than two em-dashes per paragraph).
  • Filler phrases (--mode full only): "in order to" → "to", "due to the fact that" → "because", "prior to" → "before", "with regard to" → "about", "a wide variety of" → "many", "at this point in time" → "now", "the fact that" → "that", etc.
  • Negative-parallelism tricolons (--mode full only): "No guesswork, no bloat, no surprises." - the rhetorical triple-no punch.

Tighten

  • Tricolons: "X, Y, and Z" stacks where two would suffice - keep two, drop the weakest
  • Bullet soup: three bullets that say the same thing → merge into one sentence
  • Five-paragraph essay shapes: vary paragraph length; don't write four paragraphs of identical length

Preserve EXACTLY (never modify)

  • Fenced code blocks (...) - every byte
  • Indented code blocks (4-space)
  • Inline code (...)
  • URLs and markdown links
  • File paths (./src/, /etc/, C:\Users\...)
  • Commands (npm install, git rebase, docker run)
  • Technical terms, proper nouns, API names
  • Dates, version numbers, numerics
  • Environment variables ($HOME, ${NODE_ENV})

Preserve structure

  • All markdown headings (text exact)
  • Bullet hierarchy and nesting
  • Numbered lists
  • Tables (compress cells; keep structure)
  • YAML frontmatter

CRITICAL RULE

Everything inside ``` ... ``` is read-only. No comment changes, no whitespace changes, no line reordering. Inline backticks: same. Code is the substrate; humanization only operates on prose between code regions.

Pattern (before → after)

# Before After (deterministic, --mode balanced)
1 It's important to note that running tests prior to pushing changes is a comprehensive best practice. Additionally, it's worth mentioning that this can prevent broken builds. Running tests before pushing changes is a broad best practice. This can prevent broken builds.
2 The application leverages a microservices architecture that comprises multiple discrete components. The application uses a microservices architecture that comprises multiple discrete components.
3 At its core, caching trades memory for latency. Caching trades memory for latency.
4 Let's dive in. Here is the first step. Here is the first step.
5 The intricate interplay between caching and latency is crucial. The detailed link between caching and latency is important.
6 In today's digital world, we ship fast. Today, we ship fast.

At --mode full, additionally:

# Before After
7 We ran the tests in order to verify the fix. We ran the tests to verify the fix.
8 The build failed due to the fact that the disk was full. The build failed because the disk was full.
9 No guesswork, no bloat, no surprises. (stripped)

Reference

  • blader/unslop - Claude-Code skill listing 30+ AI tells; we incorporated the strongest signals.
  • Wikipedia: Signs of AI writing - public taxonomy cross-referenced for vocab.
  • Full comparison + gap analysis: docs/research/IMPLEMENTATION_TRACE.md.

Boundaries

  • Only operate on .md, .txt, .markdown, .rst, or extensionless natural language.
  • Never modify .py, .js, .ts, .json, .yaml, .yml, .toml, .env, .lock, .css, .html, .xml, .sql, .sh.
  • Mixed prose-and-code files: humanize only the prose; leave fenced code untouched.
  • If unsure whether a file is prose or code: leave unchanged.
  • Backup FILE.original.md is written before overwrite. Never humanize a file already named *.original.md.
  • Sensitive paths (anything matching .env*, *.pem, *.key, ~/.ssh/, ~/.aws/, etc.) are refused before any read or API call.
  • Files larger than 500 KB are refused.

Limitations

  • Use this skill only when the task clearly matches its upstream source and local project context.
  • Verify commands, generated code, dependencies, credentials, and external service behavior before applying changes.
  • Do not treat examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.