The prompt is a request. Nobody checks the answer.

A gate is different. It reads the file after the model writes it, computes a number, and fails the check when the number misses the floor. The model can still write badly. It cannot do it silently.

One file, no network

grai-gate is a single Python file with no dependencies outside the standard library. It imports re, sys, json and math. It never opens a socket, never reads an API key, never writes a cache file.

It runs in three places:

• A command line: pipx run grai-gate README.md
• A pre-commit hook, before the commit lands.
• A GitHub Action, on the pull request.

The analyzer is the same in all three. Only the wrapper changes.

What it measures

The core metric is sentence-length burstiness:

CV = standard deviation of words per sentence / mean words per sentence

A draft that alternates a 6-word line with a 30-word explanation gets a high CV. A draft where every sentence runs 14 to 18 words gets a low one.

The thresholds come from a 134,522-post study:

The gate needs at least four sentences and a mean length of four words before it computes a CV. A three-line stub has no measurable rhythm, so the gate stays quiet instead of inventing one.

The structural checks

Vocabulary lists age fast. Structure changes slowly, so the gate checks structure.

The dead lexicon is deliberately small. A long list produces false positives on technical writing, and a false positive teaches the team to skip the gate.

How the score works

The score starts at 100. Each flag subtracts a fixed penalty. A hard flag caps the result below the pass mark even when the arithmetic would pass.

score = max(0, 100 - sum(penalties))
pass = score >= 85 and hard_flags == 0

The pass condition has two parts for a reason. A draft can collect several soft flags, score 86, and still fail because one hard flag fired. The team sees one number in CI and one honest verdict underneath.

What the analyzer ignores

False positives kill adoption, so the parser strips the parts that are not prose:

• Fenced code blocks and inline code.
• YAML frontmatter at the top of the file.
• Link URLs. Link text survives.
• Images.
• Table separator rows.
• Headings for the cadence math. Headings still get scanned for tells.

A README full of commands should not fail because the commands look like short sentences.

The report card

A failing file prints one compact card:

[grai-gate] Slop Score: 64/100 (CV: 0.27 | Flags: 2)
- Worst offender: flat cadence ("CV 0.27 across 12 sentences")
- Tells detected: flat cadence, zombie words (x2)
- Fix prompt: "Rewrite to increase sentence burstiness (target CV > 0.45) and eliminate flat cadence, zombie words."
- Pro Cockpit: Full Voice DNA & repair workbench at https://grai.page?utm_source=hashnode&utm_medium=article&utm_campaign=gate_v0.1#developer

A clean file prints nothing by default. That matters. A gate that prints on every run becomes noise, and noise gets muted.

Install it in a repo

One command:

pipx run grai-gate README.md

Pre-commit:

repos:
  - repo: https://github.com/adrianpeticila/grai-gate-action
    rev: v0.1.5
    hooks:
      - id: grai-gate

GitHub Actions:

- uses: adrianpeticila/grai-gate-action@v0.1.5
  with:
    fail-on-slop: "false"

The Action is advisory by default. It scores only files changed in the pull request, and it writes the card to the workflow summary, so the reviewer sees it on the checks page without opening the job log. Set fail-on-slop: "true" when the team wants a hard gate.

The command line exits 0 on clean, 1 on slop, and 2 on an input error. That contract lets any CI system consume it without parsing text.

Why CI and not a writing app

A writing app catches the draft the writer remembers to paste. CI catches every markdown file the team ships, and it catches the ones an agent wrote at 2am when nobody was watching.

The gate also runs before the commit, which is the last moment the writer still has context. A failure there costs one edit. A failure in review costs a round trip.

Limits

The gate judges cadence, not truth. It cannot tell whether a claim is correct, a quote is real, or a number is sourced.

It also cannot hear intent. A manifesto written in short declaratives may score low and still be right for the piece. The gate reports, and a person decides.

And it only sees files. A pull request description typed in a browser never reaches disk, so the gate never scores it.

It is a style gate, not an authorship detector. On the v2 corpus, it flagged 7 of 63 model docs and 3 of 58 human docs.

The point

A prompt asks a model to behave. A gate measures whether it did. The second one survives a model upgrade, a new teammate, and a deadline.

The engine is MIT and one file. Run it on your worst README and see whether the number matches your read.

pipx run grai-gate README.md

Repo: https://github.com/adrianpeticila/grai-gate-action

If you want the full calibration workbench behind the gate, it lives at https://grai.page?utm_source=hashnode&utm_medium=article&utm_campaign=gate_v0.1#developer