pi-anti-clanker-slopper-gaming

A pi.dev skill that abolishes AI-generated code slop across all languages.

AI coding assistants leave behind code that looks finished but is not: stubs that panic at runtime, placeholders pretending to be values, "for now" deferrals that become permanent, "should work" hedging, leaked chat text, hallucinated credentials, silently swallowed errors, and AI writing artifacts like em dashes, emoji, and weird Unicode. pi-anti-clanker-slopper-gaming uses an agent-first approach: you read the code with your own judgment as the primary slop detector. No scanner, no regex engine, no dependencies.

Why

Standard linters (eslint, clippy, ruff, golangci-lint) catch syntax, style, and bugs. They do not catch the intent-vs-implementation gaps that LLMs introduce. This skill targets exactly those gaps.

• You (the LLM) are the sole detector. You read code with your own judgment, understand context, and decide what is real slop versus legitimate code.
• New slop categories require judgment. Em dashes, emojis, weird Unicode, and AI sentence patterns ("it's not this, it's that") are impossible to detect reliably with any automated approach.

Install

As a pi package (recommended)

pi install npm:pi-anti-clanker-slopper-gaming

Or add to ~/.pi/agent/settings.json:

  "packages": ["npm:pi-anti-clanker-slopper-gaming"]
}

Try without installing

pi -e npm:pi-anti-clanker-slopper-gaming

Direct from git

pi install git:github.com/hanzceo/pi-anti-clanker-slopper-gaming

Use

Trigger the skill in any pi session by asking it to abolish slop. Read the target files and use your judgment to detect slop patterns.

What it catches

Category	Severity	Examples
stub	critical/high	NotImplementedError, todo!(), unimplemented!(), pass-only bodies, panic("not implemented")
placeholder	medium/high	TODO/FIXME/XXX/HACK markers, mock/fake/dummy data
deferral	medium/high	"for now", "temporary", "workaround", "quick hack", WIP
hedging	low/medium	"should work", "hopefully", apologetic/overconfident language
ai-bleed	critical/high	leaked chat preamble (# Here's the code...), markdown fences in source, instruction comments
ai-refusal	critical	"As an AI language model...", "I cannot..."
hallucination	high/medium	"your-api-key-here", REPLACE_ME, example.com, path/to/...
silent-error	high/medium	bare except: pass, empty catch {}, Go's return nil without error
debug-leftover	medium/high	console.log, debugger;, pdb.set_trace(), print('DEBUG')
ai-prose	low/medium	em dashes (---, --), emoji in code, weird Unicode, AI sentence patterns

Languages

Python, JS/TS, Go, Rust, Java/Kotlin, C/C++, Ruby, PHP, Swift, Scala, Lua, Perl, R, Haskell, shell, SQL, and more.

The 4-phase workflow

1. EYEBALL IT - read the target files yourself. Look for stubs, placeholders, em dashes, emoji, weird Unicode, AI sentence patterns, hedging, AI conversational bleed, and all other slop categories.
2. CONFIRM - check each finding: is it real slop or a false positive? Abstract methods, test fixtures, tracked TODOs, and intentional string literals are not slop.
3. ABOLISH - apply the per-category fix playbook. Replace slop with working code, never with different slop.
4. VERIFY - re-read the changed code, optionally re-scan with the bundled scanner, run the test suite.

Full rule catalog with exact regexes and false-positive rules: references/slop-taxonomy.md. Per-category fix playbooks: references/abolition-guide.md.

What this is not

• Not a style linter. If eslint/clippy/ruff/golangci-lint catches it by default, this skill defers to them.
• Not a security scanner. Use bug-reaper for vulnerabilities. This skill flags hardcoded secrets and hallucinated credentials as slop, but does not do exploit analysis.
• Detection is agent-driven. The LLM reads code with its own judgment. The bundled scanner is a supplementary tool, not the primary detector.

License

MIT