My Stop Slop: How I Use Claude Code Agent Skills to Prevent AI Slop in Design and Code

If you searched for a “stop slop skill” you want one concrete thing: a way to strip the AI tells out of your writing before anyone reads it. That’s exactly what I built. Stop Slop is a Claude Code Agent Skill, a small instruction file the model loads on demand, and it runs every line of copy, button label, error message, and docstring I ship through one ruthless filter. The cold first draft of any LLM is a smooth, confident, context-free paragraph that reads like a LinkedIn post written by someone who’s never met you.

Round phrasing, fragment drama, “let me be clear” openers, and a closing line that could apply to any topic on the internet. Designers hit the same wall when they ask a model to generate a hero section: gradient mesh, three pricing cards, “elevate your workflow”, and a CTA button that says “Get Started” ¹1. The biggest content AI slop. × in violet-500. The fix takes about ten minutes to set up and pays for itself the first time you ship a UI. I keep a small toolkit of these skills open at all times, and the one called Stop Slop is the spine.

What AI Slop Actually Looks Like

Before you can fight slop, you have to recognise it. Slop is not bad writing in the literary sense. It’s predictable writing. A reader feels it within two sentences. Search engines and AI rankers feel it too. Google’s Helpful Content signals, ChatGPT’s preference data, and Anthropic’s Claude RLHF data all penalise the same patterns. A September 2025 research paper, “Measuring AI Slop in Text”, put numbers behind the gut feeling: it found slop correlates with low information density, overuse of a small set of terms, and structural quirks like lists-as-answers.

These are the surface-level tells that show up in almost every untreated LLM output:

• Throat-clearing openers. “Here’s the thing:”, “The uncomfortable truth is:”, “Let me be clear:”, “It turns out”. Add nothing, push the real sentence one beat back.
• Binary contrasts. “Not because X. Because Y.” “It feels like X. It’s actually Y.” Telegraphed reversals that announce a reframe instead of doing one.
• Dramatic fragmentation. “Three words. That’s it. That’s the product.” Performative simplicity.
• Cadence uniformity. The 2026 tell that survives longest. Eighteen-to-twenty-four-word sentences, one after another, with the same shape and the same rhythm. Vocabulary tells fade as models update; this one persists across prompt rewrites.
• Em-dash drama (fading, not gone). The em-dash itself isn’t bad. LLMs used it as a setup-and-payoff crutch on every third sentence. Newer models suppress it by default now, so its absence no longer proves a human wrote the text.
• Filler adverbs. “Importantly,”, “Crucially,”, “Interestingly,”, “At its core,”. Words that announce significance instead of demonstrating it.
• Significance inflation. Words like testament, pivotal, transformative, paradigm-shifting. They flatten meaning and make every sentence sound like a TED-talk pull-quote.
• Synonym cycling. Calling the same noun three different things in three sentences (“the platform”, “the tool”, “the system”) because the model wants to avoid repetition. Repetition is fine. Choose one term and stick with it.
• -ing gerund clusters. highlighting, showcasing, fostering, leveraging, ensuring. Vague verbs that do no work.
• Generic optimistic closings. The last paragraph that could be pasted on any article on any topic and still half-fit.

Once you see the list, you can’t unsee it. Most LLM-generated copy on the internet contains six of these in its first paragraph.

How to Spot Slop Fast: Detection Signals

The nine tells above are the what. Here’s the how, the quick read I run on any block of text before I trust it. None of these needs a detector tool, and none of them is a single smoking gun. You’re looking for a stack of signals, not one.

• Read three sentences in a row out loud. If they’re all roughly the same length and breathe the same way, that’s cadence uniformity. Real writers vary. A four-word sentence next to a thirty-word one is a human fingerprint.
• Cut the first sentence of every paragraph. If the paragraph still says everything it needed to, the opener was throat-clearing. Slop front-loads warm-up; humans front-load the point.
• Count the claims with a number, name, or date. Low information density is the most reliable slop signal in the 2025 research. A paragraph that asserts a lot and specifies nothing is almost always untreated AI output.
• Look for the “from X to Y” sweep. “From startups to enterprises”, “whether you’re a beginner or a pro”. False comprehensiveness that adds words and removes meaning.
• Check the last paragraph against the topic. If you could paste that closing onto an unrelated article and it would still half-fit, it’s a generic optimistic closing. Delete it.
• Don’t trust the em-dash test anymore. Through 2024 a wall of em-dashes flagged AI writing. Newer models suppress them, so their presence or absence proves nothing in 2026. Judge rhythm and density instead.

