How to Stop AI Slop: Make Your Local LLM Sound Human with Anti-Slop Skills

Every self-hosted AI user has felt it. You ask your local model to draft an email, write a blog post, or compose a status update — and what comes back is unmistakably AI. The throat-clearing openers ("In today's rapidly evolving landscape…"), the redundant signposting ("It is worth noting that…"), the lifeless cadence of a language model that learned fluency without authenticity.

The community has a name for this: **slop**. And two open-source projects are trending hard this week as the antidote.

**stop-slop** (7,300+ stars) and **taste-skill** (29,000+ stars) are skill files — portable instruction sets — that teach AI agents to recognise and eliminate the telltale patterns of machine-generated writing. They work with any LLM, and they are perfect for self-hosted setups.

What is slop and why does it matter for local AI

```

Before: "In today's fast-paced digital landscape, it is crucial to leverage cutting-edge AI

solutions to optimise workflows and unlock transformative value."

After: "Here is what running local models teaches you: every model has a tell."

```

Slop is not just bad writing. It is a trust problem. If your local AI writes content that reads like a press release, people stop reading. For self-hosted users who deploy AI for business communications, blog content, or team updates, output quality directly determines whether the investment pays off.

The good news is that the fix does not require fine-tuning, larger models, or cloud APIs. It is a prompt-level intervention — and the community has already done the hard work of cataloguing every AI tell worth removing.

Understanding the two anti-slop tools

stop-slop

Created by Hardik Pandya, **stop-slop** is a structured skill file (MIT license) that identifies and removes three categories of AI tells from prose:

**Banned phrases:** Throat-clearing openers ("In an era of…", "When it comes to…"), emphasis crutches ("arguably", "truly", "essentially"), business jargon ("leverage", "synergy", "circle back"), all adverbs except where structurally necessary, vague declaratives ("It is important to…"), and meta-commentary ("As an AI language model…").

**Structural clichés:** Binary contrasts ("On one hand… on the other…"), negative listings ("Not X, not Y, not Z…"), dramatic fragmentation, rhetorical setups ("Have you ever wondered…?"), false agency ("This guide will help you…"), narrator-from-a-distance voice, and passive voice.

**Sentence-level rules:** No Wh- sentence starters, no em dashes used as crutches, no staccato fragmentation, no lazy extremes (no "game-changing," "revolutionary," "groundbreaking"), and active voice required.

The skill includes a scoring rubric that rates output 1-10 across five dimensions (directness, rhythm, trust, authenticity, density) — anything below 35/50 needs revision.

taste-skill

Created by Leon Lin, **taste-skill** takes a different angle. Instead of just stripping AI tells, it teaches agents to build interfaces and write output with genuine design sense. While originally focused on UI generation for coding agents (Codex, Cursor, Claude Code), its core principles apply to any AI output — layout, typography, motion, spacing, and the subtle judgment calls that separate professional work from boilerplate.

The skill file includes reference boards, image-generation prompts for mockups, and a detailed settings framework that controls everything from spacing density to colour palette restraint. It is particularly useful for self-hosted users running coding agents that build front-end interfaces.

How to apply anti-slop skills to your local LLM

The beauty of skill files is that they are model-agnostic. You can apply them whether you run Llama 3, Qwen 2.5, Mistral, DeepSeek, or any other local model.

Option 1: Load the skill into your agent

If you use a skill-aware agent (Claude Code, Codex, Hermes Agent, Cursor):

```bash

Clone the repos

git clone https://github.com/hardikpandya/stop-slop

git clone https://github.com/Leonxlnx/taste-skill

Then in your agent, load the skill

For Hermes Agent:

hermes -s ./stop-slop/SKILL.md -s ./taste-skill/skills/main.md

```

Option 2: Add to your custom agent's system prompt

For any LLM accessed via API (OpenAI-compatible local server, Ollama, vLLM, llama.cpp), prepend the skill instructions to your system prompt:

```python

import requests

Load the core rules from SKILL.md

with open("stop-slop/SKILL.md") as f:

anti_slop_rules = f.read()

system_prompt = f"""You are a helpful assistant. Follow these writing rules:

{anti_slop_rules}

Convey information directly. Remove AI tells. Write like a human expert, not a chatbot."""

Send to your local model

response = requests.post(

"http://localhost:11434/api/chat",

json={

"model": "llama3",

"messages": [

{"role": "system", "content": system_prompt},

{"role": "user", "content": "Draft a professional email about project delays"}

]

}

)

```

