# Set Up Slop or Not

These instructions are for a coding agent. Slop or Not is a Mac app that detects AI-generated text and images on device. Its app bundle ships a command-line tool, `slop`, and a local MCP server, `slop mcp`. Follow the sections in order unless a step sends you elsewhere: find the app, check that it runs, then set up the MCP server, the CLI, or both. If the prompt that sent you here asked for the humanizer skill, you also install that skill in section 7. Human-readable reference: https://slopornot.ai/en/mcp and https://slopornot.ai/en/cli

Rules for every step:

- Each of your commands runs in a fresh shell, so variables do not carry over. Every command block that uses the app starts with `APP='<app path from section 2>'`: substitute the app bundle path section 2 found, exactly as `mdfind` or `ls` printed it, inside the single quotes, and write any `'` in it as `'\''`. Never paste the path anywhere else in a command, not even in double quotes, which still run `$(...)` and backticks; later lines use `"$APP"`. Blocks that use `"$SLOP"` set it from `$APP`, and blocks that use `"$f"` set it on a `$HOME`-based line.
- Never open, read or print a config file or shell profile, with a shell command or with your own file-reading or editing tools: they can hold other servers' API keys. Do not `cat`, `head`, `less`, or `grep` them without `-q`, and never run `claude mcp list` or `codex mcp list`, which print every server. Check whether something exists by exit status only, as the commands below do.
- Ask before writing a shell profile or the config of any client other than the one you run in.
- Register the MCP server at user scope only, never project scope: the path to `slop` is specific to this Mac and would break for anyone else who opens the project.
- Edit JSON configs only with the merge commands in section 5, which keep every other server.
- If your sandbox refuses a command, show the user the exact command to run in their own terminal, and continue from what they report.

## 1. Where Are You Running

```bash
uname -s; sysctl -n hw.optional.arm64
```

Also work out whether you run on the user's own computer or in a cloud sandbox or remote machine; ask if you cannot tell.

- `Darwin` and `1`, on the user's own Mac: an Apple-silicon Mac. `sysctl` prints `1` there even under Rosetta, where `uname -m` says `x86_64`. Continue to section 2.
- Anything else (Linux, Windows, an Intel Mac where `sysctl` prints `0` or nothing, a cloud sandbox): the Slop or Not app cannot run here; it needs an Apple-silicon Mac. Offer the hosted server instead, and say plainly what it is: `SlopOrNotWeb` at `https://mcp.slopornot.ai/mcp` scans and cleans text but does not detect AI, and the text sent to it goes to Numen's server instead of staying on the device. On a yes, first check by exit status whether your client already has a server named `SlopOrNotWeb`, and whether it is an HTTP server at exactly `https://mcp.slopornot.ai/mcp` (0 means yes). Claude Code:

  ```bash
  claude mcp get SlopOrNotWeb >/dev/null 2>&1; echo "exists $?"
  claude mcp get SlopOrNotWeb 2>/dev/null | grep -qxF '  Type: http' >/dev/null 2>&1; echo "type $?"
  claude mcp get SlopOrNotWeb 2>/dev/null | grep -qxF '  URL: https://mcp.slopornot.ai/mcp' >/dev/null 2>&1; echo "url $?"
  ```

  Codex:

  ```bash
  codex mcp get SlopOrNotWeb >/dev/null 2>&1; echo "exists $?"
  codex mcp get SlopOrNotWeb --json 2>/dev/null | jq -e '.transport.type == "streamable_http" and .transport.url == "https://mcp.slopornot.ai/mcp"' >/dev/null 2>&1; echo "canonical $?"
  ```

  - `exists 0` with `type 0` and `url 0` (Codex: `canonical 0`): it is already set up. Add nothing, because adding it again would replace the entry and its settings.
  - `exists 0` otherwise: the entry points somewhere else, uses another transport, or cannot be read. Tell the user it is unverified, never call it ready, and offer to replace it. On a yes, run `claude mcp remove SlopOrNotWeb -s user` or `codex mcp remove SlopOrNotWeb`, then the exists check again, and add the server below only when it prints 1. If it still prints 0, the entry is at project or local scope: add nothing, and tell the user where it is.
  - `exists 1`: add it to your own client as an HTTP server named `SlopOrNotWeb`:
    - Claude Code: `claude mcp add --transport http --scope user SlopOrNotWeb https://mcp.slopornot.ai/mcp`
    - Codex: `codex mcp add SlopOrNotWeb --url https://mcp.slopornot.ai/mcp`
    - Any other client: a Streamable HTTP server at `https://mcp.slopornot.ai/mcp`, no authentication.

  Then, if the prompt asked for the humanizer skill, go to section 7: the skill runs without Slop or Not. Otherwise go to section 9.

