Applying Stop Slop Guidelines to Technical Documentation: A Complete Workflow

To apply Stop Slop guidelines to technical documentation, import the SKILL.md rules into your LLM workflow, reference the phrase and structure catalogs from the repository, and enforce quality gates using the 50-point scoring rubric.

The hardikpandya/stop-slop repository provides a declarative editorial skill set designed to strip AI-generated filler patterns from prose. By integrating these guidelines into your technical writing pipeline, you ensure documentation remains direct, human-centric, and free from formulaic structures that undermine reader trust.

Understanding the Stop Slop Repository Structure

The repository organizes its editorial rules into five discrete components. Each file serves a specific function in the cleanup workflow:

• SKILL.md – Acts as the primary entry point and contains the core rule set, quick-check checklist, and metadata triggers that activate the skill within an LLM context.
• references/phrases.md – Catalogues exhaustive lists of filler phrases, adverbs, business jargon, and meta-commentary that must be removed according to the guidelines.
• references/structures.md – Defines structural patterns including binary contrasts, negative listings, and dramatic fragmentation that produce a formulaic, AI-like tone.
• references/examples.md – Provides concrete before-and-after transformations illustrating how the rules clean real-world text.
• README.md – Contains the high-level overview, quick-start instructions, and the scoring rubric used to audit output quality.

According to the hardikpandya/stop-slop source code, this modular architecture allows teams to load specific rule sets as needed—importing only phrases.md for adverb removal, for example, or the complete skill for comprehensive editing.

Integrating Stop Slop into Your Documentation Workflow

Applying Stop Slop guidelines requires a five-step integration process that moves from skill import to automated enforcement:

1. Import the skill – Add the SKILL.md file to your LLM’s skill set. The metadata fields (trigger, author, etc.) signal the model to activate the rules when processing documentation.
2. Reference auxiliary files – Upload references/phrases.md and references/structures.md as knowledge assets. Most LLM platforms support on-demand loading of these reference catalogs.
3. Configure system prompts – Embed the quick-check checklist from SKILL.md into your system prompt, or explicitly call the skill with commands like “Apply Stop Slop to the following paragraph.”
4. Audit output quality – Evaluate generated text against the scoring rubric defined in README.md. The system assesses five dimensions: Directness, Rhythm, Trust, Authenticity, and Density.
5. Iterate to threshold – Reprocess text through the skill until the composite score exceeds 35 out of 50. Scores below this threshold indicate excessive filler or structural slop requiring additional editing.

Because the repository contains only declarative content, you can store these files alongside your documentation source code and version them with Git.

Automating Enforcement with Code

Teams can automate Stop Slop enforcement by wrapping the skill in API calls or CI pipelines. Below are reference implementations for both interactive and automated workflows.

Python Wrapper for Claude API

The following script demonstrates how to programmatically apply the skill using Python and the Anthropic API:

import os
import json
import requests

# Load the skill folder (assumes it is zipped and hosted locally)

SKILL_PATH = "path/to/stop-slop"
API_URL = "https://api.anthropic.com/v1/complete"

def apply_stop_slop(text: str) -> str:
    """Send *text* to Claude with the Stop Slop skill enabled."""
    payload = {
        "prompt": f"<skill>{SKILL_PATH}</skill>\n{text}",
        "max_tokens": 1024,
        "stop_sequences": ["\n\n"],
        "temperature": 0.0,
    }
    headers = {"x-api-key": os.getenv("ANTHROPIC_API_KEY")}
    resp = requests.post(API_URL, json=payload, headers=headers)
    resp.raise_for_status()
    return resp.json()["completion"]

# Example usage

raw = """Here's the thing: building products is hard. Not because the technology is complex. Because people are complex. Let that sink in."""
clean = apply_stop_slop(raw)
print(clean)

This implementation assumes the skill folder is accessible via the <skill> directive. Replace the placeholder with the specific mechanism provided by your LLM platform.

GitHub Actions CI Pipeline

For continuous integration, use a workflow that lints all Markdown files and fails the build if quality scores fall below the threshold:

name: Documentation Lint
on:
  push:
    paths:
      - '**/*.md'

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Install Claude CLI
        run: pip install anthropic-cli   # placeholder for actual client

      - name: Run Stop Slop
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          for f in $(git ls-files '*.md'); do
            cleaned=$(anthropic complete --skill ./stop-slop "$(<$f)")
            score=$(python score.py "$cleaned")     # score.py implements the rubric

            if (( score < 35 )); then
              echo "::error file=$f::Score $score < 35 – needs revision"
              exit 1
            fi
          done

The action iterates over all Markdown files, processes them through the skill, and aborts the workflow if the post-process score is unacceptable.

Evaluating Quality with the Stop Slop Scoring Rubric

The README.md file defines a scoring system that quantifies editorial quality across five distinct axes:

• Directness – Measures the ratio of actionable content to hedging language.
• Rhythm – Assesses sentence length variation and avoidance of repetitive cadence.
• Trust – Evaluates the removal of hyperbolic claims and unsupported assertions.
• Authenticity – Checks for personal voice and the absence of generic corporate speak.
• Density – Calculates information concentration per paragraph.

Documentation must achieve a minimum composite score of 35 out of 50 to pass the quality gate. Scores below this threshold trigger revision requirements, ensuring that only refined, human-centric content reaches production.

Summary

• The hardikpandya/stop-slop repository provides a modular skill set for eliminating AI-generated filler from technical documentation.
• Key files include SKILL.md (rules), references/phrases.md (filler catalog), and references/structures.md (pattern definitions).
• Integration requires importing the skill into your LLM workflow, referencing auxiliary files, and applying the 50-point scoring rubric.
• Automation is straightforward through Python API wrappers or CI pipelines that enforce the 35-point quality threshold.
• The declarative nature of the rules allows version control and customization for specific technical domains.

Frequently Asked Questions

How do I integrate Stop Slop with LLMs other than Claude?

While the reference examples utilize Claude’s <skill> directive, the SKILL.md file contains plain-text declarative rules compatible with any LLM. Upload references/phrases.md and references/structures.md as knowledge assets in ChatGPT, Gemini, or other platforms, then embed the quick-check checklist in your system prompt to activate the guidelines.

What is the minimum acceptable score for production documentation?

According to the scoring rubric defined in README.md, documentation must achieve at least 35 out of 50 points across the five evaluated dimensions. Content scoring below this threshold requires additional editing to remove filler phrases and structural clichés before publication.

Which files contain the specific phrases and patterns to eliminate?

The references/phrases.md file catalogues filler adverbs, business jargon, and meta-commentary to remove. Structural patterns such as binary contrasts and dramatic fragmentation are defined in references/structures.md. Both files serve as reference catalogs during the editing process.

Can Stop Slop rules be customized for specific technical domains?

Yes. Because the repository contains only declarative markdown content, you can fork the repository and modify references/phrases.md to exclude domain-specific terminology or add industry-specific filler patterns. The modular architecture allows teams to mix standard rules with custom extensions while maintaining the core scoring framework.

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