# Kill AI Slop Documentation > Technical docs for the kill-ai-slop agent skill, dependency-free project scanner, shared slop taxonomy, and Astro field-guide site. For engineers scanning web projects, remediating machine-default UI, or extending the catalogue and demos. ## Context Links - [Agent index](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/llms.txt) - [Human interactive docs](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb) - [GitHub repository](https://github.com/yetone/kill-ai-slop) ## Repository Metadata - Repository: yetone/kill-ai-slop - Generated: 2026-07-11T08:26:28.683Z - Updated: 2026-07-11T08:27:01.780Z - Runtime: Grok CLI - Format: Documentation - Pages: 18 ## Page Index - 01. [Overview](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/01-overview.md) - What Kill AI Slop exposes: the agent skill, scanner entry points, shared catalogue, and field-guide site, plus who should use which surface first. - 02. [Installation](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/02-installation.md) - Install the kill-ai-slop skill via npx or manual copy, and set up the Astro website dependencies for local development. - 03. [Quickstart](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/03-quickstart.md) - Shortest path to a first scanner report and a local field-guide run, with expected success signals and one recovery note each. - 04. [Slop taxonomy](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/04-slop-taxonomy.md) - Repo-specific model of AI-slop tells: categories, named signals, and how the field guide and skill share the same taxonomy language. - 05. [Catalogue model](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/05-catalogue-model.md) - How catalogue.ts is the single source of truth for tells, how demos and i18n attach, and boundaries between site data and skill references. - 06. [Skill workflow](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/06-skill-workflow.md) - Agent skill lifecycle: scan, triage, report, then propose or apply fixes without silent file edits from the standalone scanner. - 07. [Use the agent skill](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/07-use-the-agent-skill.md) - Invoke kill-ai-slop inside a coding agent after install: prompts, expected host behavior, and how the skill uses references and the scanner. - 08. [Scan a web project](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/08-scan-a-web-project.md) - Point the dependency-free scanner at a project path, interpret grouped vs JSON reports, and verify findings against detection rules. - 09. [Apply clean fixes](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/09-apply-clean-fixes.md) - Map scanner hits to remediation steps from the fixes playbook, choose propose vs apply in an agent host, and confirm the clean alternative. - 10. [Run the field guide site](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/10-run-the-field-guide-site.md) - Develop and preview the multilingual Astro field guide: install, dev server, static build output, and how entries and demos render on the index. - 11. [Extend the catalogue](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/11-extend-the-catalogue.md) - Add or update a tell: catalogue entry, i18n strings, plain-HTML demo, and alignment with skill taxonomy, detection, and fix references. - 12. [Scanner CLI reference](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/12-scanner-cli-reference.md) - Invocation, path argument, --json mode, walk/scan behavior, console formatting helpers, and hard constraint that the scanner never edits files. - 13. [Detection patterns](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/13-detection-patterns.md) - Code-level signals the skill and scanner look for per tell: patterns, match targets, and how findings map back to taxonomy ids. - 14. [Remediation playbook](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/14-remediation-playbook.md) - Per-tell clean fixes, what to remove or replace, and how before or after demos illustrate the preferred outcome. - 15. [Catalogue and demos data](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/15-catalogue-and-demos-data.md) - Fields and shapes in catalogue.ts, catalogue.i18n.ts, and demos.ts: tell ids, copy locales, and demo HTML payloads used by site components. - 16. [Design tokens](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/16-design-tokens.md) - Site self-constraints in tokens and global styles: paper and ink palette, single editorial red, hierarchy rules, and banned slop defaults. - 17. [Build and deploy](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/17-build-and-deploy.md) - Static site build to dist, deploy-anywhere assumptions, and operational notes for the zero-JS-by-default Astro field guide. - 18. [Contributing](https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/18-contributing.md) - Where to change skill references, scanner logic, catalogue data, or site components while keeping skill and website taxonomy aligned. ## Source File Index - `README.md` - `skill/README.md` - `skill/references/detection.md` - `skill/references/fixes.md` - `skill/references/taxonomy.md` - `skill/scripts/scan.mjs` - `skill/SKILL.md` - `website/astro.config.mjs` - `website/src/components/BeforeAfter.astro` - `website/src/components/LangToggle.astro` - `website/src/components/SlopEntry.astro` - `website/src/components/T.astro` - `website/src/components/ThemeToggle.astro` - `website/src/data/catalogue.i18n.ts` - `website/src/data/catalogue.ts` - `website/src/data/demos.ts` - `website/src/layouts/Base.astro` - `website/src/pages/index.astro` - `website/src/styles/demos.css` - `website/src/styles/global.css` - `website/src/styles/tokens.css` --- ## 01. Overview > What Kill AI Slop exposes: the agent skill, scanner entry points, shared catalogue, and field-guide site, plus who should use which surface first. - Page Markdown: https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/01-overview.md - Generated: 2026-07-11T08:24:27.902Z ### Source Files - `README.md` - `skill/SKILL.md` - `skill/scripts/scan.mjs` - `website/src/data/catalogue.ts` - `website/src/pages/index.astro` --- title: "Overview" description: "What Kill AI Slop exposes: the agent skill, scanner entry points, shared catalogue, and field-guide site, plus who should use which surface first." --- **Kill AI Slop** (`yetone/kill-ai-slop`) is a two-surface repo: a static multilingual Astro field guide under `website/`, and a portable agent skill under `skill/` (`name: kill-ai-slop`) with a dependency-free scanner at `skill/scripts/scan.mjs`. Both surfaces share one 23-tell taxonomy; the website catalogue at `website/src/data/catalogue.ts` is the documented single source of truth the skill enforces. ## Product surfaces | Surface | Path | Role | Edits project files? | | --- | --- | --- | --- | | Field guide site | `website/` | Multilingual catalogue (en/zh/ja/ko), before→after HTML demos, principles | No | | Agent skill | `skill/SKILL.md` + `skill/references/` | Scan → triage → report → propose/apply fixes in a coding-agent host | Only when the host applies fixes after the report | | Scanner CLI | `skill/scripts/scan.mjs` | Greps frontend source for code-level signals; grouped or JSON report | **Never** | ```mermaid flowchart TB subgraph repo["yetone/kill-ai-slop"] subgraph site["website/"] cat["src/data/catalogue.ts\n23 tells · tier · group · detect · demo"] index["src/pages/index.astro\nfield guide UI"] tokens["src/styles/tokens.css\npaper + ink self-rules"] end subgraph skillPack["skill/"] skillmd["SKILL.md\nworkflow + guardrails"] refs["references/\ntaxonomy · detection · fixes"] scan["scripts/scan.mjs\nTELS[] patterns"] end end cat -->|"taxonomy / detect chips"| index cat -->|"spec the skill enforces"| skillmd skillmd --> refs skillmd -->|"run for leads"| scan scan -->|"file:line hits only"| skillmd ``` Live field guide: [killaislop.com](https://killaislop.com). ## Who should use which surface first | Goal | Start here | Then | | --- | --- | --- | | Learn what each tell looks like and the clean alternative | Field guide (`website/`, or killaislop.com) | Scan a real project | | Clean a vibe-coded UI/docs project with an agent | Install skill → invoke with “kill the AI slop in this project” | Host runs scanner, triage, report, then fix | | Get a machine-readable hit map without an agent | `node skill/scripts/scan.mjs [--json]` | Confirm hits by reading code; map to fixes | | Add or change a tell | Update catalogue entry (+ i18n/demo as needed) and keep skill refs/scanner aligned | See extend-catalogue and contributing pages | The standalone scanner never edits files. Mass edits happen only in an agent host after the user has seen the report and approved groups to apply (`skill/SKILL.md` workflow). ## Repo layout ``` website/ Astro site — field guide (multilingual, static, zero-JS-by-default) skill/ kill-ai-slop Agent Skill (SKILL.md + references + scanner) ``` ### Website (`website/`) - Stack: Astro, static build to `dist/`, deploy anywhere. - Local: ```bash cd website npm install npm run dev # http://localhost:4321 npm run build # → dist/ ``` - Design self-constraints (README): paper + ink, **one** editorial red, hierarchy from scale and space, hairline rules; no gradients / emoji / glass / badges. Rules live in `website/src/styles/tokens.css`. - Index (`website/src/pages/index.astro`) loads `catalogue` and renders each entry via `SlopEntry`; sections include definition, catalogue (23 tells), and six principles. ### Skill (`skill/`) - Skill id: `kill-ai-slop`. - Host install (universal): ``` npx skills add yetone/kill-ai-slop ``` - Manual: copy `skill/` contents into the agent’s `kill-ai-slop/` skills directory (see repo README / `skill/README.md` for host-specific paths). - Works on HTML/CSS, React/Vue/Svelte/Astro, Tailwind, and Markdown copy (skill description). - Provider-neutral: the skill is files on disk (SKILL.md + references + scanner). Any Agent-Skills-compatible host can load it; no model-provider or hosted connector is required. ### Scanner (`skill/scripts/scan.mjs`) ```bash node skill/scripts/scan.mjs path/to/project # grouped report node skill/scripts/scan.mjs path/to/project --json # machine-readable ``` | CLI | Behavior | | --- | --- | | `[root]` | Project root; default `.` | | `--json` | Machine-readable output for triage | | `--no-color` | Disable ANSI color (also off when not a TTY or when `--json`) | Constraints from the scanner header and skill workflow: - Pure Node (`node:fs` / `node:path` only); no package dependencies. - **Never edits files.** Hits are leads to confirm by reading code, not verdicts. - Walks frontend extensions (`.html`, `.css`, `.scss`, `.sass`, `.less`, `.tsx`/`.jsx`/`.ts`/`.js`/`.mjs`/`.cjs`, `.vue`, `.svelte`, `.astro`, `.md`, `.mdx`, plus `tailwind.config.*`). - Skips dirs such as `node_modules`, `.git`, `dist`, `build`, `out`, `.next`, `.astro`, coverage, vendor, lockfiles, minified `*.min.js|css`, and files larger than 512 KiB. ## Shared taxonomy: 23 tells Both the site and the skill operate on **23** AI-slop tells. ### Catalogue model (`website/src/data/catalogue.ts`) Documented as the single source of truth for the website and the spec the skill enforces. | Field | Type / notes | | --- | --- | | `id` | String slug (e.g. `indigo-violet-gradient`) | | `n` | Position number (auto from array order) | | `tier` | `1` classic · `2` evolved | | `group` | `color` \| `type` \| `copy` \| `component` \| `layout` \| `evolved` | | `title` / `what` / `why` / `fix` | Localized `Bi` (`en` required; `zh` inline; `ja`/`ko` optional, merged from `catalogue.i18n.ts`) | | `detect` | Code-level signal chips shared with skill heuristics | | `demo?` | Key into demo HTML / before→after data | ### Scanner tell table (`skill/scripts/scan.mjs` `TELLS`) Numeric ids `01`–`23`, with `group`, human `name`, one-line `fix`, and regex `patterns`. Some tells set `copy: true` so they also scan prose files. | Group | Scanner examples (id · name) | | --- | --- | | `color` | `01` indigo→violet gradient · `02` gradient-clip headline · `03` warm cozy palette · `04` default semantic palette · `05` one-hue status box · `06` gradients as atmosphere | | `type` | `07` serif-italic emphasis · `08` serif where sans belongs · `09` decorative strikes & highlights | | `copy` | `10` highlighted keywords · `11` AI copywriting voice · `12` emoji everywhere | | `component` | `13`–`21` (glowing status dot, left-border callout, pastel icon tiles, max-radius/glass, shadows, nested corners, badge spam, AI SVG icon, icon-in-tint) | | `layout` | `22` all-caps card grid | | `evolved` | `23` tasteful-terminal | Catalogue string ids and scanner numeric ids describe the same 23-tell set; keep names, groups, and detect patterns aligned when extending the catalogue. ## Agent skill lifecycle From `skill/SKILL.md` — run in order; do not mass-edit before the user sees the report. ```mermaid stateDiagram-v2 [*] --> Scope Scope --> Scan: confirm roots; skip build artifacts Scan --> Triage: scan.mjs hits as map Triage --> Report: slop vs intentional Report --> Fix: user picks groups / all Fix --> Scan: re-run; count should drop Report --> [*]: user stops without apply ``` 1. **Scope** — Default app/site source; skip `node_modules`, `dist`, `build`, `.git`, vendor, lockfiles, minified files. Ask if multiple apps are mixed. 2. **Scan** — `node scripts/scan.mjs ` or `--json`. 3. **Triage** — Open each hit; keep deliberate brand/authorship; flag machine defaults. Use `references/taxonomy.md` and `references/detection.md`. 4. **Report** — Grouped summary before any write: tell, `file:line`, why, proposed fix. Ask which groups to apply. 5. **Fix** — Minimal change via `references/fixes.md`; prefer shared tokens/components; no new brand colors without user confirm; re-scan after. ### Guardrails - Respect authorship; ask when unsure. - Small reviewable diffs; never `git add -A`. - No new dependencies to do the work. - Visual check when a dev server exists; a clean scan ≠ a better page. ### Skill references | Path | Contents | | --- | --- | | `references/taxonomy.md` | 23 tells: what, why slop, fix | | `references/detection.md` | ripgrep/regex patterns + false positives | | `references/fixes.md` | before→after remediation patterns | | `scripts/scan.mjs` | Dependency-free scanner | ## Field guide content model Index sections (from `index.astro`): | Section | Purpose | | --- | --- | | Hero | Positioning + CTAs to `#catalogue` and `#skill` | | Definition | What “AI slop” means in this project | | Catalogue | 23 entries; classic vs evolved legend; before→after demos | | Principles | Six anti-slop rules (same spine as skill principles) | ### Six principles (site + skill) 1. Decide before you decorate 2. One accent, one voice 3. Hierarchy from scale and space 4. Subtract first 5. Specific beats loud / punchy (copy) 6. Decoration must mean something Demos are plain-HTML rebuilds for education, not screenshots of specific products (catalogue comments + README). ## Constraints and non-goals | Constraint | Surface | | --- | --- | | Scanner never edits files | `scan.mjs` | | Agent must report before mass fix | `SKILL.md` workflow | | Zero-JS-by-default static site | `website/` README | | Design system bans the tells it documents | `tokens.css` + site itself | | Skill adds no new npm deps for cleanup | Guardrails | | Hits are not automatic truth | Scanner + triage | Out of scope for this overview: full CLI flag reference, per-tell regex lists, remediation playbooks, catalogue field schemas, and install variants — those are separate docs pages. ## Next Install the skill via npx or manual copy; set up website dependencies. First scanner report and local field-guide run with success signals. Categories, named signals, and shared language across site and skill. How catalogue.ts is the single source of truth and how demos/i18n attach. Scan → triage → report → propose/apply without silent scanner edits. Invocation, --json, walk behavior, and the no-edit hard constraint. --- ## 02. Installation > Install the kill-ai-slop skill via npx or manual copy, and set up the Astro website dependencies for local development. - Page Markdown: https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/02-installation.md - Generated: 2026-07-11T08:24:13.292Z ### Source Files - `README.md` - `skill/README.md` - `skill/SKILL.md` - `website/astro.config.mjs` --- title: "Installation" description: "Install the kill-ai-slop skill via npx or manual copy, and set up the Astro website dependencies for local development." --- Kill AI Slop ships two installable surfaces from the same repository: the `kill-ai-slop` Agent Skill under `skill/` (SKILL.md, references, and a dependency-free scanner), and the multilingual Astro field guide under `website/`. Skill install is a directory copy into an agent skills root; the website is a normal `npm install` under `website/`. ## What you install | Surface | Path | Requires packages | Purpose after install | |---|---|---|---| | Agent skill | `skill/` → host skills dir as `kill-ai-slop/` | No | Agent-driven scan → triage → report → fix | | Standalone scanner | `skill/scripts/scan.mjs` | No (pure Node) | Read-only grouped or JSON report | | Field guide site | `website/` | Yes (`npm install`) | Local dev at `http://localhost:4321`, static build to `dist/` | ``` website/ Astro site (multilingual, static, zero-JS-by-default) skill/ kill-ai-slop Agent Skill (SKILL.md + references + scanner) ``` The skill is self-contained: copy the whole directory; there is no package install and no build step for the skill itself. ## Prerequisites | Task | Runtime | |---|---| | Universal skill installer | `npx` (Node) | | Manual skill copy | `git` + shell (or any copy tool) | | Standalone scanner | Node only | | Website local run / build | Node + npm under `website/` | No model provider, API key, or hosted connector is required for install. Agent hosts (for example Claude Code) only need their own skills directory layout. ## Install the agent skill Choose one path. Destination folder name must be `kill-ai-slop`. ### Option A — Universal agent installer ```bash npx skills add yetone/kill-ai-slop ``` Follow the installer prompt for the target coding agent. ### Option B — Ask the agent to install Paste into the coding agent (Claude Code, Cursor, or another Agent Skills host): ``` Install the kill-ai-slop skill from https://github.com/yetone/kill-ai-slop/tree/main/skill Copy everything in that directory into a kill-ai-slop/ folder inside your agent's skills directory, then confirm it's registered. ``` The host should read `SKILL.md`, place the directory, and register the skill. You do not need to name individual files; the agent copies the directory as-is. ### Option C — Manual clone and copy ```bash git clone https://github.com/yetone/kill-ai-slop # Claude Code examples — swap the destination for other agents cp -r kill-ai-slop/skill ~/your-project/.claude/skills/kill-ai-slop # this project only cp -r kill-ai-slop/skill ~/.claude/skills/kill-ai-slop # every project ``` Copy the **entire** `skill` directory. Do not flatten or omit `references/` or `scripts/`. | Host example | Project-scoped skills | User-global skills | |---|---|---| | Claude Code | `/.claude/skills/kill-ai-slop` | `~/.claude/skills/kill-ai-slop` | Other agents use their own skills root; keep the folder name `kill-ai-slop`. ### Skill layout after install | Path | Role | |---|---| | `SKILL.md` | Skill name, description, workflow, guardrails | | `references/taxonomy.md` | 23 tells: definition, why it reads as slop, fix direction | | `references/detection.md` | Code patterns per tell and common false positives | | `references/fixes.md` | Before→after remediation patterns | | `scripts/scan.mjs` | Dependency-free scanner | Skill frontmatter identity: | Field | Value | |---|---| | `name` | `kill-ai-slop` | | Triggers (examples) | “kill AI slop”, “de-slop”, “remove the AI look”, “make this not look AI-generated” | ### Verify the skill 1. Confirm the host lists or loads `kill-ai-slop`. 2. Confirm the directory contains `SKILL.md`, `references/`, and `scripts/scan.mjs`. 3. Invoke with a plain request such as: > Kill the AI slop in this project. Also accepted: “de-slop this”, “remove the AI look”, “make this not look AI-generated”. Expected host behavior after install: **scan** → **triage** (slop vs intentional) → **report** grouped summary **before** edits → **fix** only approved groups. The standalone scanner never edits files; file changes come only from the agent workflow when you approve them. ## Install website dependencies (local field guide) Live site: [killaislop.com](https://killaislop.com). For a local copy: ```bash cd website npm install npm run dev # http://localhost:4321 npm run build # → dist/ (static, deploy anywhere) ``` | Command | Result | |---|---| | `npm install` | Install website dependencies in `website/` | | `npm run dev` | Dev server at `http://localhost:4321` | | `npm run build` | Static output under `website/dist/` | Astro config (`website/astro.config.mjs`): | Key | Value | Notes | |---|---|---| | `site` | `https://killaislop.com` | Canonical site URL | | `build.inlineStylesheets` | `'auto'` | Stylesheet inlining policy | | Integrations | none | Single static, dependency-light content site by design | Success signals: - Dev: field guide serves on `http://localhost:4321`. - Build: `dist/` is produced and is static (deploy-anywhere artifact). ## Run the scanner without the agent skill You can point the scanner at any web project path. It is pure Node, has no dependencies, and never edits files. From the repository root: ```bash node skill/scripts/scan.mjs path/to/project # grouped report node skill/scripts/scan.mjs path/to/project --json # machine-readable ``` From inside the installed skill directory (or `skill/`): ```bash node scripts/scan.mjs path/to/src # human-readable report node scripts/scan.mjs path/to/src --json # machine-readable ``` | Mode | Flag | Output use | |---|---|---| | Human-readable | (default) | Grouped `file:line` hits for review | | Machine-readable | `--json` | Triage / tooling | Treat hits as leads to confirm by reading code, not automatic verdicts. ## Constraints - Skill install = full directory copy as `kill-ai-slop/`; no skill packages, no skill build. - Scanner: read-only; no file writes. - Website: install and run only under `website/`; skill and site installs are independent. - No new dependencies are required to *use* the skill workflow on a target project (skill guardrail). ## Troubleshooting | Symptom | Check | |---|---| | Agent does not pick up the skill | Folder name is `kill-ai-slop`; path is the host’s skills directory (e.g. `.claude/skills/` or `~/.claude/skills/`); `SKILL.md` is present at the skill root. | | Incomplete skill (missing taxonomy / scanner) | Entire `skill/` tree was copied, including `references/` and `scripts/`. | | `npx skills add` fails | Node/`npx` available; network can reach the package/skills registry and `yetone/kill-ai-slop`. Fall back to Option B or C. | | `npm run dev` / `npm run build` fails | Commands run from `website/` after `npm install`. | | Scanner path wrong | From repo root use `skill/scripts/scan.mjs`; from skill root use `scripts/scan.mjs`. | ## Next Shortest path to a first scanner report and a local field-guide run. Prompts, host behavior, and how the skill uses references and the scanner after install. Point the dependency-free scanner at a path and read grouped vs JSON reports. Dev server, static build output, and how catalogue entries render on the index. Scan, triage, report, then propose or apply fixes without silent scanner edits. Invocation, path argument, `--json`, and the no-edit constraint. --- ## 03. Quickstart > Shortest path to a first scanner report and a local field-guide run, with expected success signals and one recovery note each. - Page Markdown: https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/03-quickstart.md - Generated: 2026-07-11T08:24:14.025Z ### Source Files - `README.md` - `skill/scripts/scan.mjs` - `skill/README.md` - `website/astro.config.mjs` - `website/src/pages/index.astro` --- title: "Quickstart" description: "Shortest path to a first scanner report and a local field-guide run, with expected success signals and one recovery note each." --- `kill-ai-slop` has two independent first-run surfaces: the dependency-free scanner at `skill/scripts/scan.mjs` (read-only `file:line` report, never edits), and the Astro field guide under `website/` (`npm run dev` → `http://localhost:4321`). Neither path requires the other; both share the same 23-tell catalogue language as the agent skill. ## Prerequisites | Surface | Need | | --- | --- | | Scanner | Node.js (run `node` on `scan.mjs`); a local path to a web project | | Field guide | Node + npm; clone or checkout of this repo | Optional later: install the `kill-ai-slop` Agent Skill via `npx skills add yetone/kill-ai-slop` or by copying `skill/` into your agent’s skills directory. The skill is not required for the two runs below. ## A. First scanner report The scanner walks frontend-ish sources under a root path, greps code-level signals for each of the 23 tells, and prints a grouped report of `file:line` hits. It skips large files, lockfiles, minified assets, and common build dirs. Hits are leads to confirm by reading the code, not verdicts. ### Run From the repository root: ```bash node skill/scripts/scan.mjs path/to/project # grouped report node skill/scripts/scan.mjs path/to/project --json # machine-readable ``` From inside `skill/`: ```bash node scripts/scan.mjs path/to/src # human-readable report node scripts/scan.mjs path/to/src --json # machine-readable ``` CLI shape from `scan.mjs`: ```text node scan.mjs [root] [--json] [--no-color] ``` | Input | Behavior | | --- | --- | | `root` | First non-flag argument; defaults to `.` | | `--json` | Machine-readable output; disables color | | `--no-color` | Force plain console output | **Scanned extensions (examples):** `.html`, `.css`, `.scss`, `.sass`, `.less`, `.tsx`, `.jsx`, `.ts`, `.js`, `.mjs`, `.cjs`, `.vue`, `.svelte`, `.astro`, `.md`, `.mdx`, plus `tailwind.config.*`. **Skipped directories (examples):** `node_modules`, `.git`, `dist`, `build`, `out`, `.next`, `.astro`, `.output`, `.svelte-kit`, `.nuxt`, `coverage`, `vendor`, `.cache`, `.vercel`, `.turbo`. ### Success signal - Process exits after printing a **grouped report** of hits (human mode) or a **JSON** payload (`--json`). - No project files change: the scanner is read-only and dependency-free. - With color enabled (TTY, not `--json`, no `--no-color`), console formatting may be colored; plain text is still valid success. ### Recovery (one note) If the report is empty or the walk seems to miss your app, confirm the path argument points at real frontend source (not only `node_modules` / `dist`), that files use a scanned extension, and that individual files are under the 512 KB skip threshold. Re-run with an explicit root, e.g. `node skill/scripts/scan.mjs ./src`. ## B. Local field-guide run The site under `website/` is a multilingual (English, Chinese, Japanese, Korean) static Astro field guide: 23 tells with interactive before→after HTML demos, catalogue data as the taxonomy source of truth, and a paper/ink design system. ### Run ```bash cd website npm install npm run dev # http://localhost:4321 ``` Optional static build check: ```bash npm run build # → dist/ (static, deploy anywhere) ``` `website/astro.config.mjs` sets `site: 'https://killaislop.com'` and `build.inlineStylesheets: 'auto'`. No Astro integrations are configured by design. ### Success signal - Dev server serves the field guide at **`http://localhost:4321`**. - Index shows the hero, definition, **catalogue** section (`#catalogue`) with entries from `catalogue` data (23 tells, before→after demos), and principles. - `npm run build` writes a static tree under `website/dist/`. ### Recovery (one note) If `npm run dev` fails or the port never comes up, ensure you ran `npm install` **inside** `website/` (not the repo root) and that nothing else is bound to `4321`; re-run from `website/` after a clean install. ## Optional: agent skill in one prompt After skill install (`npx skills add yetone/kill-ai-slop`, or copy `skill/` → `kill-ai-slop/` under the host skills dir), ask the agent: > Kill the AI slop in this project. Expected host behavior (from `skill/README.md` / skill docs): **scan** → **triage** → **report** a grouped summary before edits → **fix** only approved groups. The standalone scanner never applies fixes; edits happen only through the agent skill workflow when you approve them. ## What you should not expect from these first runs | Surface | Does | Does not | | --- | --- | --- | | `scan.mjs` | Read, match patterns, print hits | Edit files, install packages, call network APIs | | `website` dev/build | Serve/build the field guide | Scan your product code | | Agent skill (optional) | Scan, triage, report, propose/apply fixes under host control | Silent file edits from the scanner alone | ## Next Skill install via npx or manual copy, and website dependency setup. Interpret grouped vs JSON reports and verify hits against detection rules. Dev server, static build, and how catalogue entries render on the index. Invoke kill-ai-slop inside a coding agent after install. Full invocation, flags, walk behavior, and the no-edit constraint. --- ## 04. Slop taxonomy > Repo-specific model of AI-slop tells: categories, named signals, and how the field guide and skill share the same taxonomy language. - Page Markdown: https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/04-slop-taxonomy.md - Generated: 2026-07-11T08:24:29.612Z ### Source Files - `skill/references/taxonomy.md` - `website/src/data/catalogue.ts` - `skill/references/detection.md` - `README.md` --- title: "Slop taxonomy" description: "Repo-specific model of AI-slop tells: categories, named signals, and how the field guide and skill share the same taxonomy language." --- `website/src/data/catalogue.ts` is the single source of truth for the AI-slop catalogue: 23 numbered tells, two tiers, six groups, and per-tell `what` / `why` / `fix` / `detect` fields that the Astro field guide renders and that the `kill-ai-slop` skill enforces. The skill restates the same model in `skill/references/taxonomy.md`, with code-level signals in `skill/references/detection.md` (encoded by `skill/scripts/scan.mjs`) and remediations in `skill/references/fixes.md`. ## Canonical model Kill AI Slop defines **tells** — named machine-default UI/copy patterns — not abstract design theory. Every tell is meant to be findable in shipped products; each field-guide entry rebuilds the tell in plain HTML so the machine default and the clean fix sit side by side. | Surface | Role | Taxonomy artifact | | --- | --- | --- | | Website (`website/`) | Multilingual field guide + before→after demos | `catalogue.ts` entries, `GROUPS`, `demo` keys | | Agent skill (`skill/`) | Scan, triage, report, propose/apply fixes | `references/taxonomy.md`, `detection.md`, `fixes.md` + `scripts/scan.mjs` | ```text website/src/data/catalogue.ts ← single source of truth (spec) │ ├─► field guide UI (groups, copy, demos) │ └─► skill enforcement taxonomy.md (what / why / fix language) detection.md (human + scanner patterns) fixes.md (remediation playbook) scan.mjs (encodes detection; never edits files) ``` English catalogue strings are the source of truth. Chinese is inline in `catalogue.ts`; Japanese and Korean merge from `catalogue.i18n.ts` and fall back to English at the localization layer. ## Decision rule Slop is the **absence of a decision**. A tell counts only when the element is a default nobody chose. The same visual or copy move, chosen and defended for the product, is not slop. Detection docs treat every match as a **lead, not a verdict** — open the file and confirm before acting. ## Tiers Catalogue comments and `taxonomy.md` use the same two-tier split: | Tier | Label | Meaning | | --- | --- | --- | | `1` | Classic | Widely recognized tells most people already spot | | `2` | Evolved | Newer defaults that already read as templated (e.g. “tasteful terminal”) | In `catalogue.ts`, `Entry.tier` is `1 | 2`. Entries are numbered by position in the array (`n` is applied via map), so inserting a case renumbers the rest automatically. ## Groups Stable group keys (`Group` type) and English labels: | `group` | English label | Scope in taxonomy | | --- | --- | --- | | `color` | Color | Gradients, palettes, semantic/status color defaults | | `type` | Type | Serif misuse, decorative strike/highlight emphasis | | `copy` | Copy | Keyword highlighting, AI voice, decorative emoji | | `component` | Components | Status dots, callout bars, icon tiles, glass, shadows, badges, SVG marks | | `layout` | Layout | All-caps interchangeable card/stat grids | | `evolved` | Evolved slop | Terminal-chic mono + near-black template look | Localized group titles live in `GROUPS` (`en` / `zh` / `ja` / `ko`). ## Tell inventory Numbers **01–23** are shared by `skill/references/taxonomy.md` and `skill/references/detection.md`. Catalogue stable string `id` values appear below only where present in the supplied `catalogue.ts` excerpt; remaining tells are identified by number and title until you read the full raw entry list. ### Color (`group: "color"`, classic) | # | Title | Catalogue `id` (when present) | One-line what | | --- | --- | --- | --- | | 01 | Indigo→violet gradient | `indigo-violet-gradient` | `#6366f1 → #a855f7` diagonal on buttons, glows, heroes | | 02 | Gradient headline text | `gradient-text` | `background-clip: text` rainbow fills on headings | | 03 | Warm “cozy” palette | `warm-cozy-palette` | Amber/stone/orange wash on soft beige | | 04 | Default semantic palette | `default-semantic-palette` | Stock info/tip/success/error `-50` / `-600` set | | 05 | One-hue status box | `mono-hue-alert` | Border, text, and tint bg all one hue at three opacities | | 06 | Gradients as atmosphere | `atmosphere-gradient` | Page-wide glow + gradient card fills as “premium dark” | ### Type (`group: "type"`, classic) | # | Title | Catalogue `id` (when present) | One-line what | | --- | --- | --- | --- | | 07 | Serif-italic on one word | `serif-emphasis` | One word in a sans headline swapped to serif italic | | 08 | Serif where sans belongs | `serif-body-misuse` | Display serif (Playfair/Lora/etc.) as UI/body on tools/SaaS | | 09 | Decorative strikes & highlights | — | Strike/underline/highlight as decoration, not edit/link/annotation | ### Copy (`group: "copy"`, classic) | # | Title | One-line what | | --- | --- | --- | | 10 | Highlighted keywords | Colored/bold spans mid-paragraph as default emphasis | | 11 | AI copywriting voice | “Not just X — it’s Y”, triad slogans, em-dash rhythm | | 12 | Emoji everywhere | Emoji on every heading, button, and bullet | ### Components (`group: "component"`, classic) | # | Title | One-line what | | --- | --- | --- | | 13 | Glowing status dot | Pulsing/haloing green “ready/online/live” gem | | 14 | Rounded card, colored left border | Docs admonition bar wrapped around ordinary list rows | | 15 | Rounded-square icon tiles | Feature grid of icon chips with little content link | | 16 | Max radius + glassmorphism | `rounded-full` + `backdrop-blur` as default surface | | 17 | Oversized drop shadow | Huge soft blur/spread larger than the casting element | | 18 | Corners that don’t nest | Same large radius on nested boxes (no outer − padding math) | | 19 | Badge and pill spam | Decorative “New/Beta/Popular” pills in chrome | | 20 | AI-drawn SVG icons | Blob/mascot primitive SVG shipped as product mark | | 21 | Icon in a tint of itself | Icon on `bg-{hue}/10` matching its own color | ### Layout (`group: "layout"`, classic) | # | Title | One-line what | | --- | --- | --- | | 22 | All-caps card grid | ALL-CAPS micro-labels + number/icon in equal-weight cards | ### Evolved slop (`group: "evolved"`, tier 2) | # | Title | One-line what | | --- | --- | --- | | 23 | The “tasteful terminal” | Mono UI chrome, near-black, one warm accent, ASCII decoration | ## Entry shape (catalogue) ```ts export type Group = "color" | "type" | "copy" | "component" | "layout" | "evolved"; export interface Bi { en: string; zh: string; ja?: string; ko?: string; } export interface Entry { id: string; n: number; // assigned by position tier: 1 | 2; group: Group; title: Bi; what: Bi; // one line: what the tell is why: Bi; // why it reads as machine-made fix: Bi; // the clean move detect: string[]; // code-level signals (chips + skill heuristics) demo?: string; // key into demos / BeforeAfter data } ``` Field roles: | Field | Use | | --- | --- | | `id` | Stable tell key; demo key usually matches when set | | `n` | Display number; renumbers with array order | | `tier` / `group` | Filter and section grouping on the site | | `what` / `why` / `fix` | Shared prose language with skill taxonomy | | `detect` | Short signal chips; parallel to detection reference patterns | | `demo` | Optional live HTML before→after key | ## How the skill speaks the same language | Concern | Skill reference | Aligns with catalogue | | --- | --- | --- | | Names, what/why/fix | `skill/references/taxonomy.md` | Entry titles + `what` / `why` / `fix` | | Code-level signals | `skill/references/detection.md` + `scan.mjs` | Entry `detect[]` | | Remediation | `skill/references/fixes.md` | Entry `fix` + site demos | | Invocation path | `skill/SKILL.md` (scan → triage → report → fix) | Same 23-tell set | Detection is numbered **01–23** to match taxonomy. Scan scope (from `detection.md`): frontend sources `.html .css .scss .tsx .jsx .ts .js .vue .svelte .astro .md .mdx` plus `tailwind.config.*`; skip `node_modules`, `dist`, `build`, `.git`, `out`, `.next`, `.astro`, `coverage`, `vendor`, `*.min.*`, and lockfiles. Scanner entry points (read-only; never edit files): ```bash node skill/scripts/scan.mjs path/to/project # grouped report node skill/scripts/scan.mjs path/to/project --json # machine-readable ``` ## Signal language (examples) Catalogue `detect` chips are short human/scanner heuristics. Skill `detection.md` expands them to concrete `rg` patterns and false-positive notes. Examples from catalogue entries present in evidence: | Tell | Sample `detect` chips | | --- | --- | | `indigo-violet-gradient` | `from-indigo-500 to-purple-500`, `#6366f1 → #a855f7`, `shadow-purple-500/50` | | `gradient-text` | `bg-clip-text text-transparent`, `background-clip: text` | | `warm-cozy-palette` | `amber-50 / stone-100 / orange-400`, `border-amber-200` | | `default-semantic-palette` | `-50 bg + -600 text semantic set` | | `mono-hue-alert` | `border-{c} text-{c} bg-{c}/10 status box` | | `atmosphere-gradient` | `radial-gradient page background`, dark navy + top glow | | `serif-emphasis` | `font-serif italic inside a sans

