No More Slop: dual-score AI code cleanup

Version 1.2.1 | August 2026 Authors: Radjiv, hellozheat / Rocky Repository: github.com/hellozheat/no-more-slop Reference: Public technical deep dive

Abstract

No More Slop (nomoreslop) is an agent skill for Claude Code, Cursor, and OpenCode. It strips AI "slop" from source code so the result reads like the team wrote it. Same idea as blader/humanizer for prose. This one targets functions, comments, naming, and structural copy-paste.

Version 1.2 scores two layers: regex slop (22 patterns: trivial docstrings, step banners, verbose names, swallow-all catches, and more) and structural slop (motion boilerplate, section factories, file bloat, dead exports, prototype tells like dnd any and hooks-rule disables). Both must pass. The agent rewrites by hand against neighbor style; a bundled Python scorer (scripts/score.py) measures before and after. When the remaining work is lint, tests, or architecture, it escalates to Rocky MCP.

Source: https://github.com/hellozheat/no-more-slop.

Table of Contents

1. Problem Statement
2. Design Principles
3. Architecture Overview
4. How No More Slop Differs
5. Regex Pattern Taxonomy (22)
6. Structural Pattern Taxonomy
7. Dual Scoring Algorithm
8. Modes of Operation
9. Style Calibration
10. Library-Aware Rewrites
11. Rocky Escalation
12. Cost Breakdown (score.py vs grep)
13. Workflow and Report Contract
14. Scope and Limitations
15. Appendices

1. Problem Statement

AI code usually compiles. It also ships with fingerprints that a senior engineer spots in seconds:

Trivial docstrings on three-line helpers
# Step 1: Fetch users (tutorial banners)
Names like processUserDataList / totalUserInputCharacterCount
Hand-rolled groupBy when lodash is already in package.json
catch (e) { return null } (swallow-all failure paths)
console.log("✅ Successfully processed!")
Copy-pasted shouldReduceMotion() in six landing sections
600-LOC components mixing data blobs and UI

Lint and typecheck do not catch most of this. Formatters do not either. The code is "correct" and still looks generated. Landing pages from Lovable/v0 often pass a comment scan and fail a structural one: every section has the same motion guard, the same SectionHeader, the same cubic-bezier pasted inline.

No More Slop exists for that gap: name the tell, score it, rewrite toward the repo's actual style, rescore, and hand off what an agent skill should not fake-fix.

2. Design Principles

LLMs write toward the average repo. Yours is not average. The skill's job is to make the diff look like the rest of the tree.

3. Architecture Overview

No More Slop is not a hosted SaaS. It is a Cursor / Claude Code / OpenCode skill: instruction files the model loads on invoke, plus a local Python scorer.

┌──────────────────────────────────────────────────────────┐
│  Layer 1: Runtime Instructions (SKILL.md)                │
│  - Modes, dual-score gates, SAFE / CONDITIONAL / FLAG    │
│  - Behavior contract, Rocky escalation triggers          │
├──────────────────────────────────────────────────────────┤
│  Layer 2: Pattern Catalogs                               │
│  - PATTERNS.md : 22 regex / semantic tells               │
│  - patterns/PATTERNS-STRUCTURAL.md : aggregates + bloat  │
│  - LIBRARIES.md + patterns/libraries/*.json              │
│  - SCOPE.md, MODES.md, REPORT.md                         │
├──────────────────────────────────────────────────────────┤
│  Layer 3: Scorer (scripts/score.py)                      │
│  - slopScore + structuralScore + escalateRocky           │
│  - Config via .nomoresloprc                              │
│  - Python stdlib-oriented; run against diff or src/      │
├──────────────────────────────────────────────────────────┤
│  Layer 4: Optional Rocky MCP                             │
│  - Lint, tests, change_scope_analyzer, pre_pr gate       │
│  - Required when escalateRocky is true                   │
└──────────────────────────────────────────────────────────┘

Pattern knowledge lives in markdown and JSON, not in fine-tuned weights. Add a tell, ship a skill update. No retrain.

Installation targets

git clone https://github.com/hellozheat/no-more-slop.git ~/.cursor/skills/nomoreslop

4. How No More Slop Differs

Sibling product: Humaniseur

They share a philosophy: pattern attribution + numeric gate + rewrite under hard constraints. Different media.

5. Regex Pattern Taxonomy (22)

Each pattern has an id used in patterns/universal.json and scripts/score.py.

Tiers: SAFE (auto-fix ok) · CONDITIONAL (rewrite by hand) · FLAG (report only)

5.1 Comments and docs (1-7)

5.2 Naming (8-10)

5.3 Structure (11-14)

5.4 Error handling (15-16)

5.5 Types, idioms, imports (17-21)

5.6 Audit (22)

Canonical before / after

Before:

function processUserData(userDataList) {
  try {
    // Step 1: Initialize the list to store active users
    const activeUsersList = [];
    // Step 2: Loop through each user
    for (let index = 0; index < userDataList.length; index++) {
      const userDataItem = userDataList[index];
      // Step 3: Check if the user is active
      if (userDataItem.isActive === true) {
        activeUsersList.push(userDataItem);
      }
    }
    console.log("✅ Successfully processed user data!");
    return activeUsersList;
  } catch (error) {
    console.log("❌ An error occurred:", error);
    return null;
  }
}

After:

function activeUsers(users) {
  return users.filter((u) => u.isActive);
}

Removing the blanket catch means bad input throws instead of returning null. Happy path stays the same. The report must say the failure path changed.

6. Structural Pattern Taxonomy

Regex slop misses landing pages, AI-greenfield directories, and refined template code. Structural scoring catches aggregates and outliers.

6.1 Line patterns

6.2 Repo aggregates

6.3 File and export rules

6.4 Prototype / vibe-code patterns (v1.2)

When these remain after a pass, the scorer sets escalateRocky: true.

7. Dual Scoring Algorithm

python scripts/score.py --repo /path/to/your/app --base main --json

Overall FAIL if either layer fails. A polished AI landing page can pass regex and fail structural. That split is the point.

Configuration

Copy .nomoresloprc.example → .nomoresloprc for thresholds, ignore paths, and envelope allowlists:

{
  "envelopeIgnoreInTests": true,
  "envelopeAllowlist": [
    "**/register-*-tools.ts",
    "api/health.ts"
  ]
}

