How to Unslop AI Output: Tools for Every Fix

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, and it is also the half that won. The five most-installed prose tools in this space all act after the text exists. This guide sorts more than thirty free tools by the problem they solve, argues for the less popular half, and says plainly where the popular half is the right call anyway.

Step one: name which slop you have

The word covers at least four 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.

Code slop is generated source that compiles and passes review but carries no evidence: a comment restating the line below it, a try block that swallows the error, a defensive check for a state that cannot occur, a name that describes the type instead of the thing. It is a signal problem rather than a style problem, and it is the one class a prose rule set cannot touch.

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 1,093 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.

The effect is measurable, not just describable. A 2025 preprint, Antislop: A Comprehensive Framework for Identifying and Eliminating Repetitive Patterns in Language Models (Paech, Roush, Goldfeder and Shwartz-Ziv), profiled model output against human baselines and reports that some slop patterns appear over 1,000 times more often in LLM text than in human text. That is the size of the gap a rule set is trying to close, and it is why banning a handful of words barely moves the reading experience. The paper’s own remedies act at inference and training time rather than on finished text: a sampler that backtracks to suppress a banned string as it is generated, and a fine-tuning method that adjusts the individual tokens where a pattern appeared. Both are upstream interventions, which is the same argument this guide makes with cheaper tools.

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.

Anti-slop tools by the moment they act

Primitive	Before generation	After generation	At the merge gate
Taste Skill	Design rules	nothing loads	nothing loads
Hallmark	21 themes	57 gates	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
Humanizer	nothing loads	Rewrites prose	nothing loads
stop-slop	nothing loads	Scores 1 to 10	nothing loads
dmmulroy/anti-slop	nothing loads	Oxlint rules	Fails the lint
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.

Now the uncomfortable part, because a guide that hides it is not worth reading. Almost nobody installs a pre-generation prose skill. The tools people actually adopt all run on text that already exists, and they are an order of magnitude more popular than anything recommended above.

Humanizer by blader is the largest at 49,188 stars, and it is a plain Markdown skill, so it runs in any harness that reads skills. It rewrites AI-sounding text without changing what the text says, and it will match your voice if you paste two or three paragraphs of your own writing first. Its documentation reaches the same diagnosis as this guide: a model “makes the choice that fits the widest range of readers and subjects” while a person “chooses for one reader and one subject.” It then applies that insight at the wrong end of the pipeline, which is the whole disagreement in one repository. Its 25 rules, the severity model behind them and the cases where it tells the agent not to act are broken down in the Humanizer skill, explained.

Worth following that thread one step further, because almost no roundup does. Humanizer’s rule set traces back to Wikipedia’s Signs of AI writing, the community guide editors use when assessing suspected machine-written edits, and the Chinese port states that lineage explicitly in its own README. It is the closest thing the category has to a maintained upstream, it is free, and two of its sections are the ones the commercial tools never ship: a list of signs of human writing, and a list of indicators that stopped working. If you read one document in this space rather than installing anything, read that one.

stop-slop by Hardik Pandya is second at 17,243 stars, and it is the one worth borrowing from even if you never install it. Besides the usual banned phrases and structural cliches, it bans Wh- sentence starters, staccato fragmentation and lazy extremes, and requires the active voice. What no other tool here ships is a scoring rubric: rate the draft 1 to 10 on directness, rhythm, trust, authenticity and density, and revise anything below 35 out of 50. That converts an argument about taste into a number two people can disagree about productively.

no-ai-slop by Peter Yang covers 20 or more named patterns at 10,132 stars and has the most honest detector in the category. Asked “is this slop?”, it quotes every pattern it found and explicitly declines to guess whether AI wrote the text. That is the correct scope for a detector, and it is the opposite of what commercial detection services sell.

Adoption runs against the mechanism

