# Fixing Fragmented Sentences and Staccato Writing Styles with Stop‑Slop

> Fix fragmented sentences and staccato writing styles. Stop-Slop uses declarative markdown rules to eliminate AI filler, clichés, and monotony with automated rewrites.

- Repository: [Hardik Pandya/stop-slop](https://github.com/hardikpandya/stop-slop)
- Tags: how-to-guide
- Published: 2026-05-26

---

**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`](https://github.com/hardikpandya/stop-slop/blob/main/SKILL.md):

1. **Rule ingestion** – The LLM reads the metadata header and eight core rules from [`SKILL.md`](https://github.com/hardikpandya/stop-slop/blob/main/SKILL.md).
2. **Pattern matching** – The model scans text against [`references/phrases.md`](https://github.com/hardikpandya/stop-slop/blob/main/references/phrases.md) (filler words and adverbs) and [`references/structures.md`](https://github.com/hardikpandya/stop-slop/blob/main/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`](https://github.com/hardikpandya/stop-slop/blob/main/SKILL.md) | Central rule set, quick-check checklist, and scoring rubric |
| [`references/phrases.md`](https://github.com/hardikpandya/stop-slop/blob/main/references/phrases.md) | Exhaustive catalog of filler phrases, AI-tells, and redundant adverbs to excise |
| [`references/structures.md`](https://github.com/hardikpandya/stop-slop/blob/main/references/structures.md) | Structural clichés causing staccato rhythm, including binary contrasts and sentence fragmentation patterns |
| [`references/examples.md`](https://github.com/hardikpandya/stop-slop/blob/main/references/examples.md) | Concrete before/after transformations illustrating proper flow correction |
| [`README.md`](https://github.com/hardikpandya/stop-slop/blob/main/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:

```text
Add folder → Stop‑Slop/

```

Once added, every prompt processed by Claude automatically respects the rules defined in [`SKILL.md`](https://github.com/hardikpandya/stop-slop/blob/main/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:

```text
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:**

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

```

**Model output:**

```text
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:

```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`](https://github.com/hardikpandya/stop-slop/blob/main/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`](https://github.com/hardikpandya/stop-slop/blob/main/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`](https://github.com/hardikpandya/stop-slop/blob/main/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`](https://github.com/hardikpandya/stop-slop/blob/main/SKILL.md), [`references/phrases.md`](https://github.com/hardikpandya/stop-slop/blob/main/references/phrases.md), etc.), it is **language and platform agnostic**. You can paste the contents of [`SKILL.md`](https://github.com/hardikpandya/stop-slop/blob/main/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`](https://github.com/hardikpandya/stop-slop/blob/main/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.