GitHub Sponsors Hit $100 Million. AI Slop Is Costing Open Source More.

GitHub announced this week that Sponsors has crossed $100 million for open source maintainers.

More than 70,000 of them. Funded by 280,000 sponsors.

The last $10 million came in five months. The first $10 million took two years.

Read that as good news. It is good news.

Now read the other number from the same week.

Merged pull requests across GitHub grew from 25 million a month in January 2023 to 90 million a month in March 2026. A 3.6x increase.

A meaningful chunk of that growth is AI slop. Low-effort, auto-generated pull requests that don't add value, and take a real human maintainer real minutes to figure that out.

Godot's Remi Verschelde has described triaging it as draining and demoralizing. Curl's Daniel Stenberg canceled his bug bounty program because it turned into a magnet for AI-generated junk submissions.

GitHub is now shipping PR caps as a defensive feature. A kill switch for maintainers who can't keep up any other way.

$100 million sounds like a turning point.

It's not the number that decides whether open source survives the next two years.

The Milestone, and What It Actually Buys

Do the math on $100 million across 70,000 maintainers and you get roughly $1,400 each, averaged.

That average is misleading. Organizations provide nearly 40% of the funding. Organization-funded sponsorships run about 15x larger than individual ones.

Skew that distribution the way real distributions skew, and most maintainers are getting a fraction of $1,400 a year. For work that, on a popular project, is closer to a full-time job than a hobby.

That's not a knock on GitHub Sponsors. The acceleration is real. Five months for the most recent $10 million versus two years for the first $10 million means the goodwill is compounding, not stalling.

But goodwill funding was never sized against the actual cost of maintaining a dependency graph the entire industry runs on. It was sized against how generous companies felt like being in a given quarter.

AI just changed what maintainers are being asked to do with that money.

Nobody adjusted the budget to match.

The Bill Nobody Put in the Press Release

A maintainer's job used to mean reviewing contributions from people who wanted to be there.

People who'd read the CONTRIBUTING.md. People who'd usually tested their change locally before opening a PR.

Now a meaningful share of pull requests come from someone who ran a coding agent against an open issue, didn't read the diff, and clicked submit.

The agent didn't misbehave. It did exactly what it was asked, which was generate a plausible-looking fix, not a correct one.

The maintainer still has to open it, read it, run it, and figure out in real time whether the person on the other end even understands what they submitted.

That's the part that doesn't show up in a "PRs grew 3.6x" headline. Reviewing a bad PR costs more attention than writing a good one from scratch, because you're reverse-engineering intent instead of just applying it.

A maintainer who used to spend an evening merging five real contributions now spends that evening rejecting fifteen plausible-looking non-contributions. And still has the same five real ones waiting behind them.

Multiply that by every actively maintained repo on GitHub.

The $100 million milestone stops looking like a win. It starts looking like a rebate that doesn't cover the new tax.

Why More Money Doesn't Fix This

The instinct is to say: pay maintainers more and the problem goes away.

It doesn't, because the problem was never purely financial.

You can't sponsor your way out of a queue that refills faster than any human can empty it. Money buys a maintainer more hours in the week. AI slop consumes hours faster than money can buy them back.

Generating a plausible pull request now takes an agent about the same effort as generating a real one. And it costs the submitter nothing either way.

That asymmetry is the actual crisis. Not the dollar figure.

The ratio of effort-to-submit versus effort-to-reject — and right now that ratio favors whoever is submitting, every time.

The Uncomfortable Take: I'm Part of the Bill

I use Claude Code daily. I've opened pull requests against open source projects I depend on, generated with an agent, in minutes, for bugs I found while shipping client work.

Here's the honest version.

The first two times I did that, I submitted the agent's diff without reading every line. Because it looked right and I was in a hurry.

One got merged clean. One got a maintainer comment asking why I'd changed a function signature that three other callers depended on.

I hadn't checked. The agent hadn't either — it wasn't its job to. It was mine.

That's the exact same failure mode I wrote about with n8n's AI Assistant building workflows with silent edge-case gaps: the model does the first draft fast, and the part that actually requires a human is catching what it missed.

I skipped that part once because the diff looked clean. A maintainer caught it for me instead of a production incident catching it later.

That's a cost I exported onto someone who isn't getting paid enough to absorb it.

If you use AI to ship code against a dependency you don't maintain, you're either doing the review work the model can't do, or you're quietly billing a stranger for it.

What Actually Closes the Gap

Sponsorship dollars and PR caps both treat the symptom.

Neither fixes the incentive that got us here: submitting a plausible fix costs the submitter nothing, and rejecting a bad one costs the maintainer real time, every single time.

The fix that would actually change the math is making the cost symmetric.

A few maintainers are already doing this without calling it that. Requiring a passing test the contributor wrote themselves. Requiring a written explanation of why the change is correct, not just what it changes, before a human even opens the diff.

That's friction, deliberately placed. It costs the person who wants credit slightly more effort. It costs the maintainer almost nothing.

The same discipline I described wiring verification into my own agent workflow works exactly as well as a contribution gate as it does inside a codebase you own.

If you maintain anything people depend on, that gate is worth building this week, not after the burnout.

If you ship code against other people's projects, run your agent's diff through the same discipline you'd want applied to your own repo. Before you ever open the PR.

The $100 million is real.

So is the bill.

Pay the review time yourself before you hand it to someone else.