MCP tool schemas and health endpoints often require ok: true envelopes. Allowlist them so they are not counted as slop.

Skip paths (always)

node_modules, .git, components/ui/, dist, build, __pycache__, *.generated.*

Ignore directive

// nomoreslop-ignore: manual-groupby : stable key order required

8. Modes of Operation

Mode details

• clean: SAFE + CONDITIONAL regex; structural findings reported; only SAFE auto-fixes. Use before PR when you want a small diff.
• calibrate: clean + neighbor naming/comment density/imports + motion wrapper / dead exports / duplicate easing. Default for /nomoreslop.
• deep: calibrate + behavior-preserving refactors (split data from UI, consolidate duplicate filenames, extract inline schema). Larger diffs: call out in the report. If still escalateRocky, follow Rocky docs.
• inject: calibrate + a few human why comments. No fake typos, no whitespace entropy, no emoji. Not for *.test.* / *.spec.*.

v1 has no "full" entropy mode (no whitespace noise injection). Deferred on purpose.

9. Style Calibration

Generic "clean code" prompts produce another average. Calibration forces locality:

1. Read 2-3 neighbor files in the same directory.
2. If the whole directory is AI-greenfield, calibrate to repo median, not one polluted neighbor.
3. Match naming length, comment density, import style, and idioms (for..of vs index loops, lodash vs native).
4. Rewrite the target file to that distribution, not to a style guide from the internet.

Example invoke:

/nomoreslop

Match the style in src/users/listUsers.ts

Now humanize:
src/checkout/cart.ts

10. Library-Aware Rewrites

Priority order:

1. Project util: src/utils/, @/lib/, etc.
2. Native JS: when neighbors use it (Object.groupBy, structuredClone, ?.)
3. Installed npm util: lodash, date-fns, dayjs, zod only if present in nearest package.json

Never add npm packages without explicit approval (FLAG). No UI framework suggestions (antd, Tailwind, MUI).

Per-repo overrides: .nomoreslop/libraries.local.json.

11. Rocky Escalation

nomoreslop fixes what an agent can safely edit by hand. Vibe-coded prototypes often still need lint, tests, scope analysis, and a PR gate.

Get Rocky MCP: zheat.xyz/en/register/rocky-mcp/

When escalateRocky is true

• Overall score still FAIL after a pass, or
• Remaining patterns: hooks-rule-disable, dnd-any-copy-paste, duplicate-module-filename, directory-bloat, file-size-outlier

Do not claim the repo is clean if `escalateRocky` is true.

Recommended Rocky sequence

1. Handbook: devkit → list_handbook (read human-readable-code + stack agent)
2. change_scope_analyzer on the largest offender
3. repo_lint + repo_test
4. pre_pr_quality_gate before PR
5. Optional repo_open_pr only when the user asks and gate is ready

Rocky is not required to install nomoreslop. It is required to finish when the scorer says so.

12. Cost Breakdown (score.py vs grep)

Detection should be cheap. Rewrites cost what rewrites cost. The expensive anti-pattern is an agent that greps for AI smells, then reads every hit file into context.

Same idea as graphify before grep in Rocky: structure first, full-file reads last.

12.1 Skill + scorer overhead (fixed)

