Catch the junk AI leaves in your code.

Your linter can't see // ... rest of code unchanged. ESLint, Ruff, and Clippy throw away comment and string content before analysis: exactly where AI coding artifacts live. stopslop reads what they discard: leaked chat preambles, elision comments that silently deleted code, stray markdown fences, placeholder credentials, and package imports that don't resolve to anything you declared. It reads your prose too: Markdown, MDX, plain text, reST, and HTML get the same deterministic treatment. One static binary, no LLM at scan time: same input, same output, every run.

• One fast static binary, zero config to get started.
• Deterministic: no LLM calls, no API calls, no network access at scan time.
• Built for CI: exit codes, SARIF, JSON, and inline suppressions.

ESLint, Ruff, and Clippy parse comments and strings as trivia their default rule sets don't inspect, which is exactly where copy-pasted chat output and truncated edits land. A few examples:

stopslop is a deterministic linter for TypeScript, Python, Go, and Rust. Every rule is a tree-sitter AST match or a regex over extracted comments/strings: same input, same output, every time. This is a quality gate that also names AI tells: it flags patterns that are junk regardless of who (or what) produced them, and patterns that are known giveaways of machine-generated text or code, so you can rewrite either. It never scores a file as "written by AI" and never needs a model to say so.

cargo install stopslop

Once a day, an outdated install prints a one-line update notice to stderr (never in CI, never for --format json|sarif|markdown, never when stderr is not a terminal). Set STOPSLOP_NO_UPDATE_CHECK=1 (or NO_UPDATE_NOTIFIER=1) to turn it off.

Alternatives:

# latest main, for a merged-but-unreleased fix
cargo install --git https://github.com/mgiovani/stopslop

# local checkout, for hacking on stopslop itself
git clone https://github.com/mgiovani/stopslop
cd stopslop
cargo install --path .

stopslop                          # lint the current directory
stopslop src/ lib/                 # lint specific paths
stopslop --format json .           # machine-readable output
stopslop --stats .                 # files/lines scanned, wall time, throughput (stderr)
stopslop -j 1 .                    # single worker thread (perf work; 0 = automatic)
stopslop --select SLOP001          # run only the elision rule
stopslop --select rhetoric         # run one rule group (see "Rule groups" below)
stopslop --select ALL              # every rule (SLOP010 still needs --check-imports)
stopslop --ignore SLOP008          # run everything except stub detection
stopslop --select artifact --extend-select SLOP033  # add a rule on top of a narrower select
stopslop --list-rules              # print every rule with its group, tier, and default
stopslop --check-imports .         # also run SLOP010 (unresolved import) — opt-in
stopslop --config path.toml        # use a specific config file instead of the discovered one
stopslop --no-config               # ignore any project or user-level stopslop.toml, CLI flags only
stopslop --write-baseline .        # record today's findings (see "Baseline" below)
stopslop --baseline .              # report only findings that aren't in the baseline
stopslop --staged                  # lint what is about to be committed (index content, not disk)
stopslop --changed                 # staged + unstaged changes against HEAD
stopslop --since origin/main       # files changed on this branch, for PR checks

Example output:

--format json emits a flat array of findings; --format sarif emits a SARIF 2.1.0 document for GitHub code scanning and similar tools; --format markdown emits the findings grouped under one heading per tier, for pasting into a PR comment or a report. --stats prints a files/lines/wall-time/throughput summary to stderr in text and markdown modes; with --format json the output becomes {"findings": [...], "stats": {...}}, and with --format sarif the same object lands in runs[0].properties.stats. Wall time runs from startup through the walk, so it lines up with an external time. "skipped" counts files the walk reached but could not lint (unsupported extension or unreadable); paths dropped by .gitignore or exclude are never walked and are not counted.

SLOP0NN numbers are chronological, not thematic, so a numeric prefix can't express "just the rhetoric rules". Named groups can. They work anywhere a rule code or prefix does, including --select, --ignore, and the select/ignore keys in stopslop.toml:

stopslop --select artifact,structure   # the mechanical, high-confidence rules only
stopslop --select SLOP --ignore verbosity  # everything except the density rules

