slopwash

Setup guide. Every instruction for running slopwash inside your own tools: the MCP server, agent skills and writing rules, chat apps, and the API. The prompt, the scanner, and the audit live on the home page.

MCP quick start

Pick your tool to copy its config, then paste it into the file shown.

Once connected, ask the agent to slopwash some text or a file. It calls prepare_rewrite to get the prompt and the draft-wrapped text, and audit_rewrite to check the result, using the retry message once if the audit fails. Pass personas such as "journalist" to prepare_rewrite for a specific voice. In clients that support MCP prompts, rewrite and writing_rules also show up as slash commands; type / to find them (in Claude Code, /mcp__slopwash__rewrite).

Agent skills and rules

Coding agents can load slopwash two ways. A skill loads only when you invoke it. Writing rules load on every request, adding about 8,000 tokens, and shape the prose the agent writes on its own. Pick the matching format on the home page before you copy or download.

Skill: Claude Code, VS Code, Cursor

Choose Agent skill and save the download as .claude/skills/slopwash/SKILL.md. All three tools read that folder. VS Code also reads .github/skills/, and Cursor also reads .cursor/skills/.

Type /slopwash followed by pasted text or a file reference, or ask the agent to de-slop something and it will load the skill on its own.

VS Code (GitHub Copilot)

Writing rules in .github/copilot-instructions.md apply to every chat in the repo. To apply them only to docs, save them as .github/instructions/slopwash.instructions.md with an applyTo pattern at the top:

---
applyTo: "**/*.md"
---

For a dedicated editor, save the agent skill download as .github/agents/slopwash.agent.md and pick slopwash from the agent dropdown in Chat. Custom agents are chosen there, not with @.

Cursor

Save the writing rules as .cursor/rules/slopwash.mdc with this at the top. The .mdc extension is required, and .cursorrules is legacy.

---
description: slopwash writing rules
alwaysApply: true
---

To apply the rules only to docs, set alwaysApply: false and add globs: **/*.md.

Claude Code

CLAUDE.md loads into every session. Save the writing rules as slopwash-rules.md and import them with one line in CLAUDE.md, so your own instructions stay readable:

@slopwash-rules.md
Codex, Cline, and other AGENTS.md tools

Codex, VS Code, Cursor, Devin, and Cline read AGENTS.md at the repo root, so pasting the writing rules there covers all of them. Claude Code reads it only when there is no CLAUDE.md. Gemini CLI reads GEMINI.md unless you add AGENTS.md to context.fileName in its settings.

Windsurf / Devin

Rule files in .devin/rules/ hold at most 12,000 characters. The prompt is about 31,000, so use the MCP server instead. .windsurfrules still loads but is legacy.

Chat app setup

The rewrite prompt is about 31,000 characters, more than most settings fields hold. Put it in a project or Gem, or connect the MCP server. Then paste the text you want cleaned.

ChatGPT

Custom instructions hold at most 5,000 characters (1,500 on Free and Go), so the prompt won't fit there. Create a project instead and paste the prompt into its instructions, or upload the downloaded file and set the instructions to "Rewrite the text I send using slopwash-prompt.md."

On paid plans you can also connect the MCP server in developer mode (see MCP quick start). OpenAI retires custom GPTs on December 11, 2026, so don't build a new one.

Claude

Create a Project and paste the prompt into its instructions. The rules apply to every chat in that project.

To use slopwash in any chat, upload it as a skill. Download the Agent skill format, put SKILL.md in a folder named slopwash, zip the folder, and upload it under Customize → Skills → + → Create skill → Upload a skill. Skills need code execution turned on.

Or add the MCP server as a custom connector (see MCP quick start).

Gemini

Go to Gems → New Gem and paste the prompt as its instructions, or upload the downloaded file under Knowledge. Use that Gem whenever you need text cleaned.

Any other chat

Paste the prompt at the start of a new conversation, followed by your text.

API usage

Send the rewrite prompt as the system instruction and the source text as the user message. In code, wrap the text in <draft> tags so the model edits any instructions inside it instead of following them. The examples load the file downloaded from the home page and use this helper:

import re

SLOPWASH = open("slopwash-prompt.md").read()  # from the Download button

def wrap_draft(text):
    escaped = re.sub(
        r"</?draft>",
        lambda m: m.group(0).replace("<", "&lt;").replace(">", "&gt;"),
        text,
        flags=re.IGNORECASE,
    )
    return f"<draft>\n{escaped}\n</draft>"
OpenAI (Responses API)
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    instructions=SLOPWASH,
    input=wrap_draft(text_to_clean),
)
print(response.output_text)
Anthropic (Messages API)
import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    system=SLOPWASH,
    messages=[{"role": "user", "content": wrap_draft(text_to_clean)}],
)
print("".join(b.text for b in message.content if b.type == "text"))
Google Gemini (Interactions API)
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    system_instruction=SLOPWASH,
    input=wrap_draft(text_to_clean),
)
print(interaction.output_text)

Requires google-genai 2.3.0 or later.

Let the model audit its own rewrite

The OpenAI and Anthropic APIs can call the slopwash MCP server during a request, so the model checks its rewrite with audit_rewrite before it answers. Gemini 3 models don't support remote MCP servers yet.

AUDIT = (
    "\n\nBefore you answer, pass the draft and your rewrite to "
    "audit_rewrite and fix anything it flags."
)

# OpenAI
response = client.responses.create(
    model="gpt-6-astra",
    instructions=SLOPWASH + AUDIT,
    input=wrap_draft(text_to_clean),
    tools=[{
        "type": "mcp",
        "server_label": "slopwash",
        "server_url": "https://slopwash.com/api/mcp",
        "allowed_tools": ["audit_rewrite"],
        "require_approval": "never",
    }],
)

# Anthropic (beta)
message = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    system=SLOPWASH + AUDIT,
    messages=[{"role": "user", "content": wrap_draft(text_to_clean)}],
    mcp_servers=[{"type": "url", "url": "https://slopwash.com/api/mcp", "name": "slopwash"}],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "slopwash"}],
    betas=["mcp-client-2025-11-20"],
)
Fetch the prompt from the MCP endpoint

Pull the current prompt at build or deploy time instead of committing a copy. Set mode to skill or rules for the other formats, and add personas or narrative as needed.

curl -s https://slopwash.com/api/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_slopwash_prompt","arguments":{"mode":"rewrite"}}}' \
  | jq -r '.result.content[0].text' > slopwash-prompt.md

Model IDs are current as of September 2026. Any current model works, so swap in the one you use.

Things to know

  • •In chat, paste the prompt and then your text. In code, send the prompt as the system message and wrap the text in <draft> tags; prepare_rewrite does this for you.
  • •Personas are optional. The base prompt handles most of the work on its own.
  • •The rules are model-agnostic. Any modern LLM can follow them.
  • •For best results, don't layer on other tasks. Give the model the slopwash prompt and the text to clean.
  • •Run model output through audit_rewrite. If it fails, use its retry message for one correction pass.
  • •Use MCP or a skill when you need slopwash now and then. Use writing rules only when every response should follow them, since they add about 8,000 tokens to each request.