Item	Value
Humanizer · after	49,188
Humanizer-zh · after	17,393
stop-slop · after	17,243
no-ai-slop · after	10,132
im-not-ai · after	5,598
humanize-text · after	3,030
talk-normal · before	1,843
shuorenhua · after	1,769
mshumer unslop · before	549
theclaymethod unslop · after	438

Read that chart honestly and it is an argument against the recommendation above it. Two defences hold. The first is that Cursor unslop does not appear because it has no star count of its own: it ships inside a 45-skill plugin pack, so its adoption is unmeasurable from the outside and the ranking understates the before-generation half by an unknown amount. The second is that popularity in a nine-month-old category tracks distribution, not results, and exactly one tool in this chart has published a controlled comparison of itself.

The reasonable position is not that rewriters are worthless. It is that a rewriter is the right tool for text you did not generate and cannot regenerate, such as a document handed to you, and the wrong default for work you control end to end. If you are about to write the next thousand words yourself, fixing the brief is cheaper than fixing the output.

If you want alternatives to Cursor unslop that still act before generation, 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.
• mshumer/unslop is the most interesting mechanism in the group and the least adopted at 549 stars. Rather than shipping a fixed banned list, it profiles the repetitive defaults a given model falls back on in a given domain, then writes those findings out as a reusable instruction file. That is the same shape as the profiling stage in the Antislop paper, done with an agent instead of a research pipeline, and it produces a rule set matched to the model you actually use.

One warning on picking by popularity, and stop-slop is its own best illustration. At 17,243 stars it is the most-starred dedicated prose skill in the category, and its last commit was 17 March 2026, six months before this check. jalaalrd/anti-ai-slop-writing at 464 stars was last touched 18 April 2026, and the inbound-PR gate peakoss/anti-slop at 826 stars on 15 April 2026, while actively maintained tools such as MohamedAbdallah-14/unslop sit under 150. In a category this young, a star count is a record of one good week on social media and nothing else. Check the last commit date, then check whether the rules inside have kept up with the models that shipped since.

None of that makes stop-slop a bad file. Its rules did not expire; a banned phrase stays banned. It means the maintainer is not tracking new tells, so the list is a snapshot of early 2026 and you are on your own for anything that arrived after it.

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.

The most adopted option is different from the most developed one. Humanizer-zh by op7418 carries 17,393 stars, which makes it the second most-starred tool in the whole category, and its own README states what it is: a Chinese translation of blader’s Humanizer, with the rule set and scoring checklist borrowed from stop-slop. It has had no commits since 19 January 2026. A translated rule set is a reasonable starting point and a poor finishing point, for the same reason the section opened with.

For Korean, im-not-ai by epoko77-ai is the serious entry at 5,598 stars and is actively maintained. Its documentation describes 10 categories covering roughly 70 sub-patterns, classified by severity into three tiers and detected at the span level rather than the document level, and it targets Korean-specific failures: translationese, mechanical parallelism, overuse of the passive, and sentence-initial connectives. It runs in Claude Code, GitHub Copilot CLI, Codex CLI and Gemini CLI.

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

Five 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, and it is official. Start here if you install nothing else. Every tool named in this guide now has a row in this site’s directory of Claude and agent skills, with its star count and last-commit date as checked on 17 September 2026, if you want the roster as a sortable table rather than prose.

Taste Skill by Leon Lin and blueemi is the most adopted third-party option at 87,696 GitHub stars as of 17 September 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 31,253 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.

Hallmark by Together AI is the one missing from most roundups and it is the second-largest tool in the category at 28,738 stars. Its documentation describes 21 themes and four verbs: build, audit to score existing code with a punch list and no edits, redesign to throw out the structure while keeping the copy and information architecture, and study to extract the macrostructure, type pairing and colour anchor from a design you admire, which it will emit as a portable design.md for another tool to read. It runs 57 slop-test gates plus a self-critique before it hands anything back. The stated goal is that two pages built from two different briefs come out as different sites rather than colour swaps of one template, which is a sharper claim than most of this category makes.

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 512,046 npm downloads in the 30 days to 11 September 2026. Disclosure: this site runs Impeccable. There is no commercial relationship and nothing here was sponsored.

