Detect AI slop, technical debt, and architecture drift before they reach production.
AI coding tools (Claude Code, Codex, Cursor, Aider, OpenHands) made writing code fast. They also made it fast to accumulate dead code, over-abstraction, duplicated logic, meaningless wrappers, wrong module boundaries, and silent architecture drift.
SlopBuster is a set of Claude Code skills that cover the points in the lifecycle where slop is created, caught, or handed off:
Plan ──▶ Build ──▶ Audit ──▶ Fix ──▶ Document
(before) (during) (after) (remediate) (handoff + replay)
| Skill | When it fires | What it does |
|---|---|---|
slopbuster-plan |
Before a new project / major feature | Upfront, research-first planning — competitor and landscape research with real web sources, grade the opportunity (market, commercial viability, feature scope, build difficulty), output a multi-document plan instead of inventing from imagination. |
slopbuster-rules |
While implementing code | Architecture guardrails — layering, module boundaries, typing, async & resource safety — so generated code doesn't drift into slop. |
slopbuster-audit |
After code exists / on a PR | Exhaustive file-by-file audit for slop, dead/mock/fake code, duplication, perf issues, tech debt; emits a structured scores manifest (with a health gauge, severity-tagged + numbered findings), an overview with prompt-your-agent guidance, and a prioritized fix plan. Also a user-journey simulation mode that war-games real usage step by step. |
slopbuster-fix |
After an audit, to remediate | Works the audit's phased fix-plan and writes a fix-result report — what was actually fixed, which audit and findings it addresses, what changed, and the before→after health delta. The receipt that closes the loop (audit → fix → re-audit), and the record a dashboard tracks over time. |
slopbuster-docs |
For handoff and replay | Documents the codebase for two audiences: humans taking it over (overview, architecture, per-subsystem, data model, setup, operations, an honest handoff briefing — with diagrams) and an AI replaying it — an optional "reverse vibe coding" rebuild blueprint that reverse-engineers the design system, architecture, and feature specs into copy-pasteable prompts plus a rebuild order. Reads file-by-file; durable docs set, not a code re-narration. |
Each skill is stack-agnostic at the top and loads a stack reference pack on demand. Packs ship for Python, Rust, and frontend (client/server separation, with a Next.js/React instantiation); adding a new stack is just another reference file.
As a Claude Code plugin:
/plugin marketplace add perhapxin/slopbuster
/plugin install slopbuster
Or drop the skills/ folders into ~/.claude/skills/.
The skills auto-trigger from natural requests:
- "plan the architecture for this new service before we write code" →
slopbuster-plan - "scaffold the backend following good architecture" →
slopbuster-rules - "audit this repo for slop and tech debt" / "review this PR" →
slopbuster-audit - "document this codebase for handoff" / "write the architecture & onboarding docs" →
slopbuster-docs - "reverse-engineer the prompts to rebuild this" / "extract this project's design system & specs" →
slopbuster-docs(rebuild blueprint)
You can also invoke them explicitly: /slopbuster-audit.
- Originality comes from combination and refinement, not invention from zero. Plans must be grounded in existing reality (real products, real repos, real constraints).
- Thin transport, thick domain. Responsibility lives in the layer where it is most stable.
- Audit every file, changed or not. Slop hides in the files nobody reviewed.
- The output is a decision, not a transcript. Reports are prioritized and actionable.
See LICENSE.