` | | `serif-body-misuse` | Playfair / Lora / Cormorant family usage in UI body | Hard-to-grep tells (serif-italic nesting, nested corner math, visual SVG judgment, tasteful terminal) require human confirmation even when a pattern fires. ## Fix language (taxonomy pattern) Every taxonomy entry ends with a short **Fix:** line. Pattern: 1. Remove or stop the default reflex. 2. Prefer structure (weight, space, hierarchy, one chosen accent) over decoration. 3. Keep the device only when it carries real product meaning (true status, real link, real brand). Site demos (`demo` keys) and the remediation playbook illustrate the preferred outcome; the standalone scanner never applies fixes — only an agent host following `skill/SKILL.md` proposes or applies them. ## Alignment constraints When extending or changing the model: - Add or edit the tell in `catalogue.ts` first (SoT). - Keep `taxonomy.md` / `detection.md` / `fixes.md` on the same number, name, and intent. - Attach a plain-HTML demo when the site should show before→after. - Do not treat a deliberate brand choice as a hit without confirmation. ## Related pages How catalogue.ts owns tells, demos, and i18n, and where site data ends and skill references begin. Per-tell code signals, match targets, and mapping back to taxonomy numbers. Per-tell clean fixes and how before/after demos show the preferred outcome. Add or update a tell across catalogue, i18n, demo, and skill references. Scan, triage, report, then propose or apply fixes without silent scanner edits. Field shapes for catalogue.ts, catalogue.i18n.ts, and demos.ts. --- ## 05. Catalogue model > How catalogue.ts is the single source of truth for tells, how demos and i18n attach, and boundaries between site data and skill references. - Page Markdown: https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/05-catalogue-model.md - Generated: 2026-07-11T08:25:10.887Z ### Source Files - `website/src/data/catalogue.ts` - `website/src/data/catalogue.i18n.ts` - `website/src/data/demos.ts` - `skill/references/taxonomy.md` - `website/src/components/SlopEntry.astro` --- title: "Catalogue model" description: "How catalogue.ts is the single source of truth for tells, how demos and i18n attach, and boundaries between site data and skill references." --- `website/src/data/catalogue.ts` defines the field-guide tell list: stable `id`s, display order `n`, tier, group, localized `title` / `what` / `why` / `fix`, code-level `detect` chips, and an optional `demo` key. The file header states it is the single source of truth for the website and the spec the kill-ai-slop skill enforces. Japanese and Korean copy attach from `catalogue.i18n.ts`; before→after HTML lives in `demos.ts` and is rendered by `SlopEntry.astro` via `BeforeAfter`. ## Role in the repo | Artifact | Path | Owns | | --- | --- | --- | | Catalogue entries | `website/src/data/catalogue.ts` | Tell identity, order, tiers, groups, EN/ZH copy, `detect` strings, `demo` key | | JA/KO strings | `website/src/data/catalogue.i18n.ts` | Optional `title` / `what` / `why` / `fix` per `id` for `ja` and `ko` | | Demo HTML | `website/src/data/demos.ts` | Plain-HTML `before` / `after` payloads keyed by demo id | | Demo styles | `styles/demos.css` (scoped under `.demo-`) | Visual treatment for each demo pane | | Entry UI | `website/src/components/SlopEntry.astro` | Renders one `Entry`: group tag, localized fields, demo, detect chips | | Skill taxonomy prose | `skill/references/taxonomy.md` | Agent-facing narrative of the same tell set (what / why / fix) | | Skill detection / fixes | `detection.md`, `fixes.md` (referenced from taxonomy) | Detection patterns and code patches for the skill workflow | ```mermaid flowchart TB subgraph site["Field guide site"] CAT["catalogue.ts\nEntry[], GROUPS, Bi"] I18N["catalogue.i18n.ts\nja / ko by id"] DEM["demos.ts\nbefore / after HTML"] CSS["demos.css\n.demo-id scopes"] SE["SlopEntry.astro"] T["T.astro locale layer"] BA["BeforeAfter"] CAT -->|"merge ja/ko into Bi"| SE I18N --> CAT CAT -->|"entry.demo key"| BA DEM --> BA CSS --> BA SE --> T SE --> BA end subgraph skill["Agent skill references"] TAX["taxonomy.md\n23 tells, tiers, categories"] DET["detection.md"] FIX["fixes.md"] TAX --> DET TAX --> FIX end CAT -.->|"shared tell language / enforce as spec"| TAX CAT -->|"detect[] as mono chips + skill heuristics"| DET ``` The dashed link is alignment, not a TypeScript import. Site components import from `../data/catalogue`; skill agents read markdown under `skill/references/`. Keep ids, meaning, and remediation language in sync across both surfaces. ## Entry shape `Entry` and related types in `catalogue.ts`: | Field | Type | Required | Role | | --- | --- | --- | --- | | `id` | `string` | yes | Stable slug; article `id` / deep-link hash (`#${entry.id}`) | | `n` | `number` | yes | Display number; assigned from array position (inserting renumbers the rest) | | `tier` | `1 \| 2` | yes | `1` classic, `2` evolved | | `group` | `Group` | yes | Category key into `GROUPS` | | `title` | `Bi` | yes | Short name | | `what` | `Bi` | yes | One line: what the tell is | | `why` | `Bi` | yes | Why it reads as machine-made | | `fix` | `Bi` | yes | Clean alternative | | `detect` | `string[]` | yes | Code-level signals (UI mono chips + skill heuristics) | | `demo` | `string` | no | Key into demos data / `demos.css` / `BeforeAfter` | ```ts export type Group = "color" | "type" | "copy" | "component" | "layout" | "evolved"; export interface Bi { en: string; zh: string; ja?: string; ko?: string; } export interface Entry { id: string; n: number; tier: 1 | 2; group: Group; title: Bi; what: Bi; why: Bi; fix: Bi; detect: string[]; demo?: string; } ``` `rawEntries` is typed as `Omit[]`. Comments state numbering is by position so inserts renumber automatically. `GROUPS` is a `Record` used for the category tag on each entry. ### Tiers and groups | Concept | Values | Meaning in catalogue header / UI | | --- | --- | --- | | Tier 1 | `tier: 1` | Classic slop — tells most people already recognise | | Tier 2 | `tier: 2` | Evolved slop — newer defaults that already read as templated | | Groups | `color`, `type`, `copy`, `component`, `layout`, `evolved` | EN labels: Color, Type, Copy, Components, Layout, Evolved slop (plus ZH/JA/KO in `GROUPS`) | `SlopEntry` styles the group tag with `t${entry.tier}` (e.g. `tag group t2` for evolved emphasis). ### Localized strings (`Bi`) - English is the source of truth and always present. - Chinese (`zh`) is authored inline on each entry in `catalogue.ts`. - Japanese and Korean are optional on `Bi` and are merged in from `catalogue.i18n.ts`. - Missing locales fall back to English at the `` layer; partial translations are safe. `catalogue.i18n.ts` exports: ```ts type Field = "title" | "what" | "why" | "fix"; type LangText = Partial>; export interface EntryI18n { ja?: LangText; ko?: LangText; } export const i18n: Record = { /* keyed by entry id */ }; ``` Voice rule in that file: match English — terse, plain, specific; no punchy triads, no “not just X, it’s Y”, no exclamation. Site copy must not commit the slop patterns the catalogue documents. ## How demos attach 1. Catalogue entry sets `demo` to a string key (usually the same slug as `id`, e.g. `"indigo-violet-gradient"`). 2. `demos.ts` exports `demos: Record` with plain HTML for each key. 3. Styles live under `.demo-` in `styles/demos.css`. 4. `SlopEntry` renders `{entry.demo && }`. Demo contract (from `demos.ts` header): - Rebuild the tell in HTML (`before`) and the clean counterpart (`after`). - Keep illustrative copy short and neutral. - `after` panes follow the same rules the site and skill enforce: one accent, no gradient chrome, hierarchy from scale + space, mono for code only, no decorative emoji/badges. Earlier drafts used annotated screenshots of a reference product; those were removed in favour of live HTML demos so comparisons stay precise and do not drift. ### Example wire-up Catalogue fragment: ```ts { id: "indigo-violet-gradient", tier: 1, group: "color", title: { zh: "蓝紫渐变", en: "The indigo→violet gradient" }, // what, why, fix... detect: [ "from-indigo-500 to-purple-500", "#6366f1 → #a855f7", "bg-gradient-to-r via-purple", "shadow-purple-500/50", ], demo: "indigo-violet-gradient", } ``` Matching demo key in `demos.ts`: ```ts "indigo-violet-gradient": { before: `/* card with gradient chrome, decorative emoji */`, after: `/* solid surfaces, plain label, solid button */`, } ``` If `demo` is omitted, `SlopEntry` still renders text fields and detect chips; only the evidence pane is skipped. ## How the site consumes an entry `SlopEntry.astro` props: `{ entry: Entry }`. | UI region | Data | | --- | --- | | Permalink number | `String(entry.n).padStart(2, "0")`; `href={`#${entry.id}`}`; click copies shareable `#id` URL | | Group tag | `` with class `t${entry.tier}` | | Title / what | ``, `` | | Demo | `BeforeAfter` when `entry.demo` is set | | Why / fix | Localized section labels + `` / `fix` | | Code signals | `entry.detect.map` → `` chips | Article root: `
`. Deep links land on the tell; sticky-nav offset is handled globally (`html { scroll-padding-top }`), not inside the entry. ## Skill boundary: catalogue vs references `skill/references/taxonomy.md` opens with **23 tells, in two tiers** (Classic / Evolved). For each tell it covers what it is, why it reads as machine-made, and the fix. Detection patterns live in `detection.md`; code patches in `fixes.md`. Shared rule across taxonomy and catalogue framing: **slop is the absence of a decision**. A tell is only slop when it is a default nobody chose; the same element, chosen and defended, is fine. | Concern | Site catalogue | Skill references | | --- | --- | --- | | Authoritative structured data for the Astro field guide | Yes (`catalogue.ts`) | No | | Multilingual field-guide UI copy | Yes (`Bi` + i18n) | Taxonomy is prose (EN in the evidence) | | Live before/after demos | Yes (`demos.ts` + CSS) | No | | Agent scan / triage narrative | Spec alignment via comments + `detect` heuristics | Yes (`taxonomy.md`) | | Machine-oriented detection rules | `detect[]` chips (shared language) | Full patterns in `detection.md` | | Remediation patches | `fix` prose on the entry | Playbook in `fixes.md` | Do not treat `catalogue.ts` as runtime input for the standalone scanner unless another surface imports it. Treat it as the website SSOT and the human/agent-aligned **spec** that skill docs must match. When adding or renaming a tell, update catalogue identity first, then demos, i18n, and skill taxonomy / detection / fix references so ids and meaning stay one language. ### Id ↔ taxonomy alignment (examples) Stable catalogue ids are slug identifiers; taxonomy.md uses numbered titles. Align by meaning, not by inventing a runtime bridge: | Catalogue `id` (examples from data) | Taxonomy title (examples) | | --- | --- | | `indigo-violet-gradient` | 01 · Indigo→violet gradient | | `gradient-text` | 02 · Gradient headline text | | `warm-cozy-palette` | 03 · Warm "cozy" palette | | `default-semantic-palette` | 04 · The default semantic palette | | `mono-hue-alert` | 05 · The one-hue status box | | `atmosphere-gradient` | 06 · Gradients as atmosphere | | `serif-emphasis` | 07 · Serif-italic on one word | | `emoji-everywhere` | 12 · Emoji everywhere | | `status-dot-glow` | 13 · The glowing status dot | | `left-border-callout` | 14 · Rounded card, colored left border | Full id inventory, complete `detect` lists, and full demo HTML shapes belong on the data reference page; this page defines the model and attachment rules only. ## Constraints and verification | Constraint | Signal | | --- | --- | | English always present on every `Bi` field | Required `en` / `zh` on type; EN is fallback | | JA/KO optional and partial-safe | `Partial` fields; missing → EN at `` | | `demo` key must exist in `demos` when set | Runtime: `BeforeAfter` lookup by id; missing key fails the evidence pane | | Demo styles scoped by id | `.demo-` in `demos.css` | | Numbering is positional | Insert/reorder `rawEntries` renumbers `n` | | Site copy must not be slop | i18n header voice rules; demo `after` rules | | Skill docs stay in the same language | Parallel update of taxonomy / detection / fixes | After a catalogue change: confirm `id` uniqueness, `demo` key match, i18n key match, and that taxonomy/detection/fix text still describe the same tell. ## Related pages Categories, named signals, and how field guide and skill share taxonomy language. Field-level shapes for catalogue.ts, catalogue.i18n.ts, and demos.ts. Add or update a tell across catalogue, i18n, demo, and skill references. Code-level signals and how findings map back to taxonomy ids. Per-tell clean fixes and before/after outcomes. Local Astro preview and how entries/demos render on the index. --- ## 06. Skill workflow > Agent skill lifecycle: scan, triage, report, then propose or apply fixes without silent file edits from the standalone scanner. - Page Markdown: https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/06-skill-workflow.md - Generated: 2026-07-11T08:24:32.177Z ### Source Files - `skill/SKILL.md` - `skill/scripts/scan.mjs` - `skill/references/detection.md` - `skill/references/fixes.md` - `skill/README.md` --- title: "Skill workflow" description: "Agent skill lifecycle: scan, triage, report, then propose or apply fixes without silent file edits from the standalone scanner." --- The `kill-ai-slop` agent skill (`skill/SKILL.md`) runs a fixed five-step lifecycle—**Scope → Scan → Triage → Report → Fix**—so a host agent detects AI-slop tells, confirms them against real intent, reports before any write, and only then proposes or applies minimal fixes. The bundled scanner `skill/scripts/scan.mjs` is read-only: it walks frontend source, matches tell patterns, and prints `file:line` hits (human or `--json`); it never edits files. Do not mass-edit before the user has seen the report. Standalone `node scripts/scan.mjs` is a map of leads, not a verdict and not a mutator. ## Surfaces in play | Surface | Path | Role in the lifecycle | |---|---|---| | Skill definition | `skill/SKILL.md` | Principles, ordered workflow, guardrails | | Scanner | `skill/scripts/scan.mjs` | Dependency-free Node walk + regex match; report only | | Taxonomy | `skill/references/taxonomy.md` | 23 tells: what each is, why it reads as slop, the fix | | Detection reference | `skill/references/detection.md` | Patterns + common false positives (human reference; scanner encodes the patterns) | | Fixes playbook | `skill/references/fixes.md` | Before→after directions per tell | Trigger phrases the skill is meant for include: “kill AI slop”, “de-slop”, “remove the AI look”, “make this not look AI-generated”, or cleaning a templated landing page / UI / docs. ## Lifecycle at a glance ```mermaid stateDiagram-v2 [*] --> Scope Scope --> Scan: root confirmed Scan --> Triage: file:line hits Triage --> Report: confirmed slop only Report --> AwaitingApproval: grouped summary shown AwaitingApproval --> Fix: user picks groups / all AwaitingApproval --> [*]: user declines Fix --> Rescan: re-run scanner Rescan --> [*]: counts dropped; leftovers noted ``` Ownership boundary: **scan/report stay read-only**; **writes happen only in Fix**, under host-agent control after user approval. The scanner process itself never crosses that boundary. ## Principles (held on every fix) From `SKILL.md`, applied during triage and fix—not as optional style notes: 1. **Decide before you decorate.** Every visual choice must be explainable. 2. **One accent, one voice.** 3. **Hierarchy from scale and space.** Coloring words or swapping fonts is a shortcut. 4. **Subtract first.** First move toward not-ugly is removing things. 5. **Specific beats punchy** in copy. 6. **Decoration must mean something** — icons, badges, callouts are signals. ## Step-by-step workflow Confirm what to scan. Default to app/site source. Skip `node_modules`, `dist`, `build`, `.git`, `vendor`, lockfiles, and minified files (the scanner also skips additional build caches such as `.next`, `.astro`, `.output`, `.svelte-kit`, `.nuxt`, `coverage`, `.cache`, `.vercel`, `.turbo`). If the repo mixes several apps, ask which tree to target before scanning. Run the bundled scanner for code-level signals of each tell and print grouped `file:line` hits: ```bash node scripts/scan.mjs # human-readable report node scripts/scan.mjs --json # machine-readable, for triage ``` From the skill directory, invocation is the same shape as documented on the scanner (`node scan.mjs [root] [--json] [--no-color]`). Defaults: `root` is `.` when omitted; color is on only when stdout is a TTY, not JSON, and `--no-color` is absent. **Scanner contract** | Fact | Behavior | |---|---| | Runtime | Pure Node (`node:fs`, `node:path` only)—no package install | | Mutates files? | **Never** | | Hit meaning | Lead to confirm by reading code, not a verdict | | Large files | Skip files larger than `512 * 1024` bytes | | Extensions | `.html .css .scss .sass .less .tsx .jsx .ts .js .mjs .cjs .vue .svelte .astro .md .mdx`, plus `tailwind.config.*` | | Also skipped | `*.min.js` / `*.min.css`, lockfiles | Each tell in `TELLS` has `id`, `group`, `name`, one-line `fix`, and `patterns`. Some copy-oriented tells set `copy: true` (ids `10`–`12`). For every hit, open the file and decide **slop vs. intentional**. This step separates the skill from a lint rule. - Keep brand tokens, logos, deliberate illustrations, and defended design choices. - Flag defaults and pile-ons that lack intent. - Use `references/taxonomy.md` for what the tell is and why it reads as machine-made. - Use `references/detection.md` for exact patterns and common false positives. Examples of “can be real choices”: a brand-true purple, a single deliberate hero gradient headline, emoji in a picker feature, serif for an editorial product. **Before changing anything**, give a grouped summary: each tell, confirmed `file:line` hits, one sentence on why, and the proposed fix. Mirror this format: ``` slop src/Hero.tsx:12 indigo→violet gradient → one solid accent slop src/Hero.tsx:31 gradient-clip headline → solid ink, scale up slop src/Note.tsx:8 border-l-4 callout ×3 → 1 aside, rest is body slop copy.md:1 "not just X — it's Y" → say the specific thing → 4 groups, 11 hits. ``` Then ask which groups to apply, or whether to proceed on all. Do not skip this gate. Apply the **minimal** change that removes the tell while preserving intent and function. Use `references/fixes.md` for before→after direction per tell (adapt to project tokens/framework; not blind find-and-replace). **Fix order of operations** (`fixes.md`): 1. Design tokens / theme first (colors, radius, fonts)—many hits disappear at once. 2. Shared components, then one-off call sites. 3. Copy last. **Fix rules** - Prefer shared tokens/components over every call site. - Never invent new brand colors; if palette must change, propose neutrals + the project’s existing accent and wait for confirmation. - Keep copy meaning; make it specific—don’t just delete it. - Re-run the scanner after fixing; confirm hit count dropped; note intentional leftovers with reasons. ## Scanner vs agent skill | | Standalone scanner | Agent skill host | |---|---|---| | Command / surface | `node scripts/scan.mjs [root] [--json] [--no-color]` | Host invokes skill after install; user prompt like “Kill the AI slop in this project” | | Reads source | Yes | Yes (via scanner + file open) | | Edits source | **No** | Only after report + user approval, in Fix | | Output | Grouped human report or JSON | Same scan map, then triage narrative + proposal + optional apply | | Judgment | Pattern match only | Slop vs intentional; false-positive handling | Use `--json` when the host needs a machine-readable hit list for triage. Treat JSON hits the same as the human report: confirm by reading the code before proposing edits. ## Tell inventory (scanner `TELLS`) Twenty-three tells, ids `01`–`23`, with groups used for reporting and prioritization: | Group | IDs | Examples (name → one-line fix) | |---|---|---| | `color` | `01`–`06` | indigo→violet gradient → one solid, chosen accent | | `type` | `07`–`09` | serif-italic emphasis → emphasise by weight, one voice | | `copy` | `10`–`12` | AI copywriting voice → say the specific thing | | `component` | `13`–`21` | left-border callout → one aside, rest is body | | `layout` | `22` | all-caps card grid → show the one key thing fully | | `evolved` | `23` | tasteful-terminal → mono for code only | Full pattern lists live in `skill/scripts/scan.mjs` and the parallel human reference `skill/references/detection.md`. ## Guardrails | Guardrail | Constraint | |---|---| | Respect authorship | Unfamiliar files and deliberate flourishes are someone’s choice; when unsure, ask—don’t strip | | Small, reviewable diffs | No unrelated reformats; never `git add -A`; stage explicit files only | | No new dependencies | Do not add packages to perform this work | | Visual verify when possible | If a dev server exists, compare before/after; a clean scan ≠ a better page | ## Verification signals | Stage | Success signal | |---|---| | Scan | Grouped `file:line` (or JSON) report; no files modified by the scanner | | Triage | Each kept/discarded hit has a reason (intentional brand vs default) | | Report | User sees groups + proposed fixes **before** any edit | | Fix | Minimal diffs; preferred shared-token changes; scanner re-run shows lower counts | | Leftovers | Intentionally retained hits documented with reason | ## Skill package layout :::files skill/ SKILL.md # workflow + guardrails README.md # install + use references/ taxonomy.md # 23 tells (what / why / fix) detection.md # patterns + false positives fixes.md # before→after remediation scripts/ scan.mjs # dependency-free, read-only scanner ::: ## Related pages Invoke kill-ai-slop in a coding agent after install: prompts and host behavior. Point the scanner at a path; interpret grouped vs JSON reports. Map hits to the fixes playbook; choose propose vs apply. Invocation, flags, walk/scan behavior, and the hard no-edit constraint. Code-level signals per tell and how findings map to taxonomy ids. Per-tell clean fixes and preferred before/after outcomes. Shared language for categories, named signals, and field-guide alignment. --- ## 07. Use the agent skill > Invoke kill-ai-slop inside a coding agent after install: prompts, expected host behavior, and how the skill uses references and the scanner. - Page Markdown: https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/07-use-the-agent-skill.md - Generated: 2026-07-11T08:24:31.068Z ### Source Files - `skill/SKILL.md` - `skill/README.md` - `skill/scripts/scan.mjs` - `skill/references/taxonomy.md` - `README.md` --- title: "Use the agent skill" description: "Invoke kill-ai-slop inside a coding agent after install: prompts, expected host behavior, and how the skill uses references and the scanner." --- After install, the `kill-ai-slop` Agent Skill is the host-driven path: the agent loads `skill/SKILL.md`, runs `scripts/scan.mjs` as a read-only map, triages hits against `references/`, reports before any edit, then proposes or applies fixes only for groups you approve. The skill is provider-neutral and portable: it is a directory of files (`SKILL.md`, `references/`, `scripts/scan.mjs`) that any Agent Skills host can load from its own skills path. No model vendor, hosted API, or proprietary connector is required. ## Prerequisites | Requirement | Detail | |---|---| | Skill installed | `kill-ai-slop/` under the host skills directory (project or user scope) | | Node available | For the bundled scanner: `node scripts/scan.mjs …` | | Target | A web UI / docs tree (HTML/CSS, React/Vue/Svelte/Astro, Tailwind, Markdown) | Install paths and the `npx skills add yetone/kill-ai-slop` flow are documented on the installation page. This page assumes registration succeeded and the host can resolve the skill by name or description. :::files skill/ SKILL.md # definition, workflow, guardrails references/ taxonomy.md # 23 tells: what / why / fix detection.md # patterns + false positives fixes.md # before→after remediation scripts/ scan.mjs # dependency-free scanner (never edits) ::: ## Invoke the skill Once registered, start with a plain-language request. The skill’s frontmatter `description` is what hosts match on; these phrases are the intended triggers: | Intent | Example prompts | |---|---| | Full de-slop pass | `Kill the AI slop in this project.` | | Short forms | `de-slop this`, `remove the AI look`, `make this not look AI-generated` | | Scope hints | Landing page / UI / docs that feel templated; clean up vibe-coded UI defaults | You do not need to name files or pass flags unless you want a narrower root. The agent should confirm scope when the repo holds multiple apps. ```text Kill the AI slop in this project. ``` ```text De-slop the marketing site under apps/web. Keep brand tokens. ``` ## Expected host behavior Hosts must follow the ordered workflow in `SKILL.md`. **Do not mass-edit before the user has seen the report.** ```mermaid sequenceDiagram participant User participant Agent as Agent host
(SKILL.md) participant Scan as scripts/scan.mjs participant Refs as references/* User->>Agent: kill AI slop / de-slop / remove AI look Agent->>User: 1. Scope (root; multi-app?) Agent->>Scan: node scripts/scan.mjs root [--json] Scan-->>Agent: grouped file:line hits (read-only) Agent->>Refs: taxonomy + detection (triage) Agent->>User: 4. Report + ask which groups User->>Agent: approve groups / all Agent->>Refs: fixes.md patterns Agent->>User: 5. Minimal diffs + re-scan note ``` ### 1. Scope - Default to app/site source. - Skip noise dirs and artifacts the scanner also skips (`node_modules`, `dist`, `build`, `.git`, `vendor`, lockfiles, minified files, and the scanner’s own `SKIP_DIRS` set). - Ask if the project mixes several apps before walking everything. ### 2. Scan Run the bundled scanner (path relative to the installed skill directory): ```bash node scripts/scan.mjs # human-readable report node scripts/scan.mjs --json # machine-readable, for triage ``` | Property | Behavior | |---|---| | Runtime | Pure Node; no npm dependencies | | Side effects | **Never edits files** | | Role of output | Starting map of code-level signals, **not** verdicts | | Confirmation | Every hit must be checked by reading the file | From the repo root (without installing into the host), the same binary is: ```bash node skill/scripts/scan.mjs path/to/project node skill/scripts/scan.mjs path/to/project --json ``` Scanner CLI surface (as implemented in `scan.mjs`): | Input | Default | Meaning | |---|---|---| | `[root]` | `.` | First non-flag argv path | | `--json` | off | Machine-readable report | | `--no-color` | off | Disable ANSI when not JSON | Optional flags beyond those three are not part of the documented scanner contract. ### 3. Triage For every hit, open the file and decide **slop vs intentional**. This is what separates the skill from a lint rule: - Keep defended choices: brand tokens, logos, deliberate illustration, intentional serif/gradient/emoji. - Flag **defaults** — “absence of a decision,” per `references/taxonomy.md`. - Use `references/detection.md` for exact patterns and common false positives. ### 4. Report **Before any edit**, emit a grouped summary: tell, confirmed `file:line`, one sentence why, proposed fix. Mirror this shape: ```text slop src/Hero.tsx:12 indigo→violet gradient → one solid accent slop src/Hero.tsx:31 gradient-clip headline → solid ink, scale up slop src/Note.tsx:8 border-l-4 callout ×3 → 1 aside, rest is body slop copy.md:1 "not just X — it's Y" → say the specific thing → 4 groups, 11 hits. ``` Then ask which groups to apply, or whether to proceed on all. ### 5. Fix Only after approval: - Apply the **minimal** change that removes the tell while preserving intent and function. - Use `references/fixes.md` for before→after patterns. - Prefer shared tokens/components over every call site. - **Never invent new brand colors**; if palette must change, propose neutrals + existing accent and wait for confirmation. - Keep copy meaning; make it specific rather than deleting. - Re-run the scanner; confirm hit count dropped; list intentional leftovers with reasons. ## How the skill uses references | Path | Role in the agent loop | |---|---| | `SKILL.md` | Host skill entry: `name: kill-ai-slop`, trigger `description`, workflow, guardrails | | `references/taxonomy.md` | 23 tells (classic + evolved): definition, why it reads machine-made, fix intent | | `references/detection.md` | Concrete patterns + false positives for triage | | `references/fixes.md` | Remediation before→after patterns when applying edits | | `scripts/scan.mjs` | Automated lead generation only | Taxonomy rule the agent must honor: a tell is slop only when it is a **default nobody chose**. The same element, chosen and defended, stays. Coverage called out by the skill description (code and copy surfaces): indigo→violet gradients, gradient-clip headlines, warm cozy palettes, default semantic palette, one-hue status boxes, atmospheric gradients, serif-italic emphasis, serif-where-sans, decorative strikes/highlights, highlighted keywords, AI copywriting voice, emoji spam, glowing status dots, left-border callouts, pastel icon tiles, glass/over-rounding, oversized shadows, non-nesting corners, badge/pill spam, AI-drawn SVG icons, icon-in-tint tiles, all-caps card grids, and “tasteful terminal” — across HTML/CSS, React/Vue/Svelte/Astro, Tailwind, and Markdown. ## How the skill uses the scanner The scanner is a **lead generator**, not the decision engine. | Concern | Scanner | Agent (skill) | |---|---|---| | Walk sources | Yes (`walk`, extension filter, skip dirs) | Chooses `` after Scope | | Match patterns | Yes (`TELLS` regexes in `scan.mjs`) | Confirms / rejects each hit | | Edit files | **No** | Yes, only after Report + approval | | Intent / brand | No | Yes (triage + fixes playbook) | | Visual QA | No | Yes when a dev server exists | Internal constraints encoded in `scan.mjs` (for interpreting empty or sparse reports): - Skips directories such as `node_modules`, `.git`, `dist`, `build`, `out`, `.next`, `.astro`, `.output`, `.svelte-kit`, `.nuxt`, `coverage`, `vendor`, `.cache`, `.vercel`, `.turbo` - Scans extensions including `.html`, `.css`/`.scss`/`.sass`/`.less`, `.tsx`/`.jsx`/`.ts`/`.js`/`.mjs`/`.cjs`, `.vue`, `.svelte`, `.astro`, `.md`, `.mdx`, plus `tailwind.config.*` - Skips `*.min.js` / `*.min.css`, lockfiles, and files larger than **512 KiB** - Tells marked `copy: true` (e.g. AI voice, emoji) also consider prose-bearing files; others focus on code/style signals A clean re-scan is not proof of a better page. `SKILL.md` requires visual verification when a dev server is available: before/after beats a zero hit count. ## Guardrails the host must enforce | Rule | Constraint | |---|---| | Authorship | Unfamiliar files and deliberate flourishes are someone’s choice; when unsure, **ask** — do not strip | | Diff size | No unrelated reformats; never `git add -A`; stage explicit files only | | Dependencies | **No new packages** for de-slop work | | Verification | Prefer visual check; re-scan and document intentional remaining hits | | Order | Report → user choice → fix (no silent bulk edits from the skill path) | Standalone scanner use (no skill host) is scan-only; it cannot apply fixes. Fix application is host-mediated via the skill workflow. ## Verification signals | Stage | Success signal | |---|---| | Invoke | Host loads `kill-ai-slop` from skills path (not a free-form guess of the catalogue) | | Scan | Grouped `file:line` report or JSON; process does not write project files | | Report | Summary before edits; user asked which groups to apply | | Fix | Small diffs; scanner count down; intentional leftovers listed with reasons | | Visual | Page looks intentional under one accent / one voice, not just “lint clean” | ## Troubleshooting | Symptom | Check | |---|---| | Skill never fires | Re-install registration; prompt with a description-matching phrase (“kill AI slop”, “de-slop”, “remove the AI look”) | | Agent edits immediately | Workflow violation — require step 4 report and approval first | | Scanner path not found | Run relative to the installed skill: `node scripts/scan.mjs …`, or from clone: `node skill/scripts/scan.mjs …` | | Hits look wrong | Expected — treat as leads; re-read with `taxonomy.md` + `detection.md` false positives | | Palette rewrite surprises | Agent must not invent brand colors; stop and confirm neutrals + existing accent | | Multi-app monorepo noise | Re-scope to a single app root before scan | ## Next Lifecycle detail: scan → triage → report → propose/apply without silent scanner edits. Point the dependency-free scanner at a path; grouped vs JSON reports. Map hits to the fixes playbook; propose vs apply in an agent host. Flags, walk/scan behavior, and the hard no-edit constraint. Per-tell clean fixes and before/after intent. npx or manual copy into the host skills directory. --- ## 08. Scan a web project > Point the dependency-free scanner at a project path, interpret grouped vs JSON reports, and verify findings against detection rules. - Page Markdown: https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/08-scan-a-web-project.md - Generated: 2026-07-11T08:24:48.736Z ### Source Files - `skill/scripts/scan.mjs` - `skill/references/detection.md` - `skill/README.md` - `README.md` - `skill/references/taxonomy.md` --- title: "Scan a web project" description: "Point the dependency-free scanner at a project path, interpret grouped vs JSON reports, and verify findings against detection rules." --- `skill/scripts/scan.mjs` is a Node-only, dependency-free walker that greps frontend source for the 23 AI-slop tells encoded in its `TELLS` table (aligned with `skill/references/detection.md`). Point it at a project root, read the grouped `file:line` report or `--json` output, and treat every hit as a lead to confirm in code—not a verdict. The scanner never edits files. ## Prerequisites - Node.js available as `node` (ESM: `import` from `node:fs` / `node:path`). - A local checkout that includes `skill/scripts/scan.mjs` (no `npm install` for the scanner itself). - A web project path to scan (HTML/CSS, React/Vue/Svelte/Astro, Tailwind, Markdown, and related frontend source). Standalone scan is read-only. Proposing or applying clean fixes is the agent skill path (`skill/SKILL.md`), not this script. ## Invoke the scanner Usage from the script header: ```text node scan.mjs [root] [--json] [--no-color] ``` From a full repo checkout: ```bash node skill/scripts/scan.mjs path/to/project # grouped report node skill/scripts/scan.mjs path/to/project --json # machine-readable ``` From inside `skill/` (paths in `skill/README.md`): ```bash node scripts/scan.mjs path/to/src # human-readable report node scripts/scan.mjs path/to/src --json # machine-readable ``` ### CLI inputs | Input | Behavior | | --- | --- | | `root` (positional) | First argv token that does not start with `-`. Default: `.` | | `--json` | Machine-readable report mode (`asJson`). Disables ANSI color. | | `--no-color` | Force plain console output even when stdout is a TTY. | Color is enabled only when all of these hold: `--no-color` is absent, stdout is a TTY (`process.stdout.isTTY`), and `--json` is absent. ## What the walker includes and skips `walk(dir)` recurses from `root` and collects files for `scanFile`. ### Included extensions and special names `EXTS` in `scan.mjs`: | Extension | Notes | | --- | --- | | `.html`, `.css`, `.scss`, `.sass`, `.less` | Markup and styles | | `.tsx`, `.jsx`, `.ts`, `.js`, `.mjs`, `.cjs` | App/source JS/TS | | `.vue`, `.svelte`, `.astro` | Framework SFCs | | `.md`, `.mdx` | Prose / docs copy | Also included by basename: any `tailwind.config.*` file (matched with `/^tailwind\.config\./`). `detection.md` documents the same frontend scope (with a slightly shorter extension list in prose); the implementation in `scan.mjs` is authoritative for what the script actually opens. ### Skipped directories `SKIP_DIRS`: `node_modules`, `.git`, `dist`, `build`, `out`, `.next`, `.astro`, `.output`, `.svelte-kit`, `.nuxt`, `coverage`, `vendor`, `.cache`, `.vercel`, `.turbo` Dot-directories that appear in `SKIP_DIRS` are skipped; other walk errors on `readdirSync` return the files collected so far. ### Skipped files - `*.min.js` / `*.min.css` - Lockfiles matching `package-lock`, `pnpm-lock`, or `yarn.lock` in the basename - Files larger than **512 KiB** (`st.size > 512 * 1024`) — treated as large/generated; `scanFile` returns no hits - Unreadable paths (`statSync` / `readFileSync` failures return `[]`) ## Tell catalogue encoded in the scanner Each entry in `TELLS` has: | Field | Role | | --- | --- | | `id` | Two-digit tell id (`"01"` … `"23"`), shared with taxonomy/detection language | | `group` | Bucket used for reporting: `color`, `type`, `copy`, `component`, `layout`, `evolved` | | `name` | Short human label | | `fix` | One-line remediation hint printed with the tell | | `patterns` | One or more `RegExp`s applied to file text | | `copy` | Optional; when `true`, the tell is a copy tell (prose-oriented). Set on **10**, **11**, **12** | Script comment: code tells target code/style files; copy tells also read prose. `scanFile` begins an `isCode` branch after the read (remainder of match/filter logic is in the full script); pattern lists themselves are fully declared in `TELLS`. ### Tell inventory (ids and groups) | Id | Group | Name | Fix (scanner one-liner) | | --- | --- | --- | --- | | 01 | color | indigo→violet gradient | one solid, chosen accent | | 02 | color | gradient-clip headline | solid ink, scale up | | 03 | color | warm ‘cozy’ palette | neutral base + one warm accent | | 04 | color | default semantic palette | one palette: neutrals + a couple of chosen states | | 05 | color | one-hue status box | state in words; one muted accent on neutral | | 06 | color | gradients as atmosphere | one flat bg; depth from a hairline | | 07 | type | serif-italic emphasis | emphasise by weight, one voice | | 08 | type | serif where sans belongs | one legible UI sans | | 09 | type | decorative strikes & highlights | strike for edits, underline for links | | 10 | copy | highlighted keywords | let structure carry emphasis | | 11 | copy | AI copywriting voice | say the specific thing | | 12 | copy | emoji everywhere | cut emoji from product copy | | 13 | component | glowing status dot | flat dot + a word; no halo | | 14 | component | left-border callout | one aside, rest is body | | 15 | component | pastel icon tiles | labelled list with specifics | | 16 | component | max-radius / glassmorphism | one small radius, solid surfaces | | 17 | component | oversized drop shadow | tight elevation, never bigger than the element | | 18 | component | corners that don't nest | inner = outer − padding | | 19 | component | badge / pill spam | badges only for real status | | 20 | component | AI-drawn SVG icon | a real, high-quality icon (a designer, or a strong image model) | | 21 | component | icon in a tint of itself | no tinted tile; inherit text color | | 22 | layout | all-caps card grid | show the one key thing fully | | 23 | evolved | tasteful-terminal | mono for code only | Human-oriented pattern notes, false positives, and confirm checks live in `skill/references/detection.md`. Taxonomy prose lives in `skill/references/taxonomy.md`. ## Interpreting reports ### Grouped (default) Default mode prints a **grouped report of `file:line` hits** for matching tells. Expect human-oriented grouping by tell (ids/names/fixes from `TELLS`) and path/line locations relative to the walk root—not a pass/fail grade. Success signals: - Process exits after printing (no write side effects). - Hits appear as locations you can open in an editor. - Empty or sparse output means no pattern matched under the walk rules (not proof that the UI is free of slop). ### JSON (`--json`) `--json` selects machine-readable output and turns color off. Use it for piping into triage tooling or agent hosts. Treat payload fields as whatever the script emits at runtime; wire consumers against a real run of `scan.mjs` rather than inventing a schema from this page. ### Constraint shared by both modes From the scanner header and READMEs: - **Never edits files** - **Every hit is a lead to confirm by reading the code, not a verdict** A gradient, serif, emoji, or monospaced UI can be intentional design. The skill (when used) triages slop vs chosen design; the standalone scanner only surfaces signals. ## Verify findings against detection rules Use `skill/references/detection.md` as the human checklist for each tell id. Workflow: Match the report’s tell id/name to the same numbered section in `detection.md` (and the taxonomy entry in `taxonomy.md` for “why it reads as machine-made” and the intended fix direction). Confirm the match is real in context (class list, CSS, markup, or copy), not a partial string inside an unrelated token. Detection entries call out usual lies of each pattern—for example brand-true purple vs indigo→violet factory gradient; logo wordmark vs default gradient headings; food/craft warm identity vs cozy-as-default; emoji in documented code samples vs emoji on every chrome heading. Taxonomy rule: slop is the *absence of a decision*. Keep anything clearly intentional; only treat default, unchosen machine patterns as fix candidates. ### Representative confirm checks (from detection.md) | Id | Confirm / false-positive stance | | --- | --- | | 01 | Slop is the *combination* (purple gradient + glow + pill + “AI-powered” eyebrow), not every purple brand accent | | 02 | Logo wordmark or one deliberate hero treatment can be fine; default gradient heading style is the tell | | 04 | Confirm several stock `-50` / `-600` semantic pairs together, unrelated to brand | | 05 | Same hue on border, text, and `/10` background on one alert | | 11 | Quotes or docs *discussing* the phrases (including this project’s own docs) can false-positive | | 12 | Code samples, emoji pickers, UGC are not chrome spam | | 16 | `rounded-full` on avatars/pills is expected; on cards/inputs as default surface is the concern | | 17 | 60px+ blur/spread fog under a small element; large surfaces with proportionate shadow can be fine | | 18 | Same large radius on nested boxes (inner should be outer − padding) | | 20 | Visual judgment on blob-with-dot-eyes / primitive mascot SVGs, not every `` | When a pattern is “hard to grep” in detection notes (e.g. serif-italic *inside* a sans heading, nested corner math), the scanner’s regexes are still leads—open the structure and decide. ## Runbook: first report Prefer the app’s source root (or monorepo package path), not a parent full of unrelated repos, so skip lists and path noise stay useful. ```bash node skill/scripts/scan.mjs path/to/project ``` ```bash node skill/scripts/scan.mjs path/to/project --json > slop-report.json ``` Work tell-by-tell using `detection.md` confirm notes; drop false positives before any fix work. Map confirmed hits to `skill/references/fixes.md` / agent fix flow. Do not expect `scan.mjs` to rewrite the tree. ## Failure modes and quiet results | Situation | What the script does | What to check | | --- | --- | --- | | Path missing or unreadable | `walk` / `scanFile` soft-fail toward empty collections | Permissions, path spelling, root default `.` | | Only build artifacts under root | Skipped via `SKIP_DIRS` | Point at `src` / app package | | Large generated bundles | Files > 512 KiB skipped | Scan sources, not minified dumps | | Zero hits | No matching patterns in included files | Patterns are heuristic; visual review still applies | | Hits on this repo’s own docs | Copy patterns can match documented phrases | Apply false-positive guidance for tell 11 (and similar) | ## Relationship to the agent skill | Surface | Role | | --- | --- | | `skill/scripts/scan.mjs` | Read-only signal report | | Agent skill (`kill-ai-slop`) | Scan → triage → report → propose/apply fixes per `skill/SKILL.md` | | `skill/references/detection.md` | Human pattern book; scanner encodes the same class of signals | | `skill/references/taxonomy.md` | What each tell is and the fix direction | | `skill/references/fixes.md` | Before→after remediation patterns | After a confirmed report, move to clean fixes through the skill or the remediation playbook—not by expecting the scanner to mutate files. ## Related pages Invocation, flags, walk/scan behavior, and the hard no-edit constraint. Per-tell patterns, match targets, and false-positive notes. Full agent lifecycle: scan, triage, report, then propose or apply fixes. Map confirmed hits to the fixes playbook and agent propose vs apply. Categories and named signals shared by the field guide and skill. Shortest path to a first scanner report and field-guide run. --- ## 09. Apply clean fixes > Map scanner hits to remediation steps from the fixes playbook, choose propose vs apply in an agent host, and confirm the clean alternative. - Page Markdown: https://grok-wiki.com/public/docs/yetone-kill-ai-slop-c0d8c9670cbb/pages/09-apply-clean-fixes.md - Generated: 2026-07-11T08:25:12.107Z ### Source Files - `skill/references/fixes.md` - `skill/SKILL.md` - `skill/references/detection.md` - `website/src/data/demos.ts` - `website/src/components/BeforeAfter.astro` --- title: "Apply clean fixes" description: "Map scanner hits to remediation steps from the fixes playbook, choose propose vs apply in an agent host, and confirm the clean alternative." --- After triage and the pre-edit report, **kill-ai-slop** remediates confirmed tells through the agent skill’s **Fix** step: map each hit to a direction in `skill/references/fixes.md`, apply the minimal edit (or only propose it), then re-scan and visually check that the clean alternative holds. The standalone scanner (`node scripts/scan.mjs`) **never edits files** — only an agent host that loads the skill can write changes. ## Prerequisites | Requirement | Detail | | --- | --- | | Agent skill | `kill-ai-slop` installed in a coding agent (`skill/SKILL.md`) | | Prior steps | Scope → Scan → Triage → Report already done; do **not** mass-edit before the user has seen the report | | Playbook | `skill/references/fixes.md` (before→after directions per tell) | | Scanner | `node scripts/scan.mjs ` and optional `--json` for machine-readable triage | | Optional visual ref | Field-guide demos in `website/src/data/demos.ts` via `BeforeAfter.astro` (Slop / Clean) | Do not treat scanner output as a verdict. Every hit is a lead: open the file, decide **slop vs intentional**, and keep deliberate brand choices (tokens, logos, real illustrations). ## Propose vs apply The skill workflow splits **proposal** (Report) from **application** (Fix). The scanner never crosses that boundary. ```text Scanner (read-only) Agent host (skill) ───────────────── ────────────────── scan.mjs → hits triage (slop vs intentional) report + proposed fix per group ask: which groups / all? ── user decision ── apply minimal diffs (Fix) re-scan + visual check ``` | Mode | When | What the agent does | Files written? | | --- | --- | --- | --- | | **Propose** | Always before edits; default until the user chooses groups | Group confirmed hits; one-sentence why + proposed fix; ask which groups to apply or whether to proceed on all | No | | **Apply** | After the user approves some or all groups | Minimal change per tell using `references/fixes.md`; prefer shared tokens/components | Yes (explicit paths only) | Report format the skill mirrors: ```text slop src/Hero.tsx:12 indigo→violet gradient → one solid accent slop src/Hero.tsx:31 gradient-clip headline → solid ink, scale up slop src/Note.tsx:8 border-l-4 callout ×3 → 1 aside, rest is body slop copy.md:1 "not just X — it's Y" → say the specific thing → 4 groups, 11 hits. ``` Then ask which groups to apply, or whether to proceed on all. ## Fix procedure On every change: decide before you decorate; one accent, one voice; hierarchy from scale and space; subtract first; prefer specific copy over punchy copy; decoration only when it is a real signal. 1. Design tokens / theme first (colors, radius, fonts) — many hits drop at once. 2. Shared components, then one-off call sites. 3. Copy last. Look up the tell in `skill/references/fixes.md` (numbered **01–23**). Patterns are **directions**, not find-and-replace rules — adapt to project tokens and framework. Preserve intent and function. Prefer editing shared tokens/components over every call site. Never invent new brand colors: if palette must change, propose neutrals + the project’s existing accent and let the user confirm. Keep copy meaning; make it specific rather than deleting it. Re-run the scanner and note intentional leftovers with reasons. If a dev server exists, compare before/after visually — a green scan is not the same as a better page. Optional: match the tell’s field-guide demo (`before` → `after` in `demos.ts`). ### Re-scan commands ```bash node scripts/scan.mjs # human-readable grouped report node scripts/scan.mjs --json # machine-readable for triage ``` Success signal: hit count for the fixed tells drops; remaining hits are either unapproved groups or intentional keeps with a stated reason. ## Map scanner hits → remediation Use the tell name from the report (or taxonomy id) as the key into `references/fixes.md`. Summary of the playbook direction and the clean outcome: | Tell | Remediation direction | Clean outcome | | --- | --- | --- | | **01** Indigo→violet gradient | Solid accent class/token; drop colored glow shadow; if gradient kept, single-hue, low contrast, justified | One solid, chosen accent | | **02** Gradient headline text | Solid ink; use scale/weight for impact | Solid heading, no `bg-clip-text` default | | **03** Warm “cozy” palette | Near-neutral paper/ink/rule; one warm accent only; propose neutrals, confirm before global apply | Neutral base + one accent | | **04** Default semantic palette | Neutrals + at most one–two intentional semantic colours (not stock blue/green/amber/red set) | Coherent chips from brand palette | | **05** One-hue status box | State in a word; neutral surface + border; one muted accent | Neutral alert, not mono-hue wash | | **06** Gradients as atmosphere | Flat background; hairline/border for depth; glow only if it points at one element | Flat held surfaces | | **07** Serif-italic on one word | Emphasize by weight/position, one voice | Bold (or structure), not serif/italic span in sans heading | | **08** Serif where sans belongs | UI sans in font tokens; serif only for genuine editorial product voice | Sans UI/body unless editorial | | **09** Decorative strikes & highlights | Remove decorative ``/``/``; keep real edits, links, annotations | Structure carries emphasis | | **10** Highlighted keywords | Specific prose; at most one accented phrase | No multi-color keyword soup | | **11** AI copywriting voice | Rewrite for specifics; delete triads and em-dash drama | Concrete claims, not “not just X — it’s Y” | | **12** Emoji everywhere | Remove from headings/buttons/bullets; keep only if real status info | Plain chrome labels | | **13** Glowing status dot | Flat dot + word; no ping/pulse/glow shadow | Small flat status marker | | **14** Rounded card, colored left border | Collapse stacked callouts to body; at most one real `