anti-slop
Skill4 starsChanged 52 days agoMITView on GitHub
Comprehensive toolkit for detecting and eliminating "AI slop" - generic, low-quality AI-generated patterns in natural language, code, and design. Use when reviewing or improving content quality, preventing generic AI patterns, cleaning up existing content, or enforcing quality standards in writing, code, or design work.
33 other projects use a version of this.
Adopted by
Most recently taken up by
- youcisla/Agent-Foundrytheir own version, first seen Nov 16, 2026
- iammrduncan/skillstheir own version, first seen Nov 16, 2026
- sant1jmnz/claude-code-kittheir own version, first seen Nov 15, 2026
- adeonir/agent-skillstheir own version, first seen Nov 10, 2026
- MishraShardendu22/agent-skills-hub-sync-enginetheir own version, first seen Nov 8, 2026
- TheVeller/claude-skillstheir own version, first seen Nov 8, 2026
Other versions33 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 33
- elithrar/dotfiles★ 222same name
- Gesso-Build/skills★ 91same name
- roedyrustam/vibes-plug★ 75same name
- Tom-Babb/ai-marketing-skills-with-by-tom-babb★ 30same name
- Vumb-VibeCoder/hook-everything★ 19same name
- aixarizzo/kill-slop★ 17same name
- darknecrocities/SkillBuilder★ 13same name
- HyunjunJeon/claude-workflow-mods★ 10same name
- taljeon/plzdo★ 9same name
- YuliangXiu/de-ai-router★ 9same name
23 more not listed
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository144 other files it gives its agents.
- skills/composition-patterns/AGENTS.mdAGENTS.md
- skills/react-best-practices/AGENTS.mdAGENTS.md
- skills/react-native-skills/AGENTS.mdAGENTS.md
- antislop-codeSkill
- antislopSkill
- api-and-interface-designSkill
- api-endpoint-builderSkill
- astroSkill
- bddSkill
- brainstormSkill
- bring-me-ideasSkill
- brooks-lintSkill
- browser-testing-with-devtoolsSkill
- cavemanSkill
- ci-cd-and-automationSkill
- cloudflareSkill
- codebase-audit-pre-pushSkill
- codebase-designSkill
- code-review-and-qualitySkill
- code-simplificationSkill
- composition-patternsSkill
- constraint-driven-developmentSkill
- context7-mcpSkill
- context-engineeringSkill
- conventional-commitSkill
- conventional-commit-with-coauthorSkill
- credentialsSkill
- data-dummerSkill
- dddSkill
- debugging-and-error-recoverySkill
- deprecation-and-migrationSkill
- 3d-uiSkill
- ai-native-uiSkill
- aurora-uiSkill
- bento-uiSkill
- brutalismSkill
- brutalist-typographySkill
- card-based-designSkill
- claymorphismSkill
- color-blockingSkill
- command-center-uiSkill
- cyberpunk-uiSkill
- cyber-y2kSkill
- dark-modeSkill
- dashboard-designSkill
- data-dense-designSkill
- duotone-designSkill
- editorial-designSkill
- flat-design-2Skill
- flat-designSkill
- floating-uiSkill
- frutiger-aeroSkill
- glassmorphismSkill
- gradient-designSkill
- high-contrastSkill
- holographic-uiSkill
- isometric-designSkill
- layered-designSkill
- material-designSkill
- maximalismSkill
- The first 60 shown.
The file
Show its rules and text
We split this skill into the rules it gives an agent
26 rules. 0 are common, 25 are distinctive, and 1 is very specific to this project.
0
Common
Most of the 32 edited versions we read keep these.
25
Distinctive
This author's own choices. Worth a look.
1
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 44
Read the appropriate reference file for detailed patterns:
- Distinctive: line 97
Use precise verbs instead of vague action words
- Distinctive: line 101
Use active voice predominantly
- Distinctive: line 102
Write in a voice appropriate to context, not corporate-generic
- Distinctive: line 125
Remove unnecessary abstraction layers
- Distinctive: line 137
Write code that's easy to understand
- Distinctive: line 139
Prefer simple solutions to complex ones
- Distinctive: line 147
Document why, not what
- Distinctive: line 159
Every element using same design treatment
- Distinctive: line 177
Create hierarchy based on importance
- Distinctive: line 181
Every design decision should be justifiable
- Distinctive: line 182
Use patterns because they serve users, not because they're trendy
- Distinctive: line 187
Avoid generic marketing speak
- Very specific: line 258
Always creates .backup file when overwriting
- Distinctive: line 267
Write with specific audience in mind
- Distinctive: line 268
Use concrete examples over abstractions
- Distinctive: line 275
Not all patterns are always slop:
- Distinctive: line 291
Detect: - Run detection scripts or manual review
- Distinctive: line 300
Use automated detection to find candidates
- Distinctive: line 341
Always review automated changes
- Distinctive: line 397
Run detection first to understand scope
- Distinctive: line 398
Use non-aggressive mode for important content
- Distinctive: line 403
Start with renaming generic variables
- Distinctive: line 404
Remove obvious comments next
- Distinctive: line 406
Test after each significant change
- Distinctive: line 411
Ensure changes serve user needs
“Common” is measured: kept by at least 6 in 10 of the 32 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Anti-Slop Skill
Detect and eliminate generic AI-generated patterns ("slop") across natural language, code, and design.
What is AI Slop?
AI slop refers to telltale patterns that signal low-quality, generic AI-generated content:
- Text: Overused phrases like "delve into," excessive buzzwords, meta-commentary
- Code: Generic variable names, obvious comments, unnecessary abstraction
- Design: Cookie-cutter layouts, generic gradients, overused visual patterns
This skill helps identify and remove these patterns to create authentic, high-quality content.
When to Use This Skill
Apply anti-slop techniques when:
- Reviewing AI-generated content before delivery
- Creating original content and want to avoid generic patterns
- Cleaning up existing content that feels generic
- Establishing quality standards for a project
- User explicitly requests slop detection or cleanup
- Content has telltale signs of generic AI generation
Core Workflow
1. Detect Slop
For text files:
python scripts/detect_slop.py <file> [--verbose]This analyzes text and provides:
- Slop score (0-100, higher is worse)
- Specific pattern findings
- Actionable recommendations
Manual detection: Read the appropriate reference file for detailed patterns:
references/text-patterns.md- Natural language slop patternsreferences/code-patterns.md- Programming slop patternsreferences/design-patterns.md- Visual/UX design slop patterns
2. Clean Slop
Automated cleanup (text only):
# Preview changes
python scripts/clean_slop.py <file>
# Apply changes (creates backup)
python scripts/clean_slop.py <file> --save
# Aggressive mode (may slightly change meaning)
python scripts/clean_slop.py <file> --save --aggressiveManual cleanup: Apply strategies from the reference files based on detected patterns.
Text Slop Detection & Cleanup
High-Priority Targets
Remove immediately:
- "delve into" → delete or replace with "examine"
- "navigate the complexities" → "handle" or delete
- "in today's fast-paced world" → delete
- "it's important to note that" → delete
- Meta-commentary about the document itself
Simplify wordy phrases:
- "in order to" → "to"
- "due to the fact that" → "because"
- "has the ability to" → "can"
Replace buzzwords:
- "leverage" → "use"
- "synergistic" → "cooperative"
- "paradigm shift" → "major change"
Quality Principles
Be direct:
- Skip preambles and meta-commentary
- Lead with the actual point
- Cut transition words that don't add meaning
Be specific:
- Replace generic terms with concrete examples
- Name specific things instead of "items," "things," "data"
- Use precise verbs instead of vague action words
Be authentic:
- Vary sentence structure and length
- Use active voice predominantly
- Write in a voice appropriate to context, not corporate-generic
Code Slop Detection & Cleanup
High-Priority Targets
Rename generic variables:
data→ name what data it representsresult→ name what the result containstemp→ name what you're temporarily storingitem→ name what kind of item
Remove obvious comments:
# Bad
# Create a user
user = User()
# Better - let code speak
user = User()Simplify over-engineered code:
- Remove unnecessary abstraction layers
- Replace design patterns used without purpose
- Simplify complex implementations of simple tasks
Improve function names:
handleData()→ what are you doing with data?processItems()→ what processing specifically?manageUsers()→ what management action?
Quality Principles
Clarity over cleverness:
- Write code that's easy to understand
- Optimize only when profiling shows need
- Prefer simple solutions to complex ones
Meaningful names:
- Variable names should describe content
- Function names should describe action + object
- Class names should describe responsibility
Appropriate documentation:
- Document why, not what
- Skip documentation for self-evident code
- Focus documentation on public APIs and complex logic
Design Slop Detection & Cleanup
High-Priority Targets
Visual slop:
- Generic gradient backgrounds (purple/pink/cyan)
- Overuse of glassmorphism or neumorphism
- Floating 3D shapes without purpose
- Every element using same design treatment
Layout slop:
- Template-driven layouts ignoring content needs
- Everything in cards regardless of content type
- Excessive whitespace without hierarchy
- Center-alignment of all elements
Copy slop:
- "Empower your business" type headlines
- Generic CTAs like "Get Started" without context
- Buzzword-heavy descriptions
- Stock photo aesthetics
Quality Principles
Content-first design:
- Design around actual content needs
- Create hierarchy based on importance
- Let content determine layout, not templates
Intentional choices:
- Every design decision should be justifiable
- Use patterns because they serve users, not because they're trendy
- Vary visual treatment based on element importance
Authentic voice:
- Copy should reflect brand personality
- Avoid generic marketing speak
- Be specific about value proposition
Reference Files
Consult these comprehensive guides when working on specific domains:
- text-patterns.md - Complete catalog of natural language slop patterns with detection rules and cleanup strategies
- code-patterns.md - Programming antipatterns across languages with refactoring guidance
- design-patterns.md - Visual and UX design slop patterns with improvement strategies
Each reference includes:
- Pattern definitions and examples
- Detection signals (high/medium confidence)
- Context where patterns are acceptable
- Specific cleanup strategies
Scripts
detect_slop.py
Analyzes text files for AI slop patterns.
Usage:
python scripts/detect_slop.py <file> [--verbose]Output:
- Overall slop score (0-100)
- Category-specific findings
- Line numbers and examples
- Actionable recommendations
Scoring:
- 0-20: Low slop (authentic writing)
- 20-40: Moderate slop (some patterns)
- 40-60: High slop (many patterns)
- 60+: Severe slop (heavily generic)
clean_slop.py
Automatically removes common slop patterns from text files.
Usage:
# Preview changes
python scripts/clean_slop.py <file>
# Save changes (creates backup)
python scripts/clean_slop.py <file> --save
# Save to different file
python scripts/clean_slop.py <file> --output clean_file.txt
# Aggressive mode
python scripts/clean_slop.py <file> --save --aggressiveWhat it cleans:
- High-risk phrases
- Wordy constructions
- Meta-commentary
- Excessive hedging
- Buzzwords
- Redundant qualifiers
- Empty intensifiers
Safety:
- Always creates
.backupfile when overwriting - Preview mode shows changes before applying
- Preserves content meaning (non-aggressive mode)
Best Practices
Prevention Over Cure
When creating content:
- Write with specific audience in mind
- Use concrete examples over abstractions
- Lead with the point, skip preambles
- Choose words for precision, not impression
- Review before considering it complete
Context-Aware Cleanup
Not all patterns are always slop:
Acceptable contexts:
- Academic writing may need more hedging
- Legal documents require specific phrasing
- Internal documentation can use shortcuts
- Technical docs have domain-specific conventions
Always consider:
- Who is the audience?
- What is the purpose?
- Does this pattern serve a function?
- Is there a better alternative?
Iterative Improvement
- Detect - Run detection scripts or manual review
- Analyze - Understand which patterns are truly problems
- Clean - Apply automated cleanup where safe
- Review - Manually verify changes maintain meaning
- Refine - Fix remaining issues by hand
Quality Over Automation
The scripts are tools, not replacements for judgment:
- Use automated detection to find candidates
- Apply automated cleanup to obvious patterns
- Manually review anything that changes meaning
- Exercise discretion based on context
Integration Patterns
Code Review
# Check files before committing
python scripts/detect_slop.py src/documentation.md --verbose
# Clean up automatically
python scripts/clean_slop.py src/documentation.md --saveContent Pipeline
- Create initial content
- Run slop detection
- Apply automated cleanup
- Manual review and refinement
- Final quality check
Standards Enforcement
Create project-specific thresholds:
- Max acceptable slop score: 30
- Required manual review for scores > 20
- Auto-reject submissions with scores > 50
Limitations
Scripts only handle text:
- Code slop detection is manual (use code-patterns.md)
- Design slop detection is manual (use design-patterns.md)
Context sensitivity:
- Scripts can't understand all contexts
- Some "slop" may be appropriate in certain domains
- Always review automated changes
Language coverage:
- Detection patterns optimized for English
- Code patterns focus on common languages (Python, JS, Java)
- Design patterns are platform-agnostic
Common Scenarios
Scenario 1: Review AI-Generated Content
# User asks: "Can you review this article for AI slop?"
1. Read references/text-patterns.md for patterns to watch
2. Run: python scripts/detect_slop.py article.txt --verbose
3. Review findings and apply manual cleanup
4. Optionally run: python scripts/clean_slop.py article.txt --save
5. Do final manual review of cleaned contentScenario 2: Clean Up Codebase
# User asks: "Help me clean up generic AI patterns in my code"
1. Read references/code-patterns.md
2. Review code files manually for patterns
3. Create list of generic names to rename
4. Refactor following principles in code-patterns.md
5. Remove obvious comments and over-abstractionsScenario 3: Design Review
# User asks: "Does this design look too generic?"
1. Read references/design-patterns.md
2. Check against high-confidence slop indicators
3. Identify specific issues (gradients, layouts, copy)
4. Provide specific recommendations from design-patterns.md
5. Suggest concrete alternativesScenario 4: Establish Quality Standards
# User asks: "Help me create quality standards for our team"
1. Review all three reference files
2. Identify patterns most relevant to user's domain
3. Create project-specific guidelines
4. Set up detection scripts in development pipeline
5. Document acceptable exceptionsTips for Success
For text cleanup:
- Run detection first to understand scope
- Use non-aggressive mode for important content
- Always review automated changes
- Focus on high-risk patterns first
For code cleanup:
- Start with renaming generic variables
- Remove obvious comments next
- Refactor over-engineered code last
- Test after each significant change
For design cleanup:
- Audit visual elements against patterns
- Prioritize structural issues over aesthetic ones
- Ensure changes serve user needs
- Maintain brand consistency
General principles:
- Quality > uniformity
- Context > rules
- Clarity > cleverness
- Specificity > generality
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

