Does the scorer call an API or send my documents anywhere?

No. The scorer is standard-library Python with zero third-party dependencies. It makes no network call, needs no account and no API key, and nothing leaves the runner.

Is this an AI detector?

No. The score measures the writing, not the author. Human writing in the project corpus scores 9 to 21 and unedited AI drafts average 77, but neither number identifies who wrote a document. Do not use it to make decisions about a person.

What threshold should I use?

Start at 25 in report-only mode, look at a week of real numbers, then enforce. Teams with a house style that scores naturally high should raise it rather than rewrite around the tool.

How slow is it on a large repository?

It scored 1,000 documents in 2.1956 seconds on one Apple silicon Mac, about 455 documents per second, and a 15,201-word document in 0.3225 seconds. On a typical docs directory the gate is faster than the checkout that precedes it.

Slop score in CI: gate a docs build on prose quality

Your CI already rejects a type error, an unformatted file and a failing test. It accepts a README that reads like a press release. Zero Slop closes that gap: one command scores every document in a directory from 0 to 100 and exits non-zero above a threshold you pick.

python3 slopscore.py --batch docs/ --json --gate 25

Exit 0 when every file is under the gate, 1 when any file is at or above it. That is the whole contract, and it is the only thing a build step needs.

What it costs to run

Nothing you have to provision. The scorer is a single standard-library Python program with zero third-party dependencies, so there is no lockfile to maintain and no supply chain to audit. It makes no network call, needs no account and no API key, and no document leaves the runner — which is what makes it usable on a private repository without a security review.

Speed is not the interesting part, but it is the part people ask about: 1,000 documents in 2.1956 seconds on one Apple silicon Mac, about 455 per second, and a 15,201-word document in 0.3225 seconds. On a normal docs directory the gate finishes before the checkout that preceded it.

GitHub Actions

The whole job. Pin the release you tested against rather than tracking main, the way you would pin any other check.

name: prose

on: [push, pull_request]

jobs:
  slop:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
      - uses: actions/setup-python@v6
        with:
          python-version: "3.11"

      - name: Install the scorer
        run: |
          curl -sSL -o zero-slop.tar.gz \
            https://registry.npmjs.org/zero-slop/-/zero-slop-2.7.6.tgz
          tar -xzf zero-slop.tar.gz

      - name: Score the docs
        run: python3 package/scripts/slopscore.py --batch docs/ --json --gate 25

No Node on the runner, no action from the marketplace with its own permissions, and nothing that can reach the network mid-job. If you would rather vendor it, the scorer and its two data files are the only runtime pieces; copy them into the repository and skip the download entirely.

Roll it out without a revolt

A gate that fails on day one against prose nobody agreed to gets switched off in a week. Run it in report-only mode first by dropping the --gate flag: the command still prints every score and still exits 0.

# Week one: measure, do not block.
python3 slopscore.py --batch docs/ --json > slop.json

# Week two: enforce at the number your own corpus already clears.
python3 slopscore.py --batch docs/ --json --gate 25

Pick the threshold from your own documents rather than from this page. For calibration: human writing in the project corpus scored 9 to 21, and unedited AI drafts averaged 77. A team whose house style sits naturally high should raise the gate, not rewrite around the tool.

Only the files that changed

On a large repository, score the diff instead of the tree. This keeps the check proportional to the pull request, which is what makes it survive on a monorepo.

git diff --name-only --diff-filter=d origin/main...HEAD \
  | grep -E '\.(md|mdx|txt)$' \
  | xargs -r -I{} python3 slopscore.py --json --gate 25 {}

Before it reaches CI

The same command works as a pre-commit hook, which is the cheaper place to catch it.

# .git/hooks/pre-commit
#!/bin/sh
git diff --cached --name-only --diff-filter=d \
  | grep -E '\.(md|mdx|txt)$' \
  | xargs -r python3 scripts/slopscore.py --gate 25

What the gate does not do

It does not decide whether a document is true, whether the ideas are any good, or who wrote it. The score describes writing. A page can score 4 and be wrong about everything, and the tool will not notice — only a reader will.

It is not an AI detector, and it should never be pointed at a person. The number moves with phrasing, rhythm and formatting, all of which a human writer can produce and a careful model can avoid. Using it to accuse someone of using AI is a misuse the benchmark page is explicit about.

The editing half

The gate tells you a document failed. The skill fixes it, inside the agent you already use, under a fact gate that rejects any rewrite changing a name, number, quotation or link.

npx skills add manavmishra/ZeroSlop --global
# then, in Claude Code, Codex, Cursor, Warp, OpenCode or Zed:
/zero-slop docs/architecture.md

Everything on this page is MIT licensed and reproducible from the repository. The scoring method and its limits are documented on the benchmark page.

Fail the build on bad prose.