Skip to main content

The Anti-Slop Guard

Your engine defines who you are: voice, positioning, audiences, rules. The Anti-Slop Guard is the layer that sits on top of it and enforces the floor: it checks every generation for slop, learns what you like from every edit you make, and steers toward what your analytics prove works. The two evolve together - the engine stays your source of truth, and the Guard keeps sharpening how it ships.

Every rule the Guard applies is conditional on your engine's silence. On any conflict, the engine wins. A brand whose voice deliberately uses em dashes keeps them; a lexicon that loves a word the Guard would normally cut keeps that word. The authority order is explicit in every generation:

  1. Your engine (always wins)
  2. Learned preferences (from your edits, weight-adjustable)
  3. Performance signals (from your analytics)
  4. Guard skills (the quality floor - built-in and your own)

Find it in the sidebar: Anti-Slop Guard. Three tabs: Skills, Memory, Signals. A master toggle turns the whole layer off if you ever want raw engine output (turning it off requires a manager: the Guard is the only review on the unattended auto-publish path).

Skills​

Skills are instruction layers the Guard injects below your engine. Four ship built in:

  • Anti-slop (on by default): strips the tells of AI writing - em dashes, filler vocabulary, "it's not just X, it's Y", throat-clearing intros, restated conclusions - and enforces specific, natural prose. Backed by a deterministic lint pass: after generation, the Guard greps the draft for violations and runs one targeted repair that fixes exactly those and nothing else.
  • Casual language (opt-in): keeps the register conversational - contractions, short words, direct address, zero corporate speak.
  • Technical accuracy (opt-in): grounds every factual claim. No invented numbers, quotes, sources, or capabilities - if it isn't in your engine context or the brief, it doesn't get stated.
  • Answer engine readiness (opt-in): structures long-form content so AI answer engines can cite it - conclusion-first sections, question-shaped headings, self-contained passages, citable specifics.

Your own skills​

Upload any skill of your own - a SKILL.md file works as-is (the name and description are read from its frontmatter), or write one in the app. Custom skills join the Guard alongside the built-ins and toggle on and off per skill. This is also how you give the Guard standing instructions: a rule like "never mention pricing in social posts" is a one-line skill.

A shared skill library is coming: browse, install, and publish skills across teams.

Review anything​

The Guard's deterministic lint runs over any text, not just Reactor drafts. The guard_review MCP tool (and the same API) takes pasted text or a public URL - Reactor fetches the page and strips it to its article text - and returns each violated rule with a count and sample matches. Repair mode runs one targeted pass that fixes exactly the flagged violations and returns the cleaned copy.

This works on content that never touched Reactor: a draft from another tool, a competitor's post, last year's blog. For whole codebases, review_copy and revise_copy do the same per segment - see Use Reactor in your codebase.

In the editor, the same lint runs live as amber squiggles on the draft, with Fix with Guard repairing the flagged paragraph in place - see Guard squiggles.

Teach the Guard​

Durable preferences don't need the Skills form. Tell the assistant in plain words - "never call it a platform", "remember: sign social posts with the team name" - and it proposes a standing rule as a card in the chat. Applying the card lands the rule in the Guard:

  • Banned words and phrases become lexicon rules that compile into the deterministic lint, so the Guard catches them mechanically from then on.
  • Style and procedure preferences become skills - standing instructions injected into every generation.

Nothing is remembered until you apply the card. Agents teach the same way over MCP with remember_rule.

Memory​

The Guard remembers. Every time you edit a piece and publish it, the Guard compares what was generated with what you actually shipped and distills the difference into rules: words you always remove, structures you prefer, hooks you rewrite. Recurring asks in the content chat become rules too. And when you publish a piece untouched, the memories that shaped it get reinforced.

  • Learned rules start as candidates. They apply once they've been seen twice, or the moment you confirm one.
  • Weights are yours to set. Every memory has a weight (low, medium, high, critical - the same scale as your engine items). Heavier rules shape content more. Sort by weight, recency, or how often a rule has been observed.
  • You stay in control. Confirm, mute, re-weight, or delete anything. Muted rules never come back on their own. Stale rules decay if your editing stops reinforcing them. And for standing rules of your own, add a skill on the Skills tab - memory is reserved for what the Guard learns.

Signals​

Signals are rules the Guard derives from your analytics: what your top pieces on each channel share, what your underperformers lack, refreshed nightly as the data moves. Generation also sees your current top performers with their real numbers - framed as patterns to steer toward, never wording to copy (the similarity guard rewrites anything that echoes a previous post).

Signals need data: connect an analytics source (Google Analytics, Plausible, Search Console) or a social channel with metrics, and signals appear after the nightly analysis once pieces accumulate impressions.

Enforcement: advisory when you're there, blocking when you're not​

Every generation runs the full Guard: the weighted prompt, then the deterministic lint, then one targeted repair. What happens to violations that survive depends on whether a human is in the loop:

  • Manual publish is advisory. Surviving violations are shown as warnings at the publish confirm. You see exactly what the Guard flagged and decide whether to ship anyway - your call, always.
  • Scheduled auto-publish is blocking. A piece that is about to publish with no one watching is re-checked, and if violations survive repair it does not go out: the piece stays a draft and you get a guard-blocked notification to review it. Auto-publish never ships content the Guard couldn't clean.

The Guard page (sidebar: Anti-Slop Guard) is where you see and steer all of it - which skills are on, what memory has learned and at what weight, and the signals currently applied.

Guard analytics​

Is the Guard earning its tokens? A panel on the Guard page aggregates the last 90 days of lint records: pieces checked, how many came out clean, how many violations were auto-repaired, how many auto-publishes were blocked - plus the rules that fire most often. Every generation and AI edit writes a lint record, so the numbers fill in as content flows through.

Headless, like everything else​

The Guard is fully driveable over MCP: list_skills, set_skill_enabled, add_skill, list_memories, mute_memory, and set_memory_weight to tune it; guard_review to lint and repair any text; remember_rule to teach it a standing rule - so an agent works the Guard the same way you do in the UI.