AI Slop That Actually Runs: Inside sloprun.dev, Where the Run Button Is the Code Review

It usually starts with a rejection notice.

Somebody builds something they are proud of, posts it, and discloses that an AI wrote most of the code — because disclosure is the honest thing to do. And the work gets dismissed unread. Pull request closed on principle. Forum post deleted for the label. Nobody ran it. Nobody read it. The provenance was the verdict, and the verdict was a single word: slop.

"AI slop" has become one of those rare insults that ends a conversation before it starts. It lets you hand down judgment on a piece of work without engaging with the work at all. And the frustrating part is that the insult exists for a reason — the internet genuinely is drowning in low-effort AI-generated projects that nobody can try, verify, or trust. The label is doing real filtering work. It is just doing it with terrible precision, and good ideas are dying with their provenance instead of their merit.

Which is why I found sloprun.dev so interesting. It is a small site that takes the insult, prints it on the front door, and then quietly dismantles the logic behind it. The tagline is "AI slop that actually runs." The footer says "99% slop. 100% runs." And the entire site is organized around one idea: if you can press run on something and it works, the argument about where the code came from becomes a lot less important than we pretend it is.

Three rules, in order

The homepage explains the whole system in three steps, and the ordering is the point.

Post it. One writeup and one self-contained HTML file. That is the entire submission format. No repo to clone, no build step, no dependency tree — if the idea cannot be shown in a single file, the site's position is that it is not ready yet. This sounds like a toy constraint until you see what people fit inside it: real SQLite compiled to WebAssembly booting inside the browser tab, Python running via Pyodide, Raft leader election with five simulated machines, a neural network with hand-written backpropagation.

Run it. Every visitor gets a run button. No install, no sign-up, no build — the demo executes in the visitor's own browser, sandboxed. Reading and running never require an account; signing in exists only for posting, voting and commenting, as a spam limiter rather than a gate.

Label it honestly. Every post declares its provenance: ai, hybrid, or human. The label is recorded and displayed — and never ranked on. Nothing on the site filters by it, nothing scores it, nothing buries the ai-labeled work under the human-labeled work. Provenance is metadata, not a score. The one thing that gets a post removed on principle is lying about the label, which neatly inverts the usual incentive: everywhere else on the internet, disclosing AI involvement invites the penalty, so people hide it. Here, hiding it is the only offense.

What pressing run actually gets you

Rules are cheap; the shelf is what sold me. The catalog is over a hundred demos deep, and the best of them have a real idea inside — the kind of thing a textbook takes a chapter to explain and a running demo teaches in ten seconds.

Take the flocking demo. Four hundred birds, no leader, no plan. Each one follows three local rules — steer toward neighbours, steer with neighbours, don't crowd neighbours — and a murmuration falls out for free. You can drag the sliders mid-flight or click the field to drop a predator and watch the flock split around it.

There is something almost self-describing about that demo living on this particular site. A murmuration is order that emerges from simple local rules with no central authority — which is more or less sloprun's theory of how trust should work. No editorial gatekeeper decides what is worthy. Each visitor applies one local rule: press run, and if it worked, say so.

The Galton board makes the same argument for randomness. Balls fall through a triangle of pegs; every peg is a coin flip, left or right, nothing else. No individual ball knows anything. The pile at the bottom draws a bell curve every single time, live, with the normal-distribution overlay filling in as the histogram grows.

Some of the shelf is just beautiful. The light-show choreographer scatters two hundred little lights over a park at dusk; pick a shape — or type a word — and each light computes its own route to a spot in the formation, easing in, nudging aside mid-flight when a neighbour crowds it.

And some of it is quietly rigorous. The double pendulum integrates the real equations of motion — Runge-Kutta, 240 steps a second — and runs a second pendulum alongside the first, started just 0.001 radians away. Same rules, same maths, same clock. A live readout tracks the gap between them as it grows from nothing to everything, which is the cleanest demonstration of sensitive dependence on initial conditions I have seen outside a lecture hall.

The trust machinery

Skepticism about running a stranger's AI-generated code in your browser is correct, and the site treats that skepticism as a design input rather than an insult. Every demo runs inside an iframe sandboxed to allow-scripts only — an opaque origin with no cookies, no storage, and no access to the parent page. The content security policy allows zero external requests, so a demo physically cannot phone home; whatever you type into one stays in the tab. A banner above every demo says it plainly: sandboxed and isolated in your browser, and never enter a real password in a demo — the kind of warning that only occurs to people who have thought properly about what could go wrong.

Then there is the part I keep coming back to. Scroll below any demo and you hit the source panel, headed with a sentence that carries the whole site: the code you see is the code that just ran. For the flocking demo that is 1,140 lines, 47.4 KB, one index.html — every line readable, no account needed. Nothing is published without its code. Traditional review is still available to anyone who wants it; it just is not required reading before you are allowed to try the thing.

The honest zero

Next to every demo are two counters: how many people ran it, and how many pressed a button afterward saying it actually worked. The checkmark is green, and green is earned — nothing else on the site is allowed to use that color. When I went through, most counters read dozens of runs and zero worked. Not because the demos are broken — everything I pressed run on ran — but because almost nobody has bothered to vouch yet.

Most sites would fake that number, seed it, or hide it until it looked respectable. Leaving the zeros visible is a small act of discipline that tells you more about the operation than any about page could: the metric means something precisely because it is allowed to be embarrassing. It is the same instinct as the readability-scoring demo on the shelf that grades its own syllable counter against 150 hand-counted words and publishes the complete list of all 26 it gets wrong. Measurement you can trust is measurement that discloses its own error.

Why this matters beyond one small site

The industry is currently sorting AI-generated code with two bad tools: blanket rejection ("no AI slop") and blanket acceptance ("ship whatever the model emits"). Both are provenance-based judgments, and provenance is a terrible proxy for quality in both directions. LLM-written code can be excellent; human-written code can be garbage; the label tells you who typed, not whether it works.

What sloprun proposes is older than any of this: judge software by executing it. Make the artifact runnable by anyone, in a sandbox that makes running safe, with the source one scroll away, and let the only currency be a real person saying "this worked for me." Disclosure stops being a confession because it stops being a verdict. That will not scale to every kind of software — a one-file browser demo is a favorable arena for run-it-and-see — but as a norm, an idea does not count until someone can try it would improve most of what gets posted everywhere, AI-written or not.

And if you have built something with an AI that you believe actually runs — a visualization, a tiny game, an algorithm made touchable — one HTML file is the entire submission format. Label it honestly. Then let strangers press run on it, which is both the scariest and the fairest review process your code will ever get.

Go press run on something: sloprun.dev. If it works, say so. On this site, that sentence is the whole peer-review system — and it only means anything because real people do it.