If the slop you are looking at is specifically a diagram, that has its own tool. diagram-design by Cathryn Lavery carries 40,512 stars and ships 39 editorial diagram types as self-contained HTML and SVG, explicitly as an alternative to default Mermaid output. Useful to know because a generated architecture diagram is one of the most recognisable tells on an otherwise careful page.

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: code that compiles but carries no evidence

Every tool above works on words or pixels. None of them reads the generated source, and generated source has its own tells: the comment that restates the line under it, the catch block that swallows an error to keep the build green, the guard against a state the type system already rules out, the abstraction added for a second caller that never arrived.

anti-slop by Dillon Mulroy, 4,585 stars, is the most rigorous answer because it is not a skill at all. It is a set of opinionated Oxlint rules that reject low-evidence TypeScript and JavaScript patterns, so the check is a lint rule with a number, running with no model in the loop. The design decision worth copying is that the project is meant to be vendored rather than depended on: there is deliberately no npm package, and the bundled skill copies the rules into your repository, merges them into your existing lint configuration and then gets out of the way. The maintainer is explicit that the rules encode one team’s taste rather than a universal standard, which is the correct posture and a rare one here.

Two alternatives with different shapes. desloppify by peteromallet, 3,127 stars, is an agent harness that reworks existing generated code rather than linting it, though it has had no commits since 13 May 2026. miqdadbadjuber/anti-slop, 2,836 stars and actively maintained, spans UI, copy and code from one rule set and describes itself as a filter rather than a style guide: it prescribes no colours, fonts or layouts, and it takes direction from a DESIGN.md you write. That makes it the closest thing in the category to a single install covering three of the four classes, at the cost of being shallower in each than the specialists.

The honest limit is the same one the linters hit elsewhere in this guide. A rule can see that a comment restates the code. It cannot see that the function is solving the wrong problem.

This class has more evidence behind it than the rest of the category, because three 2026 studies measured it. The full read, including where generated code actually lands in a repository and why the cost shows up in review rather than in the diff, is in what AI slop in code actually costs.

Fix five: 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 ..

For source code rather than prose or markup, the deterministic option is the Oxlint rule set covered in the previous section, which fails on a named rule you can read and argue with.

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 six: 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. Three do, and the three are not equivalent, which is the part worth understanding before you read any of their numbers.

talk-normal publishes the weakest kind: it reports a 73 percent and 72 percent reduction in output length on GPT-4o-mini and GPT-5.4 across ten test questions, with the full before and after text published. Length is easy to measure and is not the thing you care about. Shorter output is only better if nothing useful left with the words, and a character count cannot tell you that.

shuorenhua publishes the middle kind, covered above: 120 cases deliberately split between text that needs fixing and 57 texts that must be left alone. Testing that a tool does nothing when it should do nothing is the half almost everyone skips, and it is worth more than another hundred positive examples.

The third 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.

Adopt in this order

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

Six options against five needs

Dimension	Taste Skill	Hallmark	Impeccable	Vercel rules	Cursor unslop	ux-skill
Interface coverage	Broad	Broad	Broad	Broad	None	Broad
Prose coverage	None	None	None	Separate skill	Full	None
Runs without a model	No	No	Partly	No	No	Yes
Blocks a merge	No	No	Via CLI	No	No	Yes
Setup effort	Low	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. Hallmark is the one to reach for when you want structural variety rather than a house style, because it picks a different macrostructure per brief instead of restyling one. 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 most popular anti-slop skill?

By GitHub stars on 17 September 2026, Taste Skill leads the whole category at 87,696 and is a design skill. For prose specifically the leader is Humanizer at 49,188, followed by its Chinese translation Humanizer-zh at 17,393 and stop-slop at 17,243. Popularity is a weak guide here: stop-slop had not been committed to since 17 March 2026 when checked, and the category is young enough that a star count mostly records one good week of distribution. Check the last commit date before you trust a ranking.

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?