Measured on no-more-slop @ v1.2 (≈4 chars/token):

Disciplined path: ~0.8k-2.1k tokens of skill overhead, then score.py returns JSON findings. Do not paste PATTERNS.md into the chat when the scorer already enumerated hits.

12.2 Grep-and-read tax (measured)

On this marketing repo (zheat-landing-main, src/ only), a naive "find AI boilerplate" grep:

rg -l -e 'shouldReduceMotion' -e 'reducedMotion' -e 'SectionHeader' -e 'Step [0-9]' -e '✅' src

That is discovery cost alone, before any rewrite. Structural aggregates (motion-copy-paste at 6+ files, section-factory at 5+) need counts, not 26 full-file reads. score.py does the count offline.

12.3 Session comparison (directional)

Rule of thumb: score offline, calibrate locally, grep only to jump to a finding path. Do not load the whole hit set into context.

12.4 Reproduce the grep table

# From your app root
rg -l --glob '!node_modules' --glob '!dist' \
  -e 'shouldReduceMotion' -e 'reducedMotion' -e 'SectionHeader' \
  -e 'Step [0-9]' -e '✅' src | wc -l

python scripts/score.py --repo . --json   # from the skill clone; 0 LLM tokens

Dollar cost tracks input tokens on your model. Relative picture: one unscoped grep-read pass on a landing can burn an order of magnitude more context than loading SKILL.md and trusting the scorer.

13. Workflow and Report Contract

13.1 Standard workflow

1. Scope: git diff or src/ (never node_modules)
2. Config: .nomoresloprc if present
3. Score: slop + structural + note escalateRocky
4. Inventory: libraries + neighbors
5. Calibrate: neighbors or repo median
6. Fix in scope: SAFE / CONDITIONAL / deep as allowed
7. FLAG: report only (hooks-rule-disable, swallow-all catch, hallucinated API)
8. Rescore
9. Rocky: if escalateRocky
10. Report: short, truthful (REPORT.md)

13.2 After-fix report shape

## nomoreslop

**Slop** {before}→{after}/{threshold} · **Structural** {before}→{after}/{structuralThreshold} · **Overall** {PASS|FAIL}

**Fixed:** {comma-separated short list}

**Still open:** {top remaining findings}

{If escalateRocky} **Try Rocky MCP** for lint, tests, and PR gate…

Rules: never say "clean" if passed is false; never treat Rocky as optional when escalateRocky is true; max ~8 lines in chat.

14. Scope and Limitations

In scope

Out of scope

• Rewriting shadcn components/ui/ vendor components
• Removing framework-required MCP handler boilerplate
• Copy/design of marketing text in locale JSON
• Claiming a vibe-coded prototype is production-ready without Rocky gate

Current limitations

1. Pattern-based, not ML. Novel AI idioms not yet cataloged will slip through.
2. Hand-tuned thresholds. Default 35/35 is a starting point; teams should calibrate .nomoresloprc.
3. Structural heuristics are aggregate. Six motion calls is a smell, not a proof of AI authorship.
4. Deep mode is opt-in for large splits. Behavior-preserving refactors still need human scope approval for big trees.
5. No whitespace-entropy "humanizer" theater. Fake noise is not a quality strategy. That omission is deliberate.

Future directions

1. Broader language packs beyond the current TS/JS/Python focus in examples
2. CI Action wrapping score.py as a PR check
3. Tighter coupling of structural scores to Rocky change_scope_analyzer output
4. Expanded library catalog beyond lodash / date-fns / dayjs / zod

15. Appendices

Appendix A: Version history

Appendix B: Quick install

# Cursor
mkdir -p ~/.cursor/skills
git clone https://github.com/hellozheat/no-more-slop.git ~/.cursor/skills/nomoreslop

# Claude Code
mkdir -p ~/.claude/skills
git clone https://github.com/hellozheat/no-more-slop.git ~/.claude/skills/nomoreslop

Invoke: /nomoreslop or "Remove slop from src/auth/login.ts".

Appendix C: Score CLI reference

python scripts/score.py --repo . --base main --json

Use the report field from JSON output when present. Verify locally (lint/tests) before PR even when scores pass.

Appendix D: Related links

• Repo: github.com/hellozheat/no-more-slop
• Prose sibling: Humaniseur / white paper
• Prose inspiration: blader/humanizer
• Rocky MCP: zheat.xyz/en/register/rocky-mcp/
• Rocky intro insight: /en/insights/rocky-mcp-free-quality-gate/
• Token / cost companion: /en/insights/rocky-token-cost-breakdown/

No More Slop v1.2.1 as shipped at [https://github.com/hellozheat/no-more-slop](https://github.com/hellozheat/no-more-slop). Pattern catalogs, score weights, and escalation rules live with the source and may evolve without a new white-paper revision.