slop-chop

<p align="center">
  <img src="assets/banner.png" alt="slop-chop" width="420">
</p>

<p align="center">
  <a href="https://slop-chop.com"><img src="https://img.shields.io/badge/try_it-slop--chop.com-9bcf1a" alt="Try it at slop-chop.com"></a>
  <a href="https://github.com/dcadolph/slop-chop/releases/latest"><img src="https://img.shields.io/github/v/release/dcadolph/slop-chop?color=9bcf1a" alt="Latest release"></a>
  <a href="https://github.com/dcadolph/slop-chop/actions/workflows/ci.yml"><img src="https://github.com/dcadolph/slop-chop/actions/workflows/ci.yml/badge.svg" alt="ci status"></a>
  <a href="https://pkg.go.dev/github.com/dcadolph/slop-chop/sanitize"><img src="https://pkg.go.dev/badge/github.com/dcadolph/slop-chop/sanitize.svg" alt="Go reference"></a>
</p>

# slop-chop

AI writing leaves fingerprints.

Chop the slop. Paste in text and get back something that reads like a person wrote it.

Try it without installing anything: [slop-chop.com](https://slop-chop.com/) runs the same
engine in your browser.

AI writing has patterns. It loves em-dashes, drops a semicolon into every other sentence,
reaches for words like `comprehensive` and `leverage`, and clears its throat with
openers like "In summary" or "Giving it to you honestly."

slop-chop removes those patterns in a single pass. You can also hand it your own list of
things to cut, so the result reads like you instead of a chatbot.

## Why

Cleaning this up by hand is tedious. Asking a model to "stop using em-dashes" works for
about three sentences before it forgets. slop-chop applies the same cleanup rules every
time.

## How it works

There are two passes, and you can run either one on its own.

The first is a rules pass. It is fast and deterministic. It swaps characters, drops words
you have flagged, rewrites stock phrases and words, runs your own patterns, fixes spelling
to one dialect, and tidies the punctuation, with no model, no cost, and the same output on
every run. It knows markdown, so fenced code blocks and inline backtick spans come through
untouched.

The second is an optional rewrite pass that hands the text to a model for the things
rules cannot manage, like reworking a sentence so it no longer needs a semicolon, or
nudging the writing toward a voice you picked.

## Install

Homebrew:

```sh
brew install dcadolph/tap/slop-chop
```

With Go:

```sh
go install github.com/dcadolph/slop-chop@latest
```

Or clone and use the Makefile:

```sh
git clone git@github.com:dcadolph/slop-chop.git
cd slop-chop
make install     # build and install into $(go env GOPATH)/bin, version stamped
make uninstall   # remove it again
```

Run `make` with no target for the full list (`build`, `test`, `cover`, `lint`, `fmt`, `tidy`, `clean`).

## Everywhere else

The same engine runs on many surfaces. All local and free unless noted.

| Where | Get it |
| --- | --- |
| Web app | [slop-chop.com](https://slop-chop.com), nothing to install |
| VS Code, Cursor, VSCodium | search **slop-chop** on [Open VSX](https://open-vsx.org/extension/dcadolph/slop-chop) |
| JetBrains IDEs | the Marketplace plugin, or LSP4IJ with `slop-chop lsp`, see [docs/LSP.md](docs/LSP.md) |
| Neovim, Helix, any LSP editor | `slop-chop lsp`, see [docs/LSP.md](docs/LSP.md) |
| Obsidian | the desktop plugin, see [obsidian/](obsidian/) |
| Node | `npm install slop-chop-wasm` |
| Go programs | `import github.com/dcadolph/slop-chop/sanitize`, see [below](#use-it-as-a-go-library) |
| HTTP API | `POST https://api.slop-chop.com/chop`, see [docs/API.md](docs/API.md) |
| Slack | a `/chop` command and a message shortcut, see [docs/SLACK.md](docs/SLACK.md) |
| Claude Desktop, Cursor, any MCP client | `slop-chop mcp`, see [docs/MCP.md](docs/MCP.md) |
| CI, Raycast, macOS, pre-commit | the GitHub Action and [integrations/](integrations/) |

## Usage

```sh
# Print the cleaned text to stdout. Your file is not changed.
slop-chop fix notes.md

# Clean the file in place, like gofmt -w.
slop-chop fix -w notes.md

# Pipe text through it
echo "In summary, a robust—and seamless—result." | slop-chop fix

# Flag slop without changing anything (exits non-zero if it finds any)
slop-chop check notes.md

# Check or fix several files at once
slop-chop check docs/intro.md docs/guide.md README.md
slop-chop fix -w docs/intro.md docs/guide.md

# Enforce a spelling variant: flag or fix the other dialect
slop-chop check --dialect american notes.md
slop-chop fix --dialect british notes.md

# Overlay a built-in pack, like corporate phrasing to plain English
slop-chop fix --preset plain notes.md

# Use your own profile
slop-chop fix --profile myprofile.json notes.md

# Get findings as JSON for other tools to read
slop-chop check --json notes.md
slop-chop check --json --pretty notes.md

# Deeper clean: rules first, then a model rewrite (needs ANTHROPIC_API_KEY)
slop-chop fix --rewrite notes.md
slop-chop fix --rewrite --verify notes.md
```

`check --json` prints a `{"findings": [...]}` object to stdout, and `fix --json` adds the
cleaned text as `{"cleaned": "...", "findings": [...]}`. Each finding carries the rule,
the matched text, the suggested replacement, and a line and column.

## Modes

- `check` flags what it finds and exits non-zero. Drop it in CI. Add `--why` and every
  finding carries a plain-words line saying what fired and what happens to it, the same
  explanations the web app shows on a tap.
- `fix` writes the cleaned text to stdout and leaves your file alone. Pass `-w` to change
  the file in place instead.
- `score` measures how densely the text carries the patterns your profile lists, 0 to 100.
It is a lint result, not a reading on who wrote the text, and it cannot be turned into one:
the same patterns appear in writing people produce on purpose. Under 25 reads clean, 25 to
54 is mixed, and 55 and up is dense with tells, the same bands the web app shows.
`score --by-paragraph` scores each paragraph on its own, which is how a document with two
generated paragraphs buried in a thousand human words shows where they are, and `--max`
then gates on the hottest paragraph instead of the diluted whole.

Source code gets its own treatment. On a `.go`, `.py`, `.ts`, or any other code file,
`check` and `score` read only the comments, so a buzzword in a comment is flagged at its
real line and column while identifiers, strings, and formatting alignment draw nothing.
`fix` refuses to rewrite code files outright, since prose cleanups break code. Pipe a
file through stdin to override either behavior on purpose. Data files with no comments,
like `.json` and `.csv`, are skipped with a note.

## Score

`score` gives a single number from 0 to 100 for how densely the text carries the patterns
the active profile lists. Change the profile and the same prose scores differently, which
is the clearest statement of what the number is: compliance with a named ruleset. A
structural tell counts double toward the density, because a stock sentence shape survives
a thesaurus where a listed word does not.

The engine ships with a labeled corpus of AI, human, and technical passages under
`sanitize/testdata/`, and `TestBenchmark` measures recall, precision, and the score margin
against it on every run, so a change that weakens detection fails the build instead of
going unnoticed. [docs/BENCHMARK.md](docs/BENCHMARK.md) shows the numbers, the corpus
composition, what fires on what, and the limits of what the score claims. The score is a
lint result, not an authorship verdict.

```sh
slop-chop score notes.md            # notes.md: 42 (mixed: 5 tells in 180 words)
slop-chop score --json notes.md     # {"value":42,"tells":7,"words":210,...}
slop-chop score --max 20 notes.md   # exit non-zero when the score is above 20
```

`--max` turns it into a gate, so a document over the bar fails a build the same way `check`
does.

## Structural tells

Word swaps catch the vocabulary of AI writing. The rules pass also flags 61 structural
tells that a word list misses: the `it's not just X, it's Y` cadence and its contracted
`isn't a perk. It's an expectation` twin, the `let's dive in` opener, `here's the thing`
throat-clearing, the `The best part?` fragment reveal, `here are five ways` enumeration,
runs of bold-label bullets and numbered items, emoji-decorated headings, and the spaced
hyphen models reach for now that the em-dash is a known tell. It also catches the register
of a chat reply rather than a piece of writing: `let me break this down`, `you might be
wondering`, `here's where it gets interesting`, `happy coding!`, and the `say goodbye to
X` and `Enter Foo, the tool that` moves of generated marketing copy. These are flagged, not
rewritten, since the fix depends on the whole sentence and is left to the rewrite pass. Add
your own with the `flagPatterns` field in a profile.

Every tell that becomes famous gets trained out of the next model and the writing moves
somewhere else, so the default profile tracks what models write now rather than what they
wrote in 2023.

## Use it in CI

Add a workflow that fails a pull request when it finds slop:

```yaml
name: slop-chop
on: pull_request
jobs:
  slop:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dcadolph/slop-chop@v0.40.0
        with:
          files: docs/intro.md docs/guide.md
          # profile: myprofile.json   # optional
          # dialect: american         # optional
          # preset: plain             # optional
```

Or have it fix the files and push the cleanup back to the pull request branch:

```yaml
name: slop-chop
on: pull_request
jobs:
  slop:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.head_ref }}
      - uses: dcadolph/slop-chop@v0.40.0
        with:
          files: docs/intro.md docs/guide.md
          mode: fix
          commit: "true"
          # message: Chop the slop   # optional commit message
```

The fix-and-commit workflow pushes back to the pu