# Patterns to Cut in SKILL.md: The Complete Technical Reference for Eliminating AI Slop

> Discover 'Patterns to cut' in SKILL.md to eliminate AI slop. Learn 18 stylistic clichés that make writing sound generic and robotic. Improve your prose today.

- Repository: [Peter Yang/no-ai-slop](https://github.com/petergyang/no-ai-slop)
- Tags: api-reference
- Published: 2026-09-13

---

**The "Patterns to cut" defined in [`skills/no-ai-slop/SKILL.md`](https://github.com/petergyang/no-ai-slop/blob/main/skills/no-ai-slop/SKILL.md) enumerate 18 specific stylistic clichés—from binary contrasts and throat-clearing openers to robotic rhythms and formatting slop—that the repository's editing skill targets to remove generic, machine-sounding prose.**

The `petergyang/no-ai-slop` repository provides a deterministic framework for identifying and removing artificial writing patterns. Central to this system is [`skills/no-ai-slop/SKILL.md`](https://github.com/petergyang/no-ai-slop/blob/main/skills/no-ai-slop/SKILL.md), which serves as the authoritative catalog of linguistic tics that distinguish AI-generated filler from authentic human communication.

## The 18 Patterns to Cut Defined in SKILL.md

The complete list spans lines 54 through 88 of [`SKILL.md`](https://github.com/petergyang/no-ai-slop/blob/main/SKILL.md), organized by the type of structural or semantic problem each pattern represents.

### Opening Hooks and Framing Devices

These patterns appear at the beginning of paragraphs or sections, creating artificial drama rather than substantive content.

- **Binary contrasts** (Line 54): Constructions like "This is not X. It's Y." or "The question isn't X, it's Y." collapse false dichotomies into single, direct statements.

- **Throat-clearing openers** (Line 56): Filler phrases including "Here's the thing," "Let me be clear," or "I'll be honest" delay the actual claim without adding information.

- **Faux-insight setups** (Line 58): Self-promoting frames such as "What most people get wrong" or "Here's what nobody tells you" promise revelation without substantive setup.

- **Rhetorical setups** (Line 80): Artificial suspense builders like "What if I told you...", "Think about it:", or "Plot twist:" that frame simple facts as dramatic revelations.

### Sentence Construction Crutches

These structural habits create repetitive, mechanical rhythms characteristic of LLM outputs.

- **Colon reveals** (Line 60): The dramatic "The detail that makes it work: ..." construction abuses colons for artificial emphasis rather than their functional purposes (lists, labels, or quotations).

- **Dramatic fragmentation** (Line 76): Short, staccato fragments like "X. And Y. And Z." disrupt narrative flow and create a false sense of urgency.

- **Robotic rhythm** (Line 78): Repeated sentence shapes and stacked punchy fragments that produce a mechanical cadence rather than natural variation.

- **Em dashes** (Line 88): Overuse as a rhythmic crutch; the skill mandates limiting em dashes to 0–2 per longer draft, preferring commas, periods, or parentheses.

### Semantic Filler and Analysis Substitutes

These patterns substitute vague commentary for concrete evidence or direct statements.

- **Superficial analysis** (Line 62): Trailing "-ing" clauses (e.g., "highlighting," "underscoring") that gesture toward meaning without explaining specific cause-and-effect relationships.

- **Importance puffery** (Line 64): Grandoise declarations like "stands as a testament" or "marks a pivotal moment" tell the reader something is significant rather than demonstrating that significance through evidence.

- **Interpretive metadiscourse** (Line 66): Cues that instruct the reader how to interpret the text, such as "The key point is," "In other words," or "As you can see."

- **Fake-strong verbs** (Line 70): Inflated verb phrases like "serves as a centralized hub" instead of concrete actions like "tracks," "adds," or "generates."

### Attribution and Lexical Patterns

Issues involving sources, authority, and word choice precision.

- **Weasel attribution** (Line 68): Vague appeals to authority such as "Experts agree" or "industry reports suggest" without specific citations or sources.

- **Synonym cycling** (Line 72): Replacing clear terms with synonyms merely for lexical variety rather than precision or nuance.

### Listing and Structural Patterns

Mechanical ways of presenting comparative information.

- **Negative listing** (Line 74): The "Not a X. Not a Y. A Z." construction that defines concepts by negation rather than stating the positive outcome directly.

### Closings and Formatting

Patterns that appear at conclusions or in visual presentation.

- **Fake-profound kickers** (Line 82): Final lines that convert concrete points into cute metaphors or aphorisms to simulate depth.

- **Summary-recap endings** (Line 84): Redundant phrases like "In conclusion" or "Ultimately" that restate information the reader has already processed.

- **Formatting slop** (Line 86): Decorative elements including emojis in headings, bold mid-sentence for emphasis, bullet lists where prose is clearer, and oversized headers.

## Detecting Patterns Programmatically

The repository structure supports automated detection of these patterns. Below is a Python implementation that maps regular expressions to the specific line references in [`SKILL.md`](https://github.com/petergyang/no-ai-slop/blob/main/SKILL.md):

```python
import re
from pathlib import Path

# Pattern definitions derived from skills/no-ai-slop/SKILL.md lines 54-88

PATTERNS = {
    "binary_contrasts": r"\b(this is not|the question isn’t|it’s not just)\b.*?\b(it is|it's|its)\b",
    "throat_clearing": r"\b(here’s the thing|let me be clear|i’ll be honest|to be fair)\b",
    "faux_insight": r"\b(what most people get wrong|here’s what nobody tells you|the uncomfortable truth)\b",
    "weasel_attribution": r"\b(experts agree|industry reports suggest|studies show|many believe)\b",
    "importance_puffery": r"\b(stands as a testament|marks a pivotal moment|underscores the importance)\b",
    "colon_reveals": r"\b(the reason|the secret|the detail|the truth):\s+[a-z]"
}

def detect_ai_slop(text: str) -> dict:
    """
    Scan text for patterns defined in SKILL.md.
    
    Returns a dictionary mapping pattern names to lists of matched excerpts.
    """
    findings = {}
    for pattern_name, regex in PATTERNS.items():
        matches = re.findall(regex, text, flags=re.IGNORECASE)
        if matches:
            findings[pattern_name] = matches
    return findings

# Example usage

if __name__ == "__main__":
    draft = """
    Here's the thing: this is not a bug. It's a feature. 
    Experts agree that this stands as a testament to our process.
    The secret: we prioritized speed over perfection.
    """
    
    issues = detect_ai_slop(draft)
    for pattern, hits in issues.items():
        print(f"Pattern '{pattern}' detected: {hits}")

```

This detector targets the exact constructions listed at lines 54, 56, 58, 64, 68, and 80 of [`SKILL.md`](https://github.com/petergyang/no-ai-slop/blob/main/SKILL.md), converting the editorial guidelines into programmatic rules that can flag potential AI slop in text files.

## Supporting Files in the Repository

The pattern definitions in [`SKILL.md`](https://github.com/petergyang/no-ai-slop/blob/main/SKILL.md) operate within a broader validation framework:

- **[`skills/no-ai-slop/eval.md`](https://github.com/petergyang/no-ai-slop/blob/main/skills/no-ai-slop/eval.md)**: Contains the evaluation checklist that validates whether edits successfully removed the targeted patterns without introducing new rhetorical issues or losing semantic meaning.

- **[`README.md`](https://github.com/petergyang/no-ai-slop/blob/main/README.md)**: Provides the high-level project overview and integration context for implementing the skill in editing workflows.

Together, these files define the complete detection and remediation pipeline for the `no-ai-slop` skill.

## Summary

- The **18 patterns to cut** in [`skills/no-ai-slop/SKILL.md`](https://github.com/petergyang/no-ai-slop/blob/main/skills/no-ai-slop/SKILL.md) target specific stylistic clichés that signal AI-generated prose, cataloged between lines 54 and 88.
- **Structural patterns** include binary contrasts, throat-clearing openers, and rhetorical setups that create artificial drama at the expense of substance.
- **Sentence-level issues** encompass colon reveals, dramatic fragmentation, and overuse of em dashes as rhythmic crutches.
- **Semantic problems** range from superficial "-ing" analysis to weasel attribution and importance puffery that substitutes vague commentary for concrete evidence.
- **Programmatic detection** is achievable through regex patterns mapped to the specific line references in the source file, enabling automated flagging of AI slop.
- The skill prioritizes **direct statements** over negative listing, **concrete verbs** over fake-strong phrases, and **functional formatting** over decorative flourishes.

## Frequently Asked Questions

### What is the primary purpose of the patterns to cut in SKILL.md?

The patterns serve as a deterministic checklist for identifying and removing stylistic markers commonly associated with large language model outputs. According to the `petergyang/no-ai-slop` source code, these 18 specific constructions represent the linguistic tics that make prose sound generic, overly dramatic, or mechanically generated.

### How does the no-ai-slop skill use these patterns during editing?

The skill uses the patterns as negative constraints when processing drafts. It scans for constructions matching the definitions at lines 54–88 of [`SKILL.md`](https://github.com/petergyang/no-ai-slop/blob/main/SKILL.md) and either removes them entirely or transforms them into direct, concrete statements as specified in each pattern's remediation guidance, validated against the criteria in [`eval.md`](https://github.com/petergyang/no-ai-slop/blob/main/eval.md).

### Can these patterns be detected automatically using the repository's code?

Yes. While the repository primarily defines the patterns editorially in [`SKILL.md`](https://github.com/petergyang/no-ai-slop/blob/main/SKILL.md), the explicit line references and concrete examples enable programmatic detection using regular expressions. The Python reference implementation demonstrates how to target specific patterns—such as binary contrasts at line 54 and throat-clearing openers at line 56—to automatically flag potential AI slop.

### What distinguishes SKILL.md from eval.md in the repository?

[`SKILL.md`](https://github.com/petergyang/no-ai-slop/blob/main/SKILL.md) contains the prescriptive definitions of what to cut—the 18 specific patterns and their replacements—while [`eval.md`](https://github.com/petergyang/no-ai-slop/blob/main/eval.md) provides the evaluative framework that checks whether an edit successfully removed these patterns while maintaining the original meaning, factual accuracy, and natural flow. The skill file defines the rules; the evaluation file validates the results.