AI Slop: What It Is, How We Got Here, and What We're Serving

Every pull request is a dish. Someone's going to eat it — your reviewers, your teammates, the maintainer of the repo you contributed to. The question PRKitchen exists to answer is simple: is this one worth serving?

More and more of what shows up on the pass isn't. To understand why — and why it got bad so fast — it helps to know where “slop” came from in the first place.

What is AI slop, exactly?

“Slop” is the word the internet settled on for low-effort, mass-produced AI output that nobody asked for and nobody checked. It's the spam of the generative era: plausible at a glance, hollow underneath. The term went mainstream in 2024, when writers and engineers needed a single word for the flood of generated text, images, and code being published faster than anyone could vet it. “Slop” stuck because it captured the texture of the stuff — cheap, filler, reheated.

Applied to code, slop has a specific shape. It compiles. It's syntactically fine. It might even carry its own passing tests. But it was generated from a thin prompt, dropped into a pull request without the author reading it closely, and it solves a problem the codebase doesn't have — or solves the right problem in a way that ignores every convention around it. Slop isn't “wrong” the way a typo is wrong. It's wrong the way a plate sent out by a cook who never tasted it is wrong.

The tell is almost never the syntax. It's the absence of judgment.

A short history: how we got here

Code generation didn't arrive overnight, and neither did slop. The problem is a direct consequence of how fast the tooling outran the review process. Walk the timeline and you can watch the gap open.

Long before any of this, programmers were already shipping code they didn't fully understand — pasted from forums, from Q&A sites, from the one teammate who'd since left the company. Copy-paste programming is ancient. What changed wasn't the impulse; it was the supply. The web handed you one snippet at a time, and you still had to go find it, read it, and bend it to fit. Generation hands you an unlimited, made-to-order supply, on demand, that already looks tailored to your exact problem. The friction that used to force a moment of scrutiny — searching, comparing, adapting — is gone. Remove the friction and you remove the pause where judgment used to happen.

2021 — Autocomplete grows up. The first mainstream AI pair-programmer shipped as a technical preview, suggesting whole lines and functions right inside the editor. It was genuinely useful, and crucially it was scoped: it helped you write the code you were already writing. A human was still driving every keystroke, still the author of record.

Late 2022 — The chat era. A general-purpose chat assistant put a code generator in front of millions of people overnight. Suddenly you didn't need an editor plugin, or even a clear idea. You could describe a vague intention in plain English and get back something that looked like a solution. The barrier to producing code collapsed — and so did the barrier to producing code you didn't understand.

2023–2024 — The flood. Every platform shipped an assistant. Generating a hundred lines became faster than reading ten. For maintainers of open-source projects, the volume changed character: not just more contributions, but more contributions where the “author” couldn't answer a basic question about their own diff. Security teams began receiving confident, fabricated vulnerability reports — bounties claimed for bugs that didn't exist. Maintainers of core infrastructure libraries publicly described losing real hours triaging AI-generated reports that were, on inspection, hallucinated nonsense.

2024 — The word arrives. As the volume became undeniable, the culture reached for a name. “Slop,” by analogy to spam, gave people a way to talk about the problem without re-litigating whether AI itself was good or bad. The point was never the tool. The point was the missing care.

2025 and on — The gates go up. Major projects started adding explicit AI-contribution policies to their guidelines: disclose AI use, or in some cases don't submit unreviewed AI output at all. Repeat offenders began getting blocked. The community moved from “isn't this neat” to “prove you read this before you sent it.”

How did we get here, really?

Strip away the timeline and the cause is simple: generation got cheap faster than review got cheap. Writing code dropped from minutes to seconds. Reviewing code stayed exactly as expensive as it always was — a human, paying attention, holding the whole system in their head. That gap is the entire problem. Slop is just what rushes in to fill it.

And review can't simply be sped up to match. Reading code for correctness, security, and fit is irreducibly a judgment task — it scales with human attention, not with compute. You can generate ten variations of a function in the time it takes to properly review one. Every productivity gain on the writing side lands as fresh load on the reviewing side. Multiply that across a team, across every repo, across contributors you've never met, and the arithmetic stops working. Something has to hold the line automatically, or the line doesn't get held.

Here's the part that gets lost in the panic: well-seasoned AI code is a genuine superpower. Structured prompt, clear context, a human who actually reviewed the diff before opening the PR — that code doesn't just scrape by. It sails through. The problem was never “AI wrote it.” The problem is shipping code nobody tasted first. What teams need isn't another bot that leaves a comment and hopes someone reads it. They need a gate that can tell the difference before the merge.

What PRKitchen actually does

PRKitchen is a pre-merge quality gate. Instead of nagging, it acts:

• AI slop detection — a dual-layer heuristic + model score, with thresholds you set per repo.
• Real enforcement — pass, draft, or close. When a PR is below standard, PRKitchen sends it back to the kitchen instead of leaving a sticky note.
• Composable recipes — size limits, linked-issue requirements, relevance checks and more, declared in plain YAML in your repo (or click-to-configure in the dashboard).
• Per-repo rules — because one size fits none. Your infra repo and your docs repo don't deserve the same checklist.

Zero lines of code to write. A handful of checks in one config. Three actions that actually enforce. It's the judgment step the timeline above quietly deleted, added back as a gate that never gets tired and never skips a PR under deadline pressure.

recipes:
  - id: "ai-slop-filter"
    name: "🔍 AI Slop Detection"
    checks:
      - type: "slop_score"
        threshold_medium: 70   # flag for review
        threshold_high: 100    # return to sender
    actions:
      low:    "pass"           # 🟢 clean plate, serve it
      medium: "draft"          # 🟡 needs seasoning
      high:   "close"          # 🔴 back to the kitchen

That's the whole gate: score the diff, and on a high slop score, send it back to the kitchen instead of onto your main branch. Well-seasoned AI code clears it without noticing. Slop doesn't.

Right now: a waitlist, not a paywall

We're opening with a waitlist first — no signup forms to wrestle with, no billing, just a line out front. It costs you nothing to get in it, and it's how the first tables get seated when we open the kitchen.

And when we do open, here's how the trial will work:

• 14 days, full access. Every paid feature — AI slop detection, AI code review, PR summaries, the full dashboard — on from minute one.
• No card to start. You don't hand over payment details to try it. With nothing on file, nothing can quietly auto-charge — there's no renewal you have to remember to cancel.
• You decide at the end. When the 14 days are up, add payment through Stripe to keep cooking. Do nothing and your account simply drops to the Free plan — you keep your data, and with no card on file nothing is ever charged.

One price for the whole kitchen

While we're talking about money: PRKitchen is billed as one flat rate per plan — never per seat.

A lot of code-quality tooling charges by the head. Add a teammate, the bill goes up. Invite an outside collaborator to review one repo, the bill goes up again. You end up rationing access to the exact tool that's supposed to protect your codebase — which is precisely backwards.

We don't do that. A plan covers your whole org up to its member limit — the Team plan is the same price whether that's three people or twenty-five — and outside collaborators on your repos are included. You're paying for the kitchen, not counting plates at the table.

Reserve your table

We're launching soon. If you want quality enforced on every PR — and you'd like your AI-assisted code to be the kind that sails through rather than the kind that gets sent back — come get on the list at prkitchen.ai.

Every PR is a dish. Let's make yours worth serving.