They work on the wrong end of the problem, which is not the same as not working. A humanizer leaves its own statistical signature, distinct from both AI and human writing, so it adds a layer rather than removing one, and a detector scores finished text without reliably establishing authorship. Both act after generation. A skill changes the instructions the model works from, so the generic version is never produced. That said, adoption runs the other way: the six most-installed prose tools are all rewriters, led by Humanizer at 49,188 stars. A rewriter is the right tool for text you did not generate and cannot regenerate, and the wrong default for work you control end to end.

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 nine months old, free, and moving fast enough that the roster here shifted by a dozen tools in the seventeen days between the first version of this guide and this revision. The mechanism is still settled: constrain the brief, then verify deterministically, then gate the branch. In that order.

What is not settled is whether anyone follows it. The six most-installed prose tools all clean up after the fact, and the gap between the leader and the first tool that constrains generation is about 27 times. Read that as a warning about defaults rather than a verdict: people reach for the rewriter because the text is already on the screen, which is exactly when fixing the brief is no longer an option.

Pick by the problem you actually have. Prose slop, interface slop, code slop and inbound slop need different tools, non-English prose needs a tool built for that language rather than a translated one, 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

Paech, S., Roush, A., Goldfeder, J., and Shwartz-Ziv, R. (2025). Antislop: A Comprehensive Framework for Identifying and Eliminating Repetitive Patterns in Language Models. arXiv preprint 2510.15061 (preprint, not peer-reviewed). https://arxiv.org/abs/2510.15061

Wikipedia contributors (2026). Wikipedia:Signs of AI writing. Wikipedia editor guideline. https://en.wikipedia.org/wiki/Wikipedia:Signs_of_AI_writing

blader (2026). Humanizer: agent skill that removes signs of AI-generated writing from text (documentation). https://github.com/blader/humanizer

Pandya, H. (2026). stop-slop: a skill file for removing AI tells from prose (documentation). https://github.com/hardikpandya/stop-slop

Yang, P. (2026). no-ai-slop: removes 20+ patterns of AI slop from any piece of writing (documentation). https://github.com/petergyang/no-ai-slop

Together AI (2026). Hallmark: anti-AI-slop design skill for Claude Code, Cursor and Codex (documentation). https://github.com/Nutlope/hallmark

Lavery, C. (2026). diagram-design: editorial diagram types for coding agents (documentation). https://github.com/cathrynlavery/diagram-design

Mulroy, D. (2026). anti-slop: opinionated Oxlint rules for rejecting low-evidence TypeScript and JavaScript patterns (documentation). https://github.com/dmmulroy/anti-slop

op7418 (2026). Humanizer-zh: Chinese translation of Humanizer (documentation). https://github.com/op7418/Humanizer-zh

epoko77-ai (2026). im-not-ai: Korean AI-text humanizer (documentation). https://github.com/epoko77-ai/im-not-ai

hexiecs (2026). talk-normal: a system prompt that removes AI slop, including TEST_RESULTS.md (self-published evaluation). https://github.com/hexiecs/talk-normal

Shumer, M. (2026). unslop: detect a model’s repetitive defaults and turn them into an instruction file (documentation). https://github.com/mshumer/unslop

Badjuber, M. (2026). anti-slop: rules for an AI coding agent to filter out generic AI-generated UI, text and code (documentation). https://github.com/miqdadbadjuber/anti-slop

O’Malley, P. (2026). desloppify: agent harness for reworking generated code (documentation). https://github.com/peteromallet/desloppify

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, 13 August to 11 September 2026. https://api.npmjs.org/downloads/point/last-month/impeccable

GitHub API (2026). Repository star counts and last-commit dates for every tool named above, retrieved 17 September 2026. https://docs.github.com/en/rest