Automated detectors exist, but I treat them as a tiebreaker, not a verdict. They throw false positives on clean human prose and false negatives on lightly-edited AI text. The signals above are faster and harder to game because they target structure, not surface vocabulary.

What an Agent Skill Is, In Plain Terms

Claude Code Agent Skills are markdown files Anthropic introduced in October 2025 to let Claude load a specialised instruction set on demand. Each skill is a folder with a SKILL.md and optional reference files. When the model detects a relevant prompt, it pulls the skill’s rules into context and applies them. The design principle is progressive disclosure: the model reads only the part of the skill it needs, so the rules don’t eat your context window.

The mental model is simple. A skill is a job description handed to the model along with the task. “Write the error message” is a task. “Write the error message according to the rules in clarify/SKILL.md” is a task with an opinion attached. The opinion is what stops the model from defaulting to “An unexpected error has occurred. Please try again later.”

I’ve published my Stop Slop skill alongside the rest of my Claude Code toolkit in the claude-code-skills repository. It’s MIT-licensed. You can install it once and it works against any prose Claude generates inside Claude Code, the API, or any compatible runner. As of Claude Code v2.1.101 (11 April 2026), custom slash commands and skills are the same mechanism, so a skill named stop-slop is also the /stop-slop command.

The Stop Slop Skill: Five Core Rules

The whole skill is short on purpose. A skill that takes more than five minutes to read isn’t a skill, it’s a manual.

Rule 1: Cut filler phrases. A banned-list of throat-clearing openers, emphasis crutches, and business jargon. The skill ships with a references/phrases.md file that catalogues over a hundred specific tokens and their plain-language replacements. “Navigate (challenges)” becomes “handle”. “Game-changer” becomes “significant”. “At the end of the day” gets cut entirely.

Rule 2: Break formulaic structures. A taxonomy of structural patterns to avoid: binary contrasts, dramatic fragmentation, rhetorical setups, false comprehensiveness (“from X to Y”, “whether A or B”). The reference file in references/structures.md shows the pattern, names why it fails, and gives a direct rewrite.

Rule 3: Vary rhythm. Mix sentence lengths. Two items beat three. End paragraphs differently. Three consecutive sentences that match length get one rewritten. This rule does the heavy lifting against cadence uniformity, which is the single hardest tell to remove by hand.

Rule 4: Trust readers. State facts directly. Skip softening, justification, and hand-holding. The first draft of any LLM contains five caveats per claim. Stop Slop tells the model to delete four of them.

Rule 5: Cut quotables. If a sentence sounds like a pull-quote, rewrite it. The instinct that produces “this isn’t a feature, it’s a philosophy” is the same instinct that produces slop.

The skill closes with a self-audit pass. After the first edit, it asks Claude to read its own output and answer: “What makes this obviously AI-generated?” Then a 1-to-10 scoring grid across five dimensions: directness, rhythm, trust, authenticity, density. Below 35/50, it revises again.

A Worked Example, Before and After

Here’s a button-state copy block from a SaaS pricing component, generated cold by a frontier LLM and then run through the Stop Slop skill.

Before (cold output):

Unlock the full power of our platform with our Pro plan. It’s a game-changer for teams looking to navigate the complexities of modern collaboration. Whether you’re a solo founder or a growing organisation, this tier delivers everything you need to take your workflow to the next level.

After (Stop Slop pass):

Pro: 10 seats, unlimited projects, priority support. $29 per seat per month.

The cold output is 47 words and zero information. The post-skill version is 12 words and answers every question a buyer has at the moment they’re looking at a pricing card. Same model, same prompt, different opinion attached. The before hits four tells at once: “unlock the full power” (significance inflation), “game-changer” (jargon), “navigate the complexities” (gerund filler), “whether you’re X or Y” (false comprehensiveness). The after hits zero.

