How to Use stop-slop to Remove AI Writing Tilt and Make Your Text Sound Human Again
You know the feeling. You've just finished drafting a document—maybe a blog post, a technical spec, or an email to a client. You read it back and something feels wrong. The sentences are too clean. The transitions are too neat. Every paragraph starts with "Additionally" or "It is worth noting that." A friend glances at it and asks: "Did you use AI for this?"
That's AI writing tilt. And once you notice it, you can't unsee it.
Tools like Copilot and ChatGPT are genuinely useful for getting drafts out fast. But they leave fingerprints all over the text. In professional contexts, those fingerprints make your writing feel insincere. In technical documentation, they actually get in the way of clear communication.
stop-slop is an open-source tool designed to solve exactly this problem. It identifies and removes the patterns that make text sound like it was generated by a language model, bringing it back toward something a human would actually write.
1. Why AI Text Sounds Like AI
Before fixing the problem, it helps to understand why it exists in the first place.
Large language models are trained primarily on edited, formal text—academic papers, published articles, polished documentation. As a result, they default to a "textbook" register. Here are the most common patterns that give AI-generated text away:
Overuse of transition words. AI loves "Additionally," "Furthermore," "In addition," and "Moreover" to connect sentences. It creates a mechanical, list-like rhythm. Human writing tends to let the content carry the logical flow, relying less on explicit connectors.
Passive voice and nominalization. "It has been demonstrated that..." "Consideration should be given to..." "Significant progress has been made in..." These constructions are common in academic writing but feel stiff and evasive in everyday communication. Humans are more direct: "We found..." "You should consider..." "We improved..."
Excessive summarizing and emphasis. "It is important to note that..." "Critically..." "Overall..." AI seems compelled to flag its own key points, as if afraid the reader will miss them. Human writers usually weave their points into the narrative rather than announcing them.
Uniform sentence length. AI-generated sentences tend to be remarkably consistent in length—not too short, not too long. This uniformity feels unnatural. Human writing has rhythm: a long explanatory sentence followed by a short punchy one. Variation creates flow.
Relentless "although... nevertheless..." structures. AI is fond of the concessive turn—acknowledging a counterpoint before making its actual point. Used once in a while, it's fine. Used in every paragraph, it becomes a tic.
stop-slop targets these specific patterns. It has a built-in rule set that detects and rewrites the most common AI-isms, making text sound less like it came from a model and more like it came from a person.
2. Getting Started in Three Steps
For most people, using stop-slop takes about a minute.
Step 1: Install the tool
stop-slop is a command-line tool. Install it with pip:
pip install stop-slop
If you use uv:
uv pip install stop-slop
Verify it works:
stop-slop --help
Step 2: Process your text
The quickest way is to process clipboard content. Copy your AI-generated text, then run:
stop-slop --clipboard
The tool reads from your clipboard, processes the text, and writes the result back. Just paste it wherever you need it.
If your text is in a file:
stop-slop input.txt output.txt
Batch processing multiple files:
stop-slop file1.txt file2.txt file3.txt
Step 3: Review the output
After processing, the tool reports what it changed: "Replaced 12 transition words, removed 5 unnecessary emphasis markers, converted 3 passive constructions to active voice." Read through the result to make sure the meaning is intact.
That's the whole workflow. Copy, run, paste. One minute.
3. Advanced Usage
The basics cover most situations. If you need more control, here's where to go next.
Custom rule sets
stop-slop lets you define your own rules via a .stop-slop.yaml configuration file in your project root:
# .stop-slop.yaml
rules:
# Transition words to remove
remove_connectors:
- "Additionally"
- "Furthermore"
- "Moreover"
- "In addition"
# Phrases to replace or remove
replace_phrases:
"It is important to note that": ""
"Critically": ""
"Significant improvement": "improvement"
# Structural adjustments
passive_to_active: true
remove_redundant_intros: true
Once configured, every run of stop-slop in that project directory applies your custom rules automatically.
Git workflow integration
If your team uses Git, you can integrate stop-slop into your pre-commit hook so text files are automatically cleaned before each commit. Using the pre-commit framework:
# .pre-commit-config.yaml
repos:
- repo: https://github.com/hardikpandya/stop-slop
rev: v1.0.0
hooks:
- id: stop-slop
types: [text]
args: ['--config', '.stop-slop.yaml']
This enforces consistent writing standards across the team without anyone having to remember to run the tool manually.
Python API
For programmatic use—processing user feedback, cleaning auto-generated reports, integrating into a content pipeline:
from stop_slop import process_text
original = "Additionally, it is important to note that this feature is critically important."
result = process_text(original)
print(result)
# Output: "This feature is important."
This is useful when you need to process large volumes of text automatically.
4. Scenario-Specific Usage
Different types of writing call for different levels of intervention.
Technical documentation
Technical docs need to be clear and direct, not flowery. For this use case, the aggressive mode works well:
stop-slop --aggressive tech_doc.txt output.txt
The aggressive mode is more aggressive about removing filler—phrases like "Let's dive deeper into..." or "This is a fascinating topic" that add no informational value.
Marketing copy
Marketing writing needs to retain some energy and personality. You don't want to sand off all the tone. Use gentle mode:
stop-slop --gentle marketing_copy.txt output.txt
Gentle mode makes minimal changes, removing only the most obvious AI patterns while preserving the original's voice and style.
Work emails should be concise and sound like they came from a human being. AI-ness in email is especially off-putting:
stop-slop email_draft.txt --output-format plain
The --output-format plain flag strips all formatting and outputs clean text, ready to paste directly into your email client.
Code comments
Comments need to be precise. When processing files that contain code blocks:
stop-slop comments.txt --preserve-indentation
--preserve-indentation ensures the tool doesn't mess with whitespace and formatting inside code blocks.
5. Real-World Examples
Example 1: A content creator's workflow
Xiao Wang runs a tech company's social media account and publishes three posts per week. He uses AI to draft content quickly but found himself spending almost as much time "de-AI-ing" the drafts as it would have taken to write from scratch.
He added stop-slop to his workflow: AI generates the draft → stop-slop --clipboard cleans it up → he does a final manual pass for tone and brand voice.
His time per post dropped from 40 minutes to about 15 minutes. "The tool handles the mechanical stuff—transition words, emphasis markers, passive voice. I focus on adjusting the tone to match our brand." His engagement metrics stayed consistent, which suggests the cleaned-up text reads as authentically human.
Example 2: Standardizing team documentation
A six-person startup engineering team was producing a lot of internal documentation—design specs, meeting notes, technical decisions. Writing styles varied wildly. Some engineers wrote terse, dry specs. Others wrote verbose, meandering documents. AI assistance made it worse: AI-generated text has a very consistent (and very artificial) style that stood out sharply against human-written sections.
The tech lead introduced stop-slop as a standardization step. Three things they did:
- Created a team-wide
.team-stop-slop.yamlbanning phrases like "It is worth noting that" and "In summary," and requiring active voice throughout. - Integrated stop-slop into their GitBook-based doc platform so every save triggers an automatic pass.
- Added a monthly review to their tech talks: look at the documents stop-slop changed the most, and discuss why AI kept producing those patterns.
Three months in, the team reported: "Writing docs is easier now. We just write in plain language and the tool handles the cleanup."
6. Effectiveness Data
Based on publicly available information from the project and user feedback:
Processing speed: A single file under 10,000 words processes in under 1 second. Batch processing 100 files (~500,000 words total) takes approximately 2 minutes.
Edit rate: AI-generated text typically sees 5%–15% of its content modified by stop-slop. The exact rate depends on the model and text type. GPT-4 output tends to have a higher edit rate than GPT-3.5 because GPT-4 is more "formal" in its register.
Readability improvement: According to the project's test data, processed text scores 10–15 points higher on the Flesch Reading Ease scale. A text that originally scored 50 (fairly difficult) typically lands at 60–65 (standard/easy) after processing.
User satisfaction: In an informal poll in the project's GitHub Discussions:
- ~70% of respondents said the processed text "sounds noticeably more natural"
- ~20% said "some manual adjustment still needed"
- ~10% said "it went too far"
7. Common Pitfalls
A few things to watch out for.
Pitfall 1: Don't treat it as fully automated. stop-slop fixes style, not substance. If your AI-generated text contains factual errors or logical gaps, the tool won't catch them. Always read through the output and verify accuracy.
Pitfall 2: Don't over-configure your rules. It's tempting to load up your rule file with every pattern you can think of. This leads to conflicting rules and false positives—the tool "correcting" things that were fine. Start with the default rules, add new ones one at a time, and check the results after each addition.
Pitfall 3: Watch your encoding. If your text files use GBK encoding (common on Windows), you may get garbled output. Make sure files are UTF-8, or pass --encoding gbk explicitly.
Pitfall 4: Be careful with code files. stop-slop is designed for natural language. If your document contains code snippets, the tool may try to "fix" them. Either extract code blocks before processing, or use --exclude-pattern and --include-pattern to control exactly which files get processed.
Pitfall 5: Keep team rules consistent. If multiple people on a team use stop-slop with different rule sets, the output will be inconsistent. One person's config deletes "Additionally"; another's replaces it with "Also." Readers will notice the style shifts. Agree on a shared rule set.
8. Pro Tips
For those who've been using stop-slop for a while and want to get more out of it.
Tip 1: Build a personal whitelist. Some phrases that stop-slop flags may be legitimate in your context. Create a custom dictionary:
# custom_dictionary.yaml
whitelist:
- "Nevertheless" # Sometimes genuinely needed
- "In summary" # Acceptable in presentation decks
Tip 2: Pair it with a grammar checker. stop-slop handles style; tools like LanguageTool or Grammarly handle grammar and spelling. Use both: stop-slop first to remove AI patterns, then a grammar checker to catch mechanical errors.
Tip 3: Automate with pre-commit. If you manage documents in Git, set up a pre-commit hook that runs stop-slop automatically. Zero manual effort after the initial setup.
Tip 4: Use replacement, not just removal. Sometimes deleting a transition word leaves a sentence fragment. Instead of just removing, set up replacements:
replace_phrases:
"Additionally,": "Also,"
"Furthermore,": "And"
This removes the AI flavor while keeping the sentence intact.
Tip 5: Write a batch script for large-scale processing. If you have many documents to clean up:
#!/bin/bash
for file in ./docs/*.md; do
echo "Processing $file"
stop-slop "$file" "$file.clean"
mv "$file.clean" "$file"
done
Processes an entire directory in seconds.
9. Maintenance
A few habits to keep the tool working well over time.
Update regularly. stop-slop is under active development. New rules and bug fixes land in new releases. Run pip install --upgrade stop-slop periodically.
Review your rules. As your use cases evolve, your rule set should too. Set aside 30 minutes each month to look at what the tool has been changing most often. Are the rules still appropriate? Are there new patterns to address?
Back up your config. If you've customized your rule set, back it up. Store it in your Git repo or sync to cloud storage. Rebuilding a config from scratch after a system reinstall is annoying.
Follow the project. The GitHub Issues and Discussions sections are active. Users share new rules, flag edge cases, and post workflow tips. Worth checking in on occasionally.
10. Wrapping Up
stop-slop is a focused, practical tool for a specific problem: AI-generated text that sounds like AI-generated text. It's simple to install, fast to run, and effective at what it does.
Three pieces of advice:
- Treat it as an assistant, not an autopilot. Always review the output. The tool handles patterns; you handle meaning.
- Start with defaults, customize gradually. Don't try to build the perfect rule set on day one. Add rules as you discover recurring issues.
- Standardize across your team. If multiple people use it, agree on a shared configuration. Consistency matters.
Used well, stop-slop lets you keep the speed of AI-assisted writing without the telltale signs that make readers cringe. Write fast, clean up fast, publish with confidence.