Option 3: Use as post-processing filter

If you cannot modify the system prompt (for example, when using Open WebUI or a shared API), apply the rules as a post-processing step:

```python

After getting the response

raw_output = response.json()["message"]["content"]

Add a second LLM call that reviews the output against the stop-slop rules

review_prompt = f"""Review this text against stop-slop rules. Score each dimension 1-10.

Rules:

• No throat-clearing openers
• No emphasis crutches (arguably, truly, essentially)
• No business jargon
• Active voice required
• No Wh- sentence starters

Text to review:

{raw_output}

Return only a revised version that fixes all issues."""

```

Option 4: Integrate with n8n for automated content pipelines

For self-hosted AI workflows that produce content at scale, add a stop-slop review step to your n8n pipeline. After the LLM node generates text, route it through a second LLM call with the anti-slop rules as context. See Content Publishing Pipeline with n8n for Small Teams for the full workflow pattern.

Customising the rules for your voice

The stock stop-slop rules are a strong baseline, but every writer has their own voice. Here is how to adapt them for your use case:

Add your personal banned list

Every writer has tics. Maybe you overuse "essentially" or lean on "importantly" as a crutch. Add them to a personal ban list:

```

My personal banned words

• obviously
• clearly
• simply
• essentially
• fundamentally

```

Adjust the scoring thresholds

The standard 35/50 pass mark works for general prose, but you may want stricter thresholds for formal writing or looser ones for informal team updates. The scoring dimensions are:

| Dimension | What it measures | Target |

|-----------|-----------------|--------|

| Directness | Statements vs announcements | 8+ |

| Rhythm | Varied or metronomic | 7+ |

| Trust | Respects reader intelligence | 8+ |

| Authenticity | Sounds human | 8+ |

| Density | Nothing cuttable | 7+ |

Combine with voice-style prompts

For the best results, pair anti-slop rules with voice samples of your own writing. The approach described in Build a Local AI Writing Assistant That Respects Your Voice — collecting 10-20 writing samples and using them as few-shot examples — works exceptionally well alongside stop-slop constraints.

A worked example

Here is the same prompt run through a local Llama 3.1 8B model without and with anti-slop rules:

**Prompt:** "Write a short announcement about our team adopting local AI for internal tools."

**Without anti-slop rules:**

> In today's rapidly evolving technological landscape, our team is thrilled to announce a transformative initiative that leverages the power of self-hosted artificial intelligence. It is worth noting that this strategic decision underscores our commitment to innovation and data sovereignty, enabling us to optimise workflows and unlock unprecedented efficiencies across our organisation.

**With stop-slop rules applied:**

> Our team is running local AI for internal tools now. No more sending sensitive data to third-party APIs. We control the models, the data stays on our hardware, and the first results are already faster than the cloud services we replaced.

The difference is night and day. The second version says the same thing in half the words and sounds like a human colleague, not a corporate chatbot.

Scaling anti-slop across your self-hosted stack

Once you have a working anti-slop configuration, apply it everywhere your local AI produces text:

• **Open WebUI:** Add the rules to the system prompt in your model settings
• **n8n AI agent nodes:** Include the rules in the agent prompt field
• **AnythingLLM:** Set as custom instructions per workspace
• **API calls:** Wrap your client code with an anti-slop preprocessing step
• **Batch generation scripts:** Add a review pass using the scoring rubric

For teams, commit your customised rules to a shared repository alongside the patterns from Team Collaboration with Local LLMs: Multi-User Workflows for Private AI.

FAQ

Do anti-slop skills work with small local models?

Yes, but the effectiveness scales with model capability. A 7B-8B model at Q4 quantisation can follow the rules but may occasionally slip back into slop on complex prompts. A 12B+ model handles the constraints more consistently. The rules themselves are simple instruction-following tasks — no complex reasoning required.

Will this make my model sound unprofessional?

No — the goal is to remove the *unprofessional* tells that immediately identify text as AI-generated. Professional writing and slop are opposites. Anti-slop rules push output toward the clarity and directness that characterises expert communication.

How often should I update the rules?

The community is actively improving both stop-slop and taste-skill. Check the GitHub repos for updates monthly. Also review your own ban list quarterly — writing tics evolve.

Can I use these with GPT-4 or Claude?

Yes. The rules work with any LLM. They are particularly effective with frontier models that have the capacity to internalise complex stylistic constraints.

Source

**stop-slop:** https://github.com/hardikpandya/stop-slop

**taste-skill:** https://github.com/Leonxlnx/taste-skill