## 2. Find the App

Find Slop or Not by its bundle id:

```bash
mdfind "kMDItemCFBundleIdentifier == 'ie.numen.slopornot'"
```

If that prints nothing, Spotlight may be off or still indexing, so check the known install paths before concluding the app is missing:

```bash
ls -d "/Applications/Slop Or Not.app" "/Applications/Slop Or Not - AI Fake Detector.app" "$HOME/Applications/Slop Or Not.app" "$HOME/Applications/Slop Or Not - AI Fake Detector.app"
```

Before you run any copy's `slop`, check that Numen signed it, with that copy's bundle path in the `APP=` line:

```bash
APP='<app path from section 2>'
codesign --verify --deep --strict "$APP"; echo "verify $?"
codesign -dv "$APP" 2>&1 | grep -qx 'TeamIdentifier=F8773MR9C7'; echo "team $?"
```

Use only a copy that prints `verify 0` and `team 0`. For any other copy, tell the user it is not signed by Numen, and do not run or register it. If no copy passes, continue as with no app found.

- No app found: tell the user Slop or Not is not installed and link the App Store: https://slopornot.ai/download. Do not offer the hosted server on an Apple-silicon Mac. If the prompt asked for the humanizer skill, go to section 7; otherwise go to section 9.
- One app found under `/Applications` or `~/Applications`: use it.
- More than one found there: prefer `/Applications/Slop Or Not.app`, then any other copy under `/Applications` or `~/Applications`, then the highest `--version` among those.
- A copy anywhere else (Downloads, a mounted disk image, a build folder), even the only one found: name it to the user, and do not run or register it unless they confirm it. If they decline and no other copy was found, continue as with no app found.

Tell the user which path you used. The app bundle path you chose goes in the `APP=` line of every later command. Check its version:

```bash
APP='<app path from section 2>'
SLOP="$APP/Contents/MacOS/slop"
"$SLOP" --version
```

