How to Unslop AI Output: Tools for Every Fix
Your AI output reads generic. Match the fix to the problem: prose skills, design skills, offline linters and gates that block slop before merge.
Slop is fixable, and the fix depends on one question: are you cleaning up text and interfaces that already exist, or stopping the next batch from coming out generic? Those are different problems with different tools, and most people reach for the wrong one first.
The reflex is to run finished output through a humanizer or a detector. That is the weaker half of the category. The stronger half is a skill file: a set of constraints the agent reads before it generates, so the generic version never gets built. This guide sorts more than twenty free tools by the problem they solve, so you can install one and move on.
Step one: name which slop you have
The word covers at least three unrelated failures, and the tools do not overlap.
Prose slop is text that reads as generated: the “not just X, but Y” construction, the forced rule of three, synonym cycling, hedging stacks, decorative emoji, em dashes everywhere, sycophantic openers. It is a vocabulary and rhythm problem.
Interface slop is the page that looks like every other AI-built page: the centered hero, the three feature cards, the purple-to-blue gradient, the same shadow on everything, type that never changes size. It is an art-direction problem, and the code is usually fine.
Inbound slop is other people’s generated output arriving in your repository as low-effort pull requests. It is a volume problem, and it needs a gate rather than a style guide.
A fourth, quieter one: agent slop, where the assistant itself pads every reply with restatements and enthusiasm. That is fixed with an output style rather than a content rule, and attention-span by alexgreensh is the most adopted option at 884 stars.
Why cleaning up afterwards works badly
Left unguided, a model reproduces the statistical centre of what it was trained on. Ask for a modern website and you get the most probable modern website, because that is the answer least likely to be rejected. Ask for engaging copy and you get the average of engaging copy.
Adjectives do not fix this. “Make it beautiful” is a vague brief, and a vague brief resolves to the average. What changes the output is a constraint the model cannot average away: this typeface, this spacing scale, this contrast floor, never this pattern, never this phrase.
This is also why humanizers disappoint. The anti-slop writing ruleset published by InHouseSEO makes the point directly: running text through a humanizer “is detectable itself. It creates a different statistical signature that is distinct from both pure AI and pure human writing.” Fixing output after the fact adds a layer. Fixing the brief removes one.
So the ordering matters. Constrain first, check second, gate last.
| Primitive | Before generation | After generation | At the merge gate |
|---|---|---|---|
| Taste Skill | Design rules | nothing loads | nothing loads |
| Impeccable | Design rules | 59 checks | CLI audit |
| Vercel rules | 100+ rules | nothing loads | nothing loads |
| Cursor unslop | Prose rules | nothing loads | nothing loads |
| shuorenhua | nothing loads | Rewrites text | nothing loads |
| ux-skill | Design briefs | 152 regex rules | Fails on High |
| is-it-slop | nothing loads | CLI detector | nothing loads |
| peakoss/anti-slop | nothing loads | nothing loads | Closes slop PRs |
| attention-span | Output style | nothing loads | nothing loads |
Fix one: prose that reads like a language model
Start with Cursor unslop, shipped by Cursor inside its public plugin repository as one of 45 skills in the pstack pack. Its description is a single line: cut AI tells from any writing, must always apply. It enforces around 30 rules in seven groups. It bans em dashes outright, kills the “not just X, but Y” construction and the forced rule of three, stops synonym cycling, converts inline-header lists back into prose, replaces “serves as” with “is”, and strips decorative emoji and title-case headings. It is the most complete free rule set of the group and it costs nothing to add.
If you want alternatives, the credible ones differ in mechanism rather than ambition:
- theclaymethod/unslop is the only tool in this survey that publishes a benchmark of itself. More on that below, because the result is the most useful thing in the category.
- MohamedAbdallah-14/unslop targets sycophancy, stock vocabulary and hedging stacks specifically, and its documentation states it preserves code blocks, URLs and headings rather than rewriting them. Actively maintained.
- ehmo/slopkit ships two skills instead of one: one cleans writing you are about to publish, the other cleans the conversation with the agent itself.
- gabelul/slopbuster claims 152 patterns and covers prose, code and academic writing.
- adewale/anti-slop-writing is deliberately instruction-only: rules and examples, no scripts and no runtime. Useful if you want to read every rule before adopting it.
One warning on picking by popularity. Two of the most-starred prose skills in this space, jalaalrd/anti-ai-slop-writing at 425 stars and peakoss/anti-slop at 807, had not been touched in over four months when checked on 31 August 2026, while several actively maintained tools sit under 150 stars. In a category this young, a star count is a record of one good week on social media. Check the last commit date instead.
The more durable move, if you write in a specific voice, is to keep your own banned list. A shared list produces shared output, which is the original problem wearing a different hat.
Fix two: prose in a language other than English
This is the gap in every English-language roundup of these tools, and it matters more than the coverage suggests. AI tells are language-specific. A rule set that bans “delve” and the em dash does nothing for Chinese template phrasing or Czech register drift.
The most developed option is shuorenhua (说人话) by MrGeDiao, a Chinese-first rewrite skill. Its documentation reports 210 or more Chinese phrases, 96 English phrases and 25 structural anti-patterns, and it targets template feel, performance tone and register drift rather than a word list. It also ships its own benchmark of 120 test cases, deliberately split between 63 texts that need correcting and 57 that must be left alone, plus 20 scenario samples across README, release notes, forum and API-reference contexts. That protective half is the part most tools skip.
Also in this lane: stop-slop-zh for Chinese, anti-ai-slop-cz for Czech, and SDesign by simonlin1212, which is a library of 64 design systems across six aesthetic families with Chinese-language guidance.
Fix three: interfaces that look AI-generated
Four options are worth knowing, and they differ by temperament.
Anthropic’s frontend-design is the baseline. It treats the model as a design lead rather than a code generator, it is free, it is official, and it is the one already catalogued in this site’s directory of Claude and agent skills. Start here if you install nothing else.
Taste Skill by Leon Lin and blueemi is the most adopted third-party option at 82,760 GitHub stars as of 31 August 2026. Its version 2 reads a project brief and infers a design direction rather than applying a fixed style, with tunable dials for variance, motion and density. It supports Claude Code, Cursor, Codex, Gemini CLI, v0, Lovable, OpenCode and AI Studio. Two practical notes: it installs through npx skills add, not npm, and the unrelated taste-skill package on npm is a different thing entirely.
Vercel’s web-design-guidelines is the most underrated of the group and absent from most published roundups, despite sitting in a repository with 30,669 stars. It audits code against more than 100 rules across 11 categories including accessibility, focus states, forms and animation, and the same repository ships a separate writing-guidelines skill if you want prose covered by the same vendor. Install with npx skills add vercel-labs/agent-skills.
Impeccable by Paul Bakaus is the checker of the group: 59 checks and 23 commands such as /typeset, /distill and /audit, working across Claude Code, GitHub Copilot, Cursor, Gemini CLI, Codex CLI and Grok Build. It reads a PRODUCT.md file for context before making design decisions, and four of its rules only activate once you have written a DESIGN.md, which is what converts vague design debt into a number you can work down. It recorded 494,145 npm downloads in the 30 days to 29 August 2026. Disclosure: this site runs Impeccable. There is no commercial relationship and nothing here was sponsored.
Three more if none of those fit: educlopez/ui-craft ships 43 anti-slop detection rules, 25 slash commands and four deterministic quality gates; auteur by agiwhitelist takes the unusual approach of directing a site the way a film is directed, with a commit sheet and generated assets; and genjutsu by AThevon covers animation, 3D and motion principles specifically.
Fix four: you want a check, not an opinion
Every tool above still routes through a model, which means the same prompt can pass on Tuesday and fail on Thursday. If you need a result you can put in a build, use something deterministic.
ux-skill by Laith0003 is the clearest example. Its documentation describes 152 regex rules that run against your code with no model call at all, in roughly 200 milliseconds, grouped into accessibility (23 rules), content (15), layout (13), typography (10), colour (9), quality (9), visual (9), motion (8) and performance (4). It exits non-zero on Critical or High findings, so it works as a build gate. Install with pip install uxskill and run uxskill lint ..
is-it-slop by sermuns is a small Rust command-line detector for what its author calls slop smell, useful as a fast pre-commit check. unmachined pairs deterministic scanners with severity-tiered catalogues of tells and covers both text and frontend source.
The trade-off is honest: regex rules cannot read intent. They will flag a quoted vendor buzzword inside an article as a buzzword, because a pattern cannot tell quotation from endorsement. Expect a permanent floor of findings you deliberately ignore, and write that decision down so the next person does not re-litigate it.
Fix five: the slop is arriving from other people
If you maintain anything public, the problem is inbound volume rather than your own writing.
peakoss/anti-slop is a GitHub Action that detects and automatically closes low-quality pull requests using heuristics rather than a model. Its documentation says the checks were derived from patterns identified across more than 130 manually reviewed AI slop pull requests submitted to large open-source projects, and it examines branch, size, title, description, commit messages, file changes and contributor history. Defaults include a maximum of 50 changed files, an account age floor of 30 days and a global merge ratio floor of 30 percent, with a max-failures threshold of 4 before it acts.
Read that mechanism carefully before you enable it, because it profiles contributors and not prose. A first-time contributor with a new account and a genuinely good patch trips several checks at once. The project states that “genuinely good AI-assisted contributions are not penalized,” but the levers it actually pulls are account age, fork rate and merge history, so raise max-failures and start in report-only mode. It also had no commits for over four months as of 31 August 2026.
Alternatives: agentscan by MatteoGabriele does automation-pattern detection for maintainers and is actively maintained, and vibe-check by fabriziosalmi is a CI gatekeeper in the same shape.
The most useful finding in the whole category
Almost none of these tools measure themselves. Two do. One publishes a test suite, covered above: shuorenhua ships 120 cases, deliberately split between text that needs fixing and text that must be left alone. The other runs a controlled comparison, and its own result is a warning.
theclaymethod/unslop publishes an evaluation in evals/CORE-RESULTS.md using a paired, model-controlled design: the same model processes identical unfamiliar source text in two arms, one with the tool’s full pipeline and one with neutral guidance, judged blind. The release suite caps at 80 executable examples with more than 400 outcome predicates, and it measures detection precision and recall, repair success, preservation, collateral damage, net document improvement, and byte-exact no-op behaviour on prose that was already clean.
Its published verdict on itself is a no-ship. In the maintainer’s words, the tool “materially improved recall and repair over plain Luna, but it did not yet meet the precision, damage, or whole-document safety bar.”
The order to do this in
Installing four skills at once is the common mistake. They will contradict each other and you will not know which one produced a given change.
| Order | Step | Acts at | What you do |
|---|---|---|---|
| 1 | Name the problem | Diagnose | Prose, interface, or inbound. Different tools, no overlap. |
| 2 | Install one skill | Before generation | One only, so you can attribute what changed. |
| 3 | Write the context file | Context | A design document, a voice note, or your own banned list. |
| 4 | Add a deterministic check | After generation | An offline linter that never calls a model. |
| 5 | Gate the branch | Merge gate | Exit non-zero on the severities you actually care about. |
Step three is the one people skip, and it is the one that does the work. A design skill with no declared type scale falls back to its own defaults, which are somebody else’s defaults. A prose skill with no voice note bans the tells and leaves you with clean, characterless text.
Picking between the main options
| Dimension | Taste Skill | Impeccable | Vercel rules | Cursor unslop | ux-skill |
|---|---|---|---|---|---|
| Interface coverage | Broad | Broad | Broad | None | Broad |
| Prose coverage | None | None | Separate skill | Full | None |
| Runs without a model | No | Partly | No | No | Yes |
| Blocks a merge | No | Via CLI | No | No | Yes |
| Setup effort | Low | Medium | Low | Low | Medium |
For interfaces, pick on temperament. Taste Skill pushes for distinctive output and is the better choice when the risk is blandness. Impeccable is a checker with a rule engine and a vocabulary of commands, and is the better choice when a design system already exists and the risk is drift away from it. Vercel’s rules are the best fit if your stack is React and Next.js, because that is what they were written against.
For prose, Cursor unslop, and your own banned list on top of it.
They stack. A design skill and a prose skill do not overlap, and running both costs nothing. If you want to understand how skills differ from MCP servers and prompt templates before installing any of them, start there.
What none of them fix
A skill removes the defaults. It does not supply the substance.
Every tool here makes a page or a paragraph less generic, and none of them makes it worth reading. A detector count going to zero says nothing about whether a post answers a real question. A rule cannot tell a quoted vendor phrase from an endorsed one, and it certainly cannot tell you whether a claim is checkable.
That is the limit of the whole category, including the half this guide argues against. Detectors and humanizers work on finished text and cannot verify a fact. Skills work on the brief and cannot tell you whether you had anything to say. What fills the gap is the boring thing: a real number, a named source, a dated example, a result somebody actually measured. That is the standard published in this site’s editorial standards, and it is the part no file can install for you.
Frequently asked questions
- What is the fastest way to unslop AI writing?
- Install one prose skill that constrains the agent before it writes, rather than running finished text through a humanizer. Cursor unslop is the most complete free option: roughly 30 rules in seven groups that ban em dashes, the not-just-X-but-Y construction, the forced rule of three, synonym cycling and decorative emoji. Then add your own banned-word list, because a shared list produces shared output.
- Do humanizers and AI detectors work?
- Poorly, and for a structural reason. Running text through a humanizer leaves its own statistical signature, distinct from both AI and human writing, so it adds a layer rather than removing one. Detectors score finished text and cannot reliably establish authorship. Both act after generation, which is the wrong moment. A skill changes the instructions the model works from, so the generic version is never produced.
- Which anti-slop tool should I use for design versus writing?
- They are separate problems, so most people want two installs. For interfaces: Anthropic frontend-design as a free baseline, Taste Skill when the risk is blandness, Impeccable when a design system already exists and the risk is drift, or Vercel web-design-guidelines if your stack is React and Next.js. For prose: Cursor unslop. Running a design skill and a prose skill together costs nothing and they do not overlap.
- Are these anti-slop skills free?
- Every tool named in this guide is free and open. Most install through npx skills add from a public GitHub repository, Impeccable installs with npx impeccable install on Node 22.12 or later, and ux-skill installs with pip install uxskill. Support is broad across harnesses: Taste Skill lists Claude Code, Cursor, Codex, Gemini CLI, v0, Lovable, OpenCode and AI Studio, and Impeccable lists Claude Code, GitHub Copilot, Cursor, Gemini CLI, Codex CLI and Grok Build.
- Can I trust an anti-slop tool to rewrite my text automatically?
- Not without checking the diff. Only one tool in this survey, theclaymethod unslop, publishes a benchmark of itself, and its own reported verdict is that it did not yet meet the precision, damage or whole-document safety bar despite improving recall and repair. The unmeasured tools have not shown they do better. Run any rewriting tool on a copy, diff the result and accept changes individually; reserve automatic application for deterministic rules where you can read the rule that fired.
- How do I stop AI slop pull requests on my repository?
- That needs a gate rather than a style guide. peakoss anti-slop is a GitHub Action that closes low-quality pull requests using heuristics with no model call, built from patterns across more than 130 manually reviewed AI slop PRs. Enable it carefully: it profiles contributors rather than prose, using account age, fork rate and merge history, so a genuine first-time contributor can trip several checks at once. Start in report-only mode and raise the max-failures threshold.
The bottom line
The category is six months old, free, and moving fast enough that a ranking published in June was stale by August. But the mechanism is settled: constrain the brief, then verify deterministically, then gate the branch. In that order.
Pick by the problem you actually have. Prose slop and interface slop need different tools, non-English prose needs a tool built for that language, and inbound slop needs a gate. Install one thing, write the context file it reads, and check the last commit date before you trust a star count.
Sources
Cursor (2026). pstack/skills/unslop/SKILL.md. Cursor plugin repository (documentation). https://github.com/cursor/plugins/blob/main/pstack/skills/unslop/SKILL.md
Anthropic (2026). frontend-design. Agent Skills repository (documentation). https://github.com/anthropics/skills/tree/main/skills/frontend-design
Taste Skill (2026). Taste Skill: The Anti-Slop Frontend Framework for AI Agents. Leon Lin and blueemi. https://www.tasteskill.dev/
Vercel Labs (2026). web-design-guidelines. Vercel agent-skills repository (documentation). https://github.com/vercel-labs/agent-skills/tree/main/skills/web-design-guidelines
Impeccable (2026). Impeccable: design skills, commands, and anti-pattern detection for AI coding agents. Paul Bakaus. https://impeccable.style/
The Clay Method (2026). unslop: an agent skill to de-AI your writing, including evals/CORE-RESULTS.md (self-published evaluation). https://github.com/theclaymethod/unslop
MrGeDiao (2026). shuorenhua (说人话): Chinese-first de-AI rewrite skill (documentation). https://github.com/MrGeDiao/shuorenhua
Laith0003 (2026). ux-skill: design intelligence engine with offline deterministic linter (documentation). https://github.com/Laith0003/ux-skill
peakoss (2026). anti-slop: a GitHub action that detects and automatically closes low-quality and AI slop PRs (documentation). https://github.com/peakoss/anti-slop
educlopez (2026). ui-craft: design engineering system for AI coding agents (documentation). https://github.com/educlopez/ui-craft
InHouseSEO (2026). superseo-skills: anti-slop writing ruleset (documentation). https://github.com/inhouseseo/superseo-skills
npm registry (2026). Download counts for the impeccable package, 31 July to 29 August 2026. https://api.npmjs.org/downloads/point/last-month/impeccable
GitHub API (2026). Repository statistics and last-commit dates for the tools named above, retrieved 31 August 2026. https://docs.github.com/en/rest