Plan Antislop

Anti-Slop Audit + Authenticity Burndown Plan

Degree of freedom: HIGH — inventory tells, score, plan. Stay plan-only. No rewrites until each phase is approved.

This skill vs neighbors

How to reason (every plan item)

1. Propose — direction to remove a tell (not the rewrite)
2. Risk — how loudly it reads as machine-made, and who sees it first
3. Keep-working — copy/UI/code that already sounds or looks intentional
4. Phase — copy → visual → IA → code (do not execute)

Worked example

Propose: replace the hero dual-clause ("It's not just a tracker, it's a companion") with the concrete benefit already in the docs. Risk: first-screen cadence is the loudest AI tell; readers bounce. Keep-working: settings microcopy is already terse and product-specific. Phase: Phase 1 — copy pass via docs-writer.

Role: Senior editor + product designer + staff engineer (authenticity lens).

Task: Inventory machine-generated tells across prose, visual/UI, code, and structure/IA. Score each finding by recognizability × effort, cluster into phased burndowns, emit plan-antislop.md. Audit & plan only — no rewrites until each phase is approved.

Find the AI tells. Plan their removal. Change nothing until approved.

"Slop" is content that is recognizably machine-generated: technically fine, semantically empty, and uniform in a way no human hand would produce. This skill is the audit-and-plan half of de-slopping. It inventories slop across four surfaces, ranks each finding by recognizability × effort, and emits a phased burndown the user approves before any rewrite happens.

This skill never rewrites. It produces plan-antislop.md. Execution is handed to enhance-web-ux, enhance-web-ui, enhance-web-landing, design-frontend, audit-i18n, or docs-writer after approval — same contract as every plan-* skill in this repo.

When this fires

Trigger phrases: "this feels AI-generated", "de-slop this", "reads like ChatGPT", "make it sound human", "every page looks identical", "it's generic/templated/soulless", "strip the AI smell before launch", "voice and authenticity pass".

Do not fire for: functional bugs (debug-*), security/RLS (plan-security-audit), missing tests (plan-test-coverage), or designing a new surface from scratch (design-frontend). Slop is about recognizability, not correctness — code can be 100% working and still be 100% slop.

The four slop surfaces [HIGH freedom]

Audit each surface the codebase actually has. Skip surfaces that don't apply (a backend-only repo has no visual surface).

1 · Prose & copy slop

The most detectable surface. Scan all user-facing strings, marketing copy, READMEs, microcopy, error messages, and comments for:

• Cadence tells — "It's not just X, it's Y." / "In today's fast-paced world…" / "Let's dive in." / "The result? …" / "But here's the thing:" / rhetorical question → one-line answer.
• Filler vocabulary — delve, tapestry, realm, landscape, leverage, seamless, robust, elevate, unlock, empower, navigate, foster, testament, bustling, vibrant, game-changer, at the end of the day.
• Hedge-and-pad — "it's important to note that", "it's worth mentioning", "in conclusion", triple-adjective stacks, sentences that restate the heading.
• Punctuation tics — em-dash overuse, "—and that's the point.", emoji as bullet points, Title Case Everywhere, bolded every other phrase.
• Empty symmetry — three benefits that are the same benefit, "Fast. Simple. Powerful." triads, conclusions that summarize a 2-paragraph page.

Output for each: file/line, the tell, why a human wouldn't write it, and a direction for the fix (not the fix itself).

2 · Visual & UI slop

The "I've seen this exact app 400 times" surface:

• Default-palette tell — untouched shadcn violet/zinc, the default Tailwind blue-600 CTA, no brand color anywhere.
• Card-grid monotony — every section is a 3-up grid of identical rounded cards with an icon, a bold title, and two lines of gray text.
• Centered-everything — every section center-aligned, max-w-2xl, same vertical rhythm, no asymmetry, no intentional focal point.
• Iconography slop — a lucide icon on every feature whether it means anything or not; emoji in headings.
• No hierarchy — all sections weighted equally; nothing is the hero, nothing recedes; uniform spacing top to bottom.
• Generic motion — fade-in-on-scroll on everything, or no motion at all.

Cross-check against the project's design tokens if audit-uiux-design-system data or a tokens file exists — slop is often divergence from the design system plus convergence toward the framework default.

3 · Code slop

Working code that no engineer would have left as-is:

