Coherent doesn't mean it's correct Saying it's completed doesn't always mean it's been checked Confidence doesn't mean it has provenance It looks like it works — but does it have the right effect?
slopstopper is a set of tools for checking what generative systems produce. Each functions alone, but any combination of them work together as one system.
The problem
Slop used to be obvious.
It has not disappeared, it just got better at disguising itself. You can no longer tell just by looking at something what parts have been checked and what parts got filled in with an articulate guess. It all reads the same regardless.
Now with generative tools anything can look coherent, polished and confident while remaining completely untethered to reality. Everything can "look right", including complete and utter nonsense.
Failure modes
So where does it get in?
- R1Laundered uncertainty
- A mock value gets used as if it were measured. It ends up in a dashboard, then a decision, and nothing along the way marks it as a guess.
- R2Self-graded homework
- The tool that made the claim is the same tool that checks it.
- R3Ledger rot
- Work tracked in a document drifts from reality almost immediately. Merges drop rows and the file still reads fine.
- R4Silent deferral
- A “later” that isn't written down anywhere usually just doesn't happen.
- R5Economics slop
- An expensive model running work a cheap one could do, or a cheap one running work it can't and having to redo it.
- R6Overstated maturity
- Everything gets called “production-ready,” including things that aren't.
Three tools · one system
Three concerns that don't overlap.
One checks whether claims are honest, one checks which model should be doing the work, and one checks where the record of the work lives.
plumb-line
measures: whether claims are honest
Provenance primitives for JavaScript and Python, along with skills that audit for laundered uncertainty and will not launder it back out while fixing it. If a value was mocked, derived, measured or asserted, that label travels with it all the way to the claim.
tokenomics
measures: which model should do the work
Work is routed to the cheapest tier that can actually do it, and you name your own lanes rather than inheriting defaults. A living playbook carries strategy between sessions, so a new session opens on what you already worked out.
recursive-spine
measures: where tracked state lives
Work state lives in GitHub issues and milestones, where it stays queryable and does not hit the merge conflicts a prose file does. The skills teach the convention, stamp it onto a repo, migrate an old ledger, and age deferrals so they surface before they rot. Cross-project "pollen" carries a pattern that proved itself into the next repo.
Each one works on its own and in combination. Put tokenomics and recursive-spine together and the routing gets logged with issues and milestones instead of sitting in a playbook.
Applied to itself
Every tool is run on itself.
None of these ask of you a standard they don't meet. Each one is turned on its own repository, and has to survive the result.
Its auditor runs on plumb-line's own code before every release. The dogfood report keeps what it finds, including its own false-positive rate.
It runs on its own build: a dogfooded playbook, and a spend-ledger that makes its savings claims falsifiable against its own history.
Its issues and milestones existed before its first commit. Its labels were stamped by its own bootstrap. Its deferrals age on its own digest.
If we cannot follow a rule while building the tool that asks you to follow it, the rule has failed its own test and we rewrite it. The record of where it broke stays where it is, because editing that after the fact would be the failure this is all meant to catch.
Expanding
More will follow.
Three seams today, deliberately disjoint. The frame has room for more, and the vocabulary is pinned so the same word can't mean three things.
Honesty
Are the claims true, and do they carry where they came from?
Economics
Is the right model doing the work, at the right cost?
State
Does the record of the work live where it can be queried?
Where the seams meet, the shared vocabulary is pinned in the marketplace: one owner per term, the others defer or alias. New instruments join on that condition, or not at all.
One add, three tools
Install.
From inside Claude Code. Each plugin also works alone; none requires its siblings.
/plugin marketplace add slopstopper/marketplace
/plugin install plumb-line@slopstopper /plugin install tokenomics@slopstopper /plugin install recursive-spine@slopstopper
Prefer to read first? Start with plumb-line's live docs, or the org profile on GitHub.
Write-ups
What shipped, with receipts.
One short piece per release, drafted from the shipped artifacts and passed through the same audit gate as the code. Machine-drafted, owner-edited, sources listed on every piece.
- 2026-08-19 plumb-line 0.10.0 — pay down the ledger
- 2026-08-15 plumb-line 0.9.0 — the front door
Status, honestly
None of this stops you from shipping slop. It just makes it visible, attributable, and slightly embarrassing.
plumb-line's deterministic checks catch every planted violation in the fixtures without a false positive, and the results are in validation-results.md. Nothing here is called battle-tested. The vocabulary is current or planned, and the receipts are linked.