Every rule belongs to exactly one group; a test enforces that the table stays exhaustive, so a new rule can't quietly escape group selection. --list-rules prints the full mapping.

ALL is a reserved selector, not a group: --select ALL (or select = ["ALL"] in config) runs every registered rule plus any [[custom-rule]] entries from your config. SLOP010 is the one exception: it stays off until --check-imports is passed.

Turning stopslop on for an existing codebase usually surfaces findings nobody plans to fix today. A baseline grandfathers them so CI only fails on findings that are new:

stopslop --write-baseline .   # writes .stopslop-baseline.json, exits 0
stopslop --baseline .         # later runs report only what isn't in it

Use --baseline=path.json / --write-baseline=path.json for a different file (the = is required, so a bare --baseline doesn't swallow your scan path), or set baseline = ".stopslop-baseline.json" in stopslop.toml.

Findings are matched by a fingerprint of code + path + message with digits normalized out, not by line number, so editing above a finding doesn't resurrect it and a density count drifting by one doesn't either. Paths are normalized as well, with a leading ./ stripped, so a baseline written from git ls-files (foo.md) still matches a stopslop . run (./foo.md). The file stores a count per fingerprint: if a file has three accepted findings from one rule, it absorbs exactly three, and a fourth is reported. Fix one and the budget shrinks with it. The count ratchets down on its own; raising it takes a deliberate --write-baseline.

Commit the baseline file so CI and local runs agree.

--staged, --changed, and --since REF (mutually exclusive) replace the walk with a git-selected file list, so linting scales with the size of a diff instead of the whole tree. Positional paths, if given, act as git pathspecs (stopslop --staged src/ lints only staged files under src).

• --staged reads each file's staged content (git show :./path), so a partially staged file is checked as it will be committed, not as it sits on disk.
• --changed includes both staged and unstaged changes against HEAD; untracked files are not included.
• --since REF diffs against the merge base of REF and HEAD (git 2.30+), so REF advancing after the branch forked doesn't pull in its changes. Built for stopslop --since origin/main on a PR.
• An empty selection exits 0. All three compose with --baseline, exclude, and [per-file-ignores] exactly like a normal scan.

Pre-commit hook: stopslop --staged.

Every rule is exactly one of three states, --list-rules prints the DEFAULT column so you can check any given rule at a glance:

• Tier A, on by default (12 rules): mechanical artifacts (SLOP001–009, SLOP011–013) with no legitimate reading. A finding here fails the run (exit 1) and blocks CI.
• Tier B, on by default (28 rules): everything else except SLOP010. Judgment calls (density and style checks on prose, stdlib/structure heuristics) that warn without ever exiting 1. Expect some noise; silence what you don't want with ignore/--ignore by code or group.
• Tier B, off by default (1 rule): SLOP010, gated behind --check-imports because of its false-positive risk with private registries and dynamic imports.

Tier is a fixed property of each rule, and select/ignore can't change it. What you can change is which tier the run fails on: fail-on-tier = "B" in stopslop.toml (or --fail-on-tier B) puts every finding on the exit-1 path. CHANGELOG.md records which rules changed tier between releases.

Findings that have one concrete replacement print it on a second line:

src/util.ts:14:11 SLOP037 deep clone via a JSON round trip
    fix: use `structuredClone(value)`

--format json carries the same text in a fix field, omitted when a rule flags a document-wide pattern with no single substitutable span.

Note on SLOP007: a bare x as unknown is not flagged on its own: it's a legitimate first step in TypeScript's narrowing idiom. Only the chained form, x as unknown as T, is flagged, since that's the pattern that fully defeats the type checker.

stopslop also lints .md, .mdx, .txt, .rst, and .html/.htm files: same binary, same deterministic regex/structural matching, no LLM involved in the scan.

HTML is parsed with tree-sitter-html, and the rules see what a reader sees: visible text, HTML comments, and href/src attribute values. Everything else is blanked, including <script>, <style>, <pre>, <code>, <textarea>, <template>, <svg>, <math>, and <noscript> bodies. Django/Jinja {{ … }}, {% … %}, and {# … #} are blanked before parsing too. Each leaf block element (<p>, <div>, <blockquote>, <td>) is one paragraph for the rhythm, recap, synonym, and uniformity rules; list items, headings, table cells, and form controls never are, and a <footer> is never the ending. <strong>/<b> count as bold, inline <code> counts as words, and —, —, and the curly-quote entities are read as the characters they encode. – and every other entity stay blank.

SLOP011–013 catch mechanical, high-confidence artifacts (leftover chat-turn phrasing including reasoning-chain scaffolding and acknowledgment loops, citation-tool tokens, unfilled placeholders) and are Tier A: a finding there fails the run. SLOP014, SLOP018, and the formulaic-shape rules SLOP022–025 and SLOP029 are on by default too but Tier B, warn-only: judgment calls the tool still surfaces every run, just without the power to fail CI. SLOP018 flags every mid-prose dash outright (the one exemption is a block-opening attribution dash like — Oscar Wilde).

The rest are document-wide density and style checks, also on by default: hedging, overused vocabulary, rhetorical parallelism, boldface overuse, smart quotes, heading formatting, promotional register, hyphen stacking, sentence length, synonym rotation, outline filler, change-narrating docs, colon reveals, filler and adverb density, weak-verb phrasing, dramatic fragmentation, and mechanical uniformity. SLOP041 is the one rule in this list that measures statistics (burstiness, vocabulary diversity, trigram repetition) instead of matching a phrase. It catches templated prose that rotates its vocabulary just enough to slide past every phrase-based rule. These are judgment calls rather than mechanical certainties, so they're warn-only. Silence the ones you don't want by code (--ignore SLOP015) or by group (--ignore verbosity). Expect some noise from them: a finding here is a lead to investigate rather than a verdict. As with the rest of stopslop, this is a writing-quality gate, not a claim about who or what wrote the text: every rule flags a concrete pattern (a stale phrase, an unfilled slot, a density threshold, a document-level statistic), never "this is AI-generated."

Every rule runs every natural-language panel it declares, on every document, by default: nothing to configure, nothing to detect. Lang is the file syntax (Markdown, MDX, ...); NatLang is a separate axis for which lexicons a rule's phrase panels actually cover, listed per rule in the NL column above. Structural and statistical rules (AST shape, punctuation, density) need no lexicon and already run on pt-BR text. Phrase-panel rules gain a pt-BR panel one rule at a time, each proven by a fixture under tests/fixtures/markdown/pt-br/ before the rule may list pt-BR; SLOP014 (cliché phrases), SLOP016 (vocabulary), and SLOP032 (hyphenated-compound overuse) still stay English-only, and issue #30 tracks the rest. pt and pt-PT both resolve to the same Brazilian lexicon as pt-BR, a best-effort alias rather than a separate European-Portuguese panel. An HTML page that declares <html lang="..."> narrows its own run to that language when the config allows it (.rst docinfo and Markdown front matter carry no such hint yet). SLOP033's overlong-sentence cap rises to 57 words once a run is Portuguese-only (language = "pt-BR", measured against English's 50 on matched corpora). SLOP041's thresholds hold as measured (Portuguese trips them less often than English, not more); SLOP043 and SLOP029's caps are still unmeasured for Portuguese, and language = "pt-BR" in stopslop.toml restricts a run to the Portuguese panels only.

Two escape valves, both plain comments so they work in any language's comment syntax:

• // ai-slop-ignore: suppresses findings on that line and the line below it (so it works whether the comment is trailing or sits above the flagged line).
• // ai-slop-ignore-file: anywhere in the file, drops every finding in that file.

In Markdown/MDX/Text/reST/HTML files, use the HTML comment form instead: <!-- ai-slop-ignore --> / <!-- ai-slop-ignore-file -->, with the same two-line and whole-file suppression semantics.

Bare, either directive suppresses every rule. Add : CODE,CODE (commas or spaces both work) to scope it to specific rules, or to a group name:

// ai-slop-ignore: SLOP002,SLOP004
// Certainly! Generated by ChatGPT — kept verbatim as a fixture for this rule's own test

<!-- ai-slop-ignore-file: SLOP018 

Read the rest on GitHub