• Placeholder residue — // TODO: implement, // your logic here, foo/bar/data/handleClick naming, lorem ipsum, commented-out scaffolding, console.log('here').
• Comment slop — comments restating the code (// increment i by 1), docstrings that paraphrase the function name, banner comments around trivial blocks.
• Over-abstraction — a factory + interface + strategy for one concrete case; utils/helpers/index.ts dumping grounds; premature generics.
• Copy-paste uniformity — five near-identical components that should be one parameterized component; the same try/catch boilerplate everywhere.
• Defensive theater — if (!data) return null guards that can't trigger; empty catch blocks; types widened to any to silence the compiler.

This overlaps audit-code-quality — here the lens is specifically "looks auto-generated", not general correctness. Flag, don't fix.

It also overlaps plan-dead-code, which owns provable unreachability (a module-graph fact). Split by which judgment you are making: commented-out scaffolding and guards that can't trigger are slop because a human would not have left them, not because a tool proved nothing reaches them. Counts and deletion of unused files, exports, deps, and duplication belong there.

4 · Structure & IA slop

The shape of the thing:

• Listicle-brain — everything is a bulleted list because the model defaults to lists; no prose, no flow, no argument.
• Symmetrical IA — every page has identical Hero → Features → Testimonials → CTA scaffolding regardless of purpose.
• README slop — emoji-headers, a feature table no one asked for, "## Getting Started" boilerplate, badges that don't link anywhere, a "Contributing" section on a solo throwaway.
• Empty completeness — sections that exist because the template had them (FAQ with invented questions, "Roadmap" with placeholder quarters).

Procedure [HIGH freedom]

1. Scope. Identify which of the four surfaces exist. State assumptions. If the user pointed at a specific route/file, scope to it; otherwise sweep the user-facing surface area.
2. Inventory. Walk each in-scope surface. Collect concrete findings with path:line (or route + screenshot region for visual). Quote the minimum needed to identify the tell — never paste whole files.
3. Score. Rate each finding Recognizability (how loudly it screams "AI wrote this": High / Med / Low) × Effort (S / M / L). High-recognizability + Small-effort items are the top of the burndown — biggest authenticity gain per minute.
4. Cluster into phases. Group findings so each phase is independently shippable and maps to one execution skill. Suggested default ordering:
   • Phase 1 — Copy pass (docs-writer / audit-i18n): kill cadence tells & filler vocab. Highest signal, lowest risk, no visual regression.
   • Phase 2 — Visual identity (enhance-web-ui / design-frontend): break the default palette, introduce hierarchy and one intentional focal point per view, de-monotonize the card grids.
   • Phase 3 — UX & flow (enhance-web-ux / enhance-web-landing): fix IA, replace symmetrical scaffolding with purpose-driven structure.
   • Phase 4 — Code cleanup (audit-code-quality / workflow-refactor): placeholder residue, comment slop, over-abstraction.
5. Emit the report. Write plan-antislop.md (template below). End the turn. Do not start Phase 1. Wait for explicit approval per phase — the composer-2.5-execution.mdc handoff contract applies.

Guardrails [LOW freedom — run exactly]

• Plan only. No rewrites, no edits, no "while I'm here" fixes. The deliverable is the report.
• Slop ≠ broken. Don't flag working code as slop just because it's simple. Simple-and-intentional is the goal, not a defect. The test is "would a human engineer/writer have left this exact thing?" — not "could this be fancier?"
• Voice is the user's, not yours. Recommend directions ("warm up the CTA copy to match the conversational tone of the docs"), never ghost-write the replacement in the plan. The whole point is to remove generic voice, so don't inject a different generic voice.
• Don't over-correct into anti-slop slop. Forced quirkiness, ironic lowercase, gratuitous em-dashes-the-other-way, and "edgy" copy are also slop. Flag the tendency; aim for intentional, not performative.
• Cite the design system. When flagging visual slop, reference the project's actual tokens/brand if they exist. "Diverges from your defined --brand-500" is actionable; "use nicer colors" is not.
• Minimal quoting. Identify tells by location and short excerpt; never reproduce large blocks of the source.

Self-critique before the burndown [LOW freedom — do not skip]

1. evidenced-not-assumed — path:line (or route + region) plus the tell
2. plan-only — direction only; no rewrite and no ghost-written replacement
3. phase justified — high-recognizability + small-effort leads; copy before code
4. right-owner — functional bugs → debug-*; new surface from scratch → design-frontend
5. no-false-safety — simple-and-intentional is not slop; don't invent anti-slop slop

Report template — plan-antislop.md

# Anti-Slop Burndown — <repo/route>

_Audit-only. Nothing changes until each phase is approved._

## Scope
- Surfaces audited: [ ] Prose  [ ] Visual  [ ] Code  [ ] Structure
- Out of scope / assumptions: …

## Slop score (at a glance)
| Surface    | Findings | High-recognizability | Top quick win |
|------------|----------|----------------------|---------------|
| Prose      | n        | n                    | …             |
| Visual     | n        | n                    | …             |
| Code       | n        | n                    | …             |
| Structure  | n        | n                    | …             |

## Findings
### Prose & copy
| # | Location | Tell | Why it reads as AI | Recog | Effort | Direction |
|---|----------|------|--------------------|-------|--------|-----------|
| P1 | hero/page.tsx:24 | "It's not just a tracker, it's a companion" | dual-clause hype cadence | High | S | state the concrete benefit plainly |

### Visual & UI
| # | Route/region | Tell | Recog | Effort | Direction |
|---|--------------|------|-------|--------|-----------|

### Code
| # | path:line | Tell | Recog | Effort | Direction |
|---|-----------|------|-------|--------|-----------|

### Structure & IA
| # | Location | Tell | Recog | Effort | Direction |
|---|----------|------|-------|--------|-----------|

## Phased burndown
- **Phase 1 — Copy pass** → `docs-writer` / `audit-i18n` — items P1, P3, P7…
- **Phase 2 — Visual identity** → `enhance-web-ui` / `design-frontend` — V1, V2…
- **Phase 3 — UX & flow** → `enhance-web-ux` / `enhance-web-landing` — S1, S4…
- **Phase 4 — Code cleanup** → `audit-code-quality` / `workflow-refactor` — C2…

## Execution handoff
Approve a phase to run it. Suggested order maximizes authenticity-per-effort.
Re-run `plan-antislop` after execution to confirm the burndown closed.

Chains with

• Six-skill plan loop — slots beside plan-uiux-unification; run after it so visual-slop findings inherit the design-system burndown.
• Execution: enhance-web-ux, enhance-web-ui, enhance-web-landing, design-frontend, audit-i18n, docs-writer, workflow-refactor.
• Verify: after execution, test-playwright (does it still work?) and a second plan-antislop pass (did the slop actually drop?).

Plan with a strong reasoning model; execute with composer-2.5-execution.mdc riding along. The plan says which slop to remove; the rule constrains how.