One more, this time prose. Cold: “In today’s fast-paced digital landscape, leveraging AI can be a transformative way to elevate your content strategy and unlock new levels of engagement.” That’s 25 words and one idea: AI helps content. Stop Slop version: “AI drafts faster than you do. That’s the whole pitch. The editing is still your job.” Three sentences, three lengths, one concrete claim, and a stance the reader can argue with.

The Bigger Toolkit: Skills That Fight Slop in Adjacent Jobs

Stop Slop handles the prose layer. The rest of the toolkit handles design, code, and UX-copy slop, which has its own visual and functional patterns. Here’s the lineup I keep open.

Red Pen

The red-pen skill, originally from Rich Tabor, is the editorial sibling to Stop Slop. Where Stop Slop is preventive (it tells the model what not to do), red-pen is corrective (it scans existing prose and flags violations). It enforces principles drawn from George Orwell’s Politics and the English Language and Matthew Butterick’s Practical Typography. I run it against any block of marketing copy, technical documentation, or in-product microcopy that I didn’t generate myself. It returns line-by-line edits with a justification per change.

Clarify

The clarify skill is for UX writing specifically: button labels, error messages, form helper text, empty-state copy, onboarding tooltips, table column headers. It enforces three rules. Tell the user what just happened. Tell the user what they can do next. Cut everything else. “An unexpected error has occurred” becomes “We couldn’t save your changes. Try again, or copy your work and refresh.” Same information, ten times more useful.

Distill

The distill skill is a design skill with the same philosophy applied to layout. It strips a hero section, a pricing card, or a feature grid down to its essential elements and asks whether each addition earns its place. The default mode of an LLM doing UI is to add. Distill makes it subtract. Useful before any “ship” decision on a page that started life as a Figma comp generated by an AI tool.

Quieter

The quieter skill is a counterweight. When a design comes back too loud (gradient overload, screaming CTAs, pulsing animations on every card), quieter tones it down without flattening it. Reduces saturation, loosens spacing, drops a font weight. The output reads like a senior designer’s edit pass, not a beginner’s “make it less ugly” reflex.

Polish

The polish skill is the final quality pass before any UI ships. Catches inconsistent spacing, off-by-one alignment, mismatched border radii, missing hover states, and the dozen other small visual bugs that separate “looks AI-generated” from “looks like someone shipped it on purpose”. Polish is the difference between a portfolio piece and a production component.

Harden

The harden skill is for development work specifically. Tells the model to handle edge cases the cold output skipped: long text overflow, RTL layouts, missing data, slow networks, error states, accessibility for keyboard and screen readers. Cold AI code passes the happy path. Harden makes it pass everything else.

Copy Editing

A private skill I keep for any text I receive from outside sources, like a client’s existing marketing copy, a third-party tool’s product page, or a homepage that needs a refresh. It applies the Stop Slop rules in review mode rather than draft mode. Returns a marked-up version with line-level comments and a summary of the most common slop patterns it found.

Where I Actually Use These Skills

Concrete list, no fluff. Every one of these gets a Stop Slop or sibling-skill pass before it leaves my workstation.

• Component microcopy in design-system documentation. Button states, tooltip text, form validation messages, accessibility labels.
• Error messages across the WordPress plugins I ship. Every WP_Error instance, every admin notice, every Settings API description.
• README files for open-source repositories. For example, the README for GT AI Provider for OpenAI went through three Stop Slop passes before the first commit. The previous draft contained the phrase “leverages cutting-edge AI capabilities”. That’s gone now.
• Inline code documentation. Function-level docblocks, class-level descriptions, plugin headers. The naming and the description must read as if a senior engineer wrote them by hand.
• Marketing copy for the products I build. Pricing-page bullets, feature-card descriptions, FAQ answers, hero-section subheadings. Every word earns its slot or it gets cut.
• Design system tokens. The names of color tokens, spacing tokens, font scales. --color-base-50 not --color-snowy-meadow-whisper.
• CTA buttons. “Try Pro free for 14 days” not “Unlock the full experience”. “Save changes” not “Confirm and proceed”. Specific verbs, specific outcomes.
• Modal copy. Title, body, and the two buttons. Most modals get a 50% word-count reduction after a clarify + Stop Slop pass.
• Email subject lines. No question-mark hooks, no “URGENT” caps, no “you won’t believe”. Just the actual subject of the email.
• Onboarding flows. Empty states, first-run tooltips, success messages. Every screen the user sees during their first ten minutes with a product runs through clarify before it ships.

A side benefit nobody talks about: the skill set teaches the operator. After three months of running prose, design specs, and UI copy through these skills, the patterns get internalised. I now spot my own slop before I generate it. The skill becomes a coach, not just a filter.

The Slop Checklist I Run Before I Ship

If you don’t want to install anything yet, run this by hand. It’s the same logic the skill enforces, compressed into eight checks. Anything that fails gets rewritten, not patched.

1. Does the first sentence carry information, or is it a warm-up? Cut warm-ups.
2. Are three consecutive sentences the same length? Rewrite one to break the cadence.
3. Is there a number, name, or date the reader can verify? If not, the paragraph is probably empty.
4. Did I write “leverage”, “elevate”, “unlock”, “navigate”, “robust”, “seamless”, “transformative”? Replace each with a plain verb or cut it.
5. Is there a “from X to Y” or “whether A or B” sweep? Collapse it to the one case that matters.
6. Does any sentence sound like a pull-quote? Rewrite it as a plain statement.
7. Could the closing paragraph be pasted onto a different article? Then it says nothing. Cut or replace it.
8. Read the whole thing aloud. Where you stumble or get bored is where the slop lives.

How to Install Stop Slop

Three steps. Five minutes total.

1. Clone the claude-code-skills repository and either symlink the stop-slop/ folder into your Claude Code skills directory at ~/.claude/skills/stop-slop, or copy it across.
2. Restart Claude Code or open a new session. Claude auto-discovers skills in the standard directory.
3. When you want it to fire, invoke it via the slash command /stop-slop followed by the prose you want cleaned, or just trigger it implicitly by asking for “slop-free copy”. Since Claude Code v2.1.101, skills and slash commands are unified, so the folder name stop-slop is the command.

The skill is portable across any Claude runner that supports skills. I run it locally inside Claude Code on macOS, on the Anthropic API directly via the SDK, and inside the Claude Agent SDK for one of my internal tools that pre-processes contractor copy before it touches my repository. On current models like Claude Opus 4.8, the cold output is already cleaner than it was a year ago, but the structural tells still need the skill to catch them.

What Stop Slop Doesn’t Do

The skill is opinionated. It will not turn a cold model into a great writer. It removes the obvious tells and restores rhythm, but voice has to come from somewhere. For my own copy, I pair Stop Slop with a separate voice-DNA skill that contains my specific cadence preferences, banned brand words, and tone calibration. Without a voice file, Stop Slop produces clean, professional, slightly bland prose. With one, it produces clean prose that sounds like a person.

A few other things worth knowing.

• It does not fact-check. GPT-5.5 shipped a 1M-token API context window in April 2026, but if a cold draft of yours says it’s 200K, Stop Slop won’t catch the error. Run a separate verification pass for technical claims.
• It does not handle long-form structure. A 5,000-word piece needs an outline pass before the prose pass. Stop Slop edits sentence by sentence and paragraph by paragraph; structural slop sits one level above that.
• It does not replace editing by a human reader. It replaces the first hour of editing by a human reader. The last twenty minutes still happen.

The Mindset Shift

The thing I didn’t expect when I built Stop Slop is how much it changed the way I write before I open any AI tool. The skill is a list of rules. The longer you live with the list, the more the rules become reflexes. I now write a button label and immediately ask whether it survives Rule 4 (trust the reader) before I ship it. I write an error message and instinctively check whether it’s a Rule 1 violation (filler).

That’s the real value. The skill is an external checklist that becomes an internal one. Three months in, the checklist runs in your head before any AI tool sees the prompt. Six months in, you stop generating slop in the first place because the patterns have been trained out of your hands.

The toolkit is open-source. The lessons compound. And the gap between AI-generated content that ships and AI-generated content that gets caught is exactly the size of one short skill file.

Frequently Asked Questions