It prints a version and build, such as `1.3.0 (29)`. Version 1.2.1 or later: continue to section 3. Below 1.2.1: ask the user to update Slop or Not from the App Store (https://slopornot.ai/download) first, then, as with no app, go to section 7 if the prompt asked for the humanizer skill, otherwise to section 9.

## 3. Check Status

```bash
APP='<app path from section 2>'
SLOP="$APP/Contents/MacOS/slop"
"$SLOP" status --json; echo "exit $?"
```

It prints a JSON object such as `{"localCachePro":true,"pro":true,"version":"1.2.1"}`. Read only `pro` and `version`; newer versions add keys you can ignore.

- Exit 0 with `"pro": true`: Pro. Continue to section 4.
- Exit 233, or `"pro": false`: installed but not Pro. That still works on the free tier. Continue to section 4, and explain the limits in section 9.
- Any other exit, or an XPC or connection error: ask the user to open Slop or Not once (the first launch registers its detector service), then run the command again. If it still fails, your sandbox may be blocking the detector service: ask the user to run the same command in their own terminal and tell you the exit code. Exit 0 or 233 there: continue to section 4. If it fails there too, configure no MCP server or CLI: go to section 7 if the prompt asked for the humanizer skill, otherwise to section 9, and report the exit code.

## 4. Choose MCP, CLI, or Both

If the prompt asked for the humanizer skill, do not ask: the skill uses the MCP server, so set up MCP in section 5, which then sends you to section 7.

Otherwise ask the user which they want:

- **MCP**: their AI client calls Slop or Not's tools directly.
- **CLI**: the `slop` command in their own terminal and scripts.
- **Both**.

MCP or both: go to section 5. CLI only: go to section 6.

## 5. Set Up MCP

Register the server under the exact name `SlopOrNot` (the humanizer skill looks for that name), as a stdio server whose command is the absolute path to `slop` and whose only argument is `mcp`, at user scope. Start with the client you run in.

### Check for an Existing Entry

Look for `SlopOrNot` and for an older lowercase `slopornot` entry, by exit status only (0 means it exists).

Claude Code:

```bash
claude mcp get SlopOrNot >/dev/null 2>&1; echo "SlopOrNot $?"
claude mcp get slopornot >/dev/null 2>&1; echo "slopornot $?"
```

Codex:

```bash
codex mcp get SlopOrNot >/dev/null 2>&1; echo "SlopOrNot $?"
codex mcp get slopornot >/dev/null 2>&1; echo "slopornot $?"
```

Cursor (`~/.cursor/mcp.json`) or Claude Desktop (`~/Library/Application Support/Claude/claude_desktop_config.json`); for Claude Desktop, replace the `f=` line with `f="$HOME/Library/Application Support/Claude/claude_desktop_config.json"`:

```bash
f="$HOME/.cursor/mcp.json"
[ -e "$f" ] && jq -e '.mcpServers.SlopOrNot != null' "$f" >/dev/null; echo "SlopOrNot $?"
[ -e "$f" ] && jq -e '.mcpServers.slopornot != null' "$f" >/dev/null; echo "slopornot $?"
```

Here 0 means present and 1 means absent; any other exit means `jq` is missing or the file does not parse, so treat that client as in the JSON fallback below.

If either name already exists, tell the user which one (never show its command or settings) and ask whether to replace it. Never leave two Slop or Not servers in one client.

- Yes, in Claude Code: remove each existing name at user scope, `claude mcp remove SlopOrNot -s user` or `claude mcp remove slopornot -s user`, then run the Claude Code check above again. Add the server below only when both names print 1. If a removal fails, or a name still prints 0, that name is also at project or local scope, which overrides user scope: add nothing in Claude Code, and tell the user it is in this project's MCP config or their local settings.
- Yes, in Codex: remove each name that exists, `codex mcp remove SlopOrNot` and `codex mcp remove slopornot`, then run the Codex check above again. Add the server below only when both names print 1. If a name still prints 0, add nothing in Codex, and tell the user which entry remains.
- Yes, in a JSON config: the merge below replaces `SlopOrNot` and removes `slopornot`.
- No: keep the existing entry, add nothing to that client, and say so in section 9.

### Add the Server

Claude Code:

```bash
APP='<app path from section 2>'
SLOP="$APP/Contents/MacOS/slop"
claude mcp add --transport stdio --scope user SlopOrNot -- "$SLOP" mcp
```

Codex:

```bash
APP='<app path from section 2>'
SLOP="$APP/Contents/MacOS/slop"
codex mcp add SlopOrNot -- "$SLOP" mcp
```

Cursor or Claude Desktop: merge with `jq`, keeping every other server. Run `command -v jq` first. If jq is not installed, or the file does not parse, write nothing and show the user this entry to paste into the file's `mcpServers` object themselves:

```json
"SlopOrNot": {
  "command": "<app path from section 2>/Contents/MacOS/slop",
  "args": ["mcp"]
}
```

Otherwise run these two blocks in order, with the same `f=` line as the check above. For Cursor, run `mkdir -p "$HOME/.cursor"` first. The first block creates the file, readable only by the user, if it is missing, and checks that it parses:

```bash
f="$HOME/.cursor/mcp.json"
[ -e "$f" ] || (umask 077; printf '{"mcpServers":{}}\n' > "$f")
jq -e . "$f" >/dev/null; echo "parse $?"
```

If it prints anything but `parse 0`, stop and use the paste fallback above. Otherwise run the second, which backs the file up, writes it in place (keeping its permissions and any symlink), checks the result, and restores the backup if the check fails:

```bash
APP='<app path from section 2>'
SLOP="$APP/Contents/MacOS/slop"
f="$HOME/.cursor/mcp.json"
cp -p "$f" "$f.bak-slopornot"
umask 077; jq --arg cmd "$SLOP" '.mcpServers.SlopOrNot = {command: $cmd, args: ["mcp"]} | del(.mcpServers.slopornot)' "$f" > "$f.tmp-slopornot" && cat "$f.tmp-slopornot" > "$f"; echo "write $?"; rm -f "$f.tmp-slopornot"
if jq -e . "$f" >/dev/null; then rm -f "$f.bak-slopornot"; echo checked; else if cat "$f.bak-slopornot" > "$f"; then rm -f "$f.bak-slopornot"; echo restored; else echo "restore failed, backup at $f.bak-slopornot"; fi; fi
```

`write 0` and `checked`: done. Anything else: tell the user the write failed, then show the paste fallback. On `restored`, also tell them the file was put back as it was. On `restore failed`, tell them the file may be damaged and name the backup path so they can restore it themselves; never open or print the backup.

### Other Clients

After your own client, look for other installed clients:

```bash
[ -d "$HOME/Library/Application Support/Claude" ]; echo "Claude Desktop $?"
[ -d "$HOME/.cursor" ]; echo "Cursor $?"
mdfind "kMDItemFSName == 'Claude.app' || kMDItemFSName == 'Cursor.app'"
command -v claude codex
```

Claude Desktop counts as installed when its folder exists or Spotlight finds `Claude.app`; Cursor when `~/.cursor` exists or Spotlight finds `Cursor.app`; Claude Code and Codex when `command -v` finds their CLI. Offer to add `SlopOrNot` to each one you found, and ask the user before writing each app's config: write it only on a yes for that app, using the same existence check and commands as above. If Claude Desktop's folder does not exist yet, ask the user to open Claude Desktop once first. Claude Desktop has to be quit and reopened to load the server.

For a client not covered here (OpenClaw, Hermes Agent, or anything else), show the user the generic stdio entry (name `SlopOrNot`, command `<app path from section 2>/Contents/MacOS/slop`, args `["mcp"]`) and link https://slopornot.ai/en/mcp for that client's own snippet.

Then: if the user chose both, go to section 6. If the prompt asked for the humanizer skill, go to section 7. Otherwise go to section 8.

## 6. Set Up the CLI

```bash
APP='<app path from section 2>'
SLOP="$APP/Contents/MacOS/slop"
command -v slop; [ "$(command -v slop)" -ef "$SLOP" ]; echo "same $?"
```

The first line is the `slop` on PATH, if any; `same 0` means it is the app's own binary, directly or through a symlink.

- `same 0`: the CLI is already on PATH. Write nothing, report it ready, and go to section 8.
- A path, then `same 1`: a different file. Name both paths to the user. Only the binary inside the app bundle works, because the detector service answers only the app's own signed binary, and the other file comes first on PATH until the user removes it. Offer the PATH line below for section 2's copy.
- Only `same 1`: no `slop` on PATH. Offer the PATH line below.

Ask the user before writing their shell profile. Read `$SHELL` to pick the line, and write it only after they say yes. Each line checks for itself first, so running it twice adds nothing.

First check that the path is safe to put in a profile:

```bash
APP='<app path from section 2>'
case "$APP" in *[\$\`\"\\]*) echo unsafe ;; *) echo safe ;; esac
```

On `unsafe` (the path contains `$`, a backtick, `"` or `\`, which a shell would expand each time it reads the profile), write nothing to any profile: tell the user to add `<app path from section 2>/Contents/MacOS` to their PATH themselves, or to call `slop` by its full path.

zsh (`~/.zshrc`):

```bash
APP='<app path from section 2>'
line='export PATH="$PATH:'"$APP"'/Contents/MacOS"'
grep -qsxF "$line" "$HOME/.zshrc" || printf '\n%s\n' "$line" >> "$HOME/.zshrc"
```

bash: use the first of `~/.bash_profile`, `~/.bash_login`, `~/.profile` that exists. Create `~/.bash_profile` only when none does, because bash stops reading `~/.profile` once a `~/.bash_profile` exists.

```bash
for p in "$HOME/.bash_profile" "$HOME/.bash_login" "$HOME/.profile"; do [ -e "$p" ] && echo "$p" && break; done
```

Then, with the `f=` line set to the file it printed:

```bash
APP='<app path from section 2>'
f="$HOME/.bash_profile"
line='export PATH="$PATH:'"$APP"'/Contents/MacOS"'
grep -qsxF "$line" "$f" || printf '\n%s\n' "$line" >> "$f"
```

fish (`~/.config/fish/config.fish`):

```bash
APP='<app path from section 2>'
mkdir -p "$HOME/.config/fish"
line='fish_add_path --append "'"$APP"'/Contents/MacOS"'
grep -qsxF "$line" "$HOME/.config/fish/config.fish" || printf '\n%s\n' "$line" >> "$HOME/.config/fish/config.fish"
```

Any other shell: tell the user which directory to add to their PATH.

If the user says no, write nothing; section 9 gives them the line to add by hand. Then go to section 8.

## 7. Install the Humanizer Skill

Only when the prompt asked for the humanizer skill. The skill's Pro features use the MCP server registered as `SlopOrNot`.

You can install it only in Claude Code or Codex. In any other harness, link https://slopornot.ai/en/skills/claude-code-humanizer and https://slopornot.ai/en/skills/codex-humanizer, and skip the rest of this section.

Read the plugin state from JSON, never from the text list (`codex plugin list` prints every plugin each marketplace offers, installed or not). Run `command -v jq` first; if it prints nothing, the state is unknown.

Claude Code:

```bash
claude plugin list --json | jq -e 'any(.[]; .id == "slopornot@slopornot")' >/dev/null; echo "installed $?"
claude plugin list --json | jq -e 'any(.[]; .id == "slopornot@slopornot" and .enabled)' >/dev/null; echo "enabled $?"
claude plugin marketplace list --json | jq -e 'any(.[]; .name == "slopornot")' >/dev/null; echo "marketplace $?"
claude plugin marketplace list --json | jq -e 'any(.[]; .name == "slopornot" and .source == "github" and .repo == "numen-tech/slopornot")' >/dev/null; echo "source $?"
claude plugin marketplace list --json | jq -r '.[] | select(.name == "slopornot" and .source == "directory") | .path'
```

Codex:

```bash
codex plugin list --json | jq -e 'any(.installed[]; .pluginId == "slopornot@slopornot" and .installed)' >/dev/null; echo "installed $?"
codex plugin list --json | jq -e 'any(.installed[]; .pluginId == "slopornot@slopornot" and .installed and .enabled)' >/dev/null; echo "enabled $?"
codex plugin marketplace list --json | jq -e 'any(.marketplaces[]; .name == "slopornot")' >/dev/null; echo "marketplace $?"
codex plugin marketplace list --json | jq -e 'any(.marketplaces[]; .name == "slopornot" and .marketplaceSource.sourceType == "git" and .marketplaceSource.source == "https://github.com/numen-tech/slopornot.git")' >/dev/null; echo "source $?"
codex plugin marketplace list --json | jq -r '.marketplaces[] | select(.name == "slopornot" and .marketplaceSource.sourceType == "local") | .marketplaceSource.source'
```

Each prints 0 for yes and 1 for no, except the last line, which prints the folder of a `slopornot` marketplace added from a local directory, or nothing. `source 0` means the marketplace is Numen's GitHub repository `numen-tech/slopornot`. A local folder may be a developer's own checkout or a planted copy, so show the user that path and act on it only on an explicit yes.

- Installed and enabled: the skill is already installed. Install nothing and report it.
- Installed but disabled: in Claude Code, with `source 0`, offer `claude plugin enable slopornot@slopornot` and run it on a yes; with a local path, show it and enable only on an explicit yes; otherwise tell the user their `slopornot` marketplace comes from somewhere else, and enable nothing. In Codex, tell the user to enable it from `/plugins` inside Codex, and name the local path if one printed.
- Marketplace present, plugin not installed: with `source 0`, run only the install command below; with a local path, show it and install only on an explicit yes; otherwise tell the user their `slopornot` marketplace comes from somewhere else, and install nothing. Never replace or re-add an existing `slopornot` marketplace.
- Neither: add the marketplace, then install.
- `jq` missing, or any check exiting with something other than 0 or 1: the state is unknown. Install nothing, and show the user the commands below to run themselves.

Claude Code:

```bash
claude plugin marketplace add numen-tech/slopornot
claude plugin install slopornot@slopornot
```

Codex:

```bash
codex plugin marketplace add numen-tech/slopornot
codex plugin add slopornot@slopornot
```

If your sandbox refuses the install, show the user the exact commands to run in their own terminal.

Then: if section 2 found a usable app and section 3's status check succeeded (exit 0 or 233), go to section 8. Otherwise go to section 9.

## 8. Verify

A client loads a new MCP server only after a restart, so check the server directly. This also checks the binary for a CLI-only setup.

```bash
APP='<app path from section 2>'
SLOP="$APP/Contents/MacOS/slop"
printf '%s\n' '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"slopornot-setup","version":"1"}}}' '{"jsonrpc":"2.0","method":"notifications/initialized"}' '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' | "$SLOP" mcp
```

It prints two JSON lines; the second, with `"id":2`, lists the tools under `result.tools`, each with a `name`. Expect `slop_status`, `detect_text`, `analyze_readability`, `clean_text`, `detect_image`, and `score_image`.

- All of those present: the server works.
- `analyze_writing_tells` also present: a 1.3 extra. Its absence on 1.2.1 is expected, and 1.2.1 is a complete install.
- Any of the expected names missing: the app is older than 1.2.1. Ask the user to update it from the App Store.
- The pipe is blocked by your sandbox: ask the user to run it in their own terminal and paste the tool names.

Then go to section 9.

## 9. Report Back

Tell the user:

- What you configured and where: the MCP server in which clients, the PATH line in which file, the skill. Name anything you skipped and why (an existing entry kept, an entry left at project or local scope, a declined write, a sandbox refusal), with the exact command for anything they still need to run.
- If they declined the profile write, the PATH line to add by hand. If you added one, that they need to open a new terminal.
- If section 6 found a different `slop` file already on PATH: name that path, and say the PATH line has no effect while it comes first. They need to remove it from their PATH, or call the bundled binary by its full path, `<app path from section 2>/Contents/MacOS/slop`.
- If they are not Pro (exit 233 or `"pro": false`): "One free check a day; Pro, or a new install's 7-day free trial, removes the cap and adds cleanup, readability and raw image scoring." If they installed the app recently and have never opened it, add that they should open it once: the CLI and MCP server see a running trial only after the app's first launch. When section 2 found version 1.3 or later, end that sentence with "cleanup, readability, raw image scoring and writing tells" instead.
- If you set up the hosted server: it scans and cleans text but does not detect AI. If you installed the humanizer skill there, its scoring, readability and cleanup need Slop or Not on an Apple-silicon Mac.
- If section 2 found no app, or one older than 1.2.1: say so, link https://slopornot.ai/download, and tell them to paste the setup prompt again after installing or updating.
- If the status check failed in their terminal too: the exit code.
- If you configured the local `SlopOrNot` server: restart the client, then ask it to run `slop_status`. If you configured the hosted `SlopOrNotWeb` server instead, or found it already set up at the canonical URL: restart the client, then ask it to scan a sentence with `scan_text`. If you left an unverified `SlopOrNotWeb` entry in place, say so, and do not suggest that test. If you installed the skill, restart that client as well.
- Reference: https://slopornot.ai/en/mcp and https://slopornot.ai/en/cli
