Fixing Fragmented Sentences and Staccato Writing Styles with Stop‑Slop

The Stop‑Slop skill eliminates fragmented sentences and staccato writing by applying declarative markdown rules that target AI-generated filler phrases, binary structural clichés, and rhythmic monotony through pattern matching and automated rewrites.

The hardikpandya/stop-slop repository provides a portable, language-agnostic "skill" designed to prune mechanical writing patterns from LLM output. By leveraging a flat file architecture contained entirely within markdown documents, this tool integrates into any writing workflow—from Claude projects to custom Python pipelines—to transform choppy, algorithmic prose into direct, rhythmically varied text.

How Stop‑Slop Fixes Fragmented and Staccato Writing

The skill operates through a four-stage enforcement pipeline defined in SKILL.md:

1. Rule ingestion – The LLM reads the metadata header and eight core rules from SKILL.md.
2. Pattern matching – The model scans text against references/phrases.md (filler words and adverbs) and references/structures.md (structural clichés like binary contrasts and dramatic fragmentation).
3. Rewrite – For each match, the model applies transformations such as removing throat-clearing adverbs, replacing passive voice with active subjects, breaking up three-sentence runs of identical length, and eliminating em-dashes that cause fragmentation.
4. Scoring – The output is evaluated against five dimensions (Directness, Rhythm, Trust, Authenticity, Density). Scores below the 35/50 threshold trigger a second refinement loop until the text meets the density and flow standards.

Because the rules are expressed in plain English without executable scripts, the skill is environment-agnostic—any LLM capable of reading markdown can enforce these editorial standards.

Core Files and Reference Architecture

The repository uses a self-contained, declarative structure with no runtime dependencies:

File Path	Purpose
SKILL.md	Central rule set, quick-check checklist, and scoring rubric
references/phrases.md	Exhaustive catalog of filler phrases, AI-tells, and redundant adverbs to excise
references/structures.md	Structural clichés causing staccato rhythm, including binary contrasts and sentence fragmentation patterns
references/examples.md	Concrete before/after transformations illustrating proper flow correction
README.md	High-level introduction and quick-start instructions

All reference data lives in the references/ folder, allowing you to extend the skill for specific domains (e.g., technical writing or legal drafting) by editing plain text lists without modifying the core logic.

Implementation Methods

You can deploy Stop‑Slop through three primary integration patterns, depending on your LLM infrastructure.

Adding the Skill to a Claude Project

The simplest deployment method uses Claude’s native Skills directory:

Add folder → Stop‑Slop/

Once added, every prompt processed by Claude automatically respects the rules defined in SKILL.md, applying real-time corrections to fragmented output without additional prompt engineering.

Using Stop‑Slop as a System Prompt

For generic LLM APIs (ChatGPT, custom agents), prepend the rule set as a system instruction:

You are an editor equipped with the Stop‑Slop skill.  
Follow the core rules from SKILL.md and the phrase list in references/phrases.md.  
When you encounter fragmented sentences, staccato rhythm, passive voice, or listed fillers, rewrite the text to be direct, active, and varied.

Prompt example:

Original: "Here's what we did. The project was completed. The results are amazing."

Model output:

We completed the project, and the results are amazing.

Embedding Reference Lists in Custom Scripts

For programmatic pipelines, load the declarative rules directly into Python:

from pathlib import Path

skill_dir = Path("stop-slop")
phrases = skill_dir / "references/phrases.md"
structures = skill_dir / "references/structures.md"

def load_patterns(file_path):
    return {line.strip() for line in file_path.read_text().splitlines() if line.strip()}

phrase_set = load_patterns(phrases)
structure_set = load_patterns(structures)

def apply_stop_slop(text):
    # Strip exact filler matches from phrases.md

    for phrase in phrase_set:
        text = text.replace(phrase, "")
    # Additional logic for structural rewrites from structures.md would follow

    return text.strip()

This approach leverages the static markdown assets to sanitize text without importing external libraries or executing untrusted code.

Summary

• Stop‑Slop is a declarative markdown skill in hardikpandya/stop-slop that fixes fragmented, staccato writing through pattern matching against curated phrase and structure lists.
• The system enforces eight core rules defined in SKILL.md, targeting passive voice, adverb bloat, em-dash overuse, and rhythmic monotony.
• A 35/50 scoring threshold across five dimensions (Directness, Rhythm, Trust, Authenticity, Density) ensures output quality through automated refinement loops.
• Integration requires no executable code—simply reference SKILL.md and the references/ directory in Claude projects, system prompts, or custom scripts.

Frequently Asked Questions

How does Stop‑Slop identify staccato writing patterns?

According to the source files in hardikpandya/stop-slop, the skill identifies staccato rhythms by detecting three-sentence runs of identical length and binary structural clichés (e.g., "not just X, but Y") listed in references/structures.md. The model then merges or varies these sentences to restore natural cadence.

Can I use Stop‑Slop with LLMs other than Claude?

Yes. Because the skill consists entirely of static markdown files (SKILL.md, references/phrases.md, etc.), it is language and platform agnostic. You can paste the contents of SKILL.md into any LLM system prompt, or parse the reference lists programmatically in Python, Node.js, or other environments.

What is the significance of the 35/50 scoring threshold?

The threshold defined in SKILL.md represents the minimum acceptable aggregate score across the five quality dimensions. If a text passage scores below 35 points (out of 50 possible), the skill triggers a second refinement loop, rewriting the content until it achieves sufficient Directness, Rhythm, and Density.

Is Stop‑Slop safe to use in production environments?

Yes. The repository contains no executable scripts or compiled code—only markdown documentation. This flat, declarative design ensures the skill can be safely added to constrained environments, chat prompts, or version-controlled pipelines without introducing dependency conflicts or security vulnerabilities.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}