Modern PR Spam: A Mirror of Early 2000s Email Chaos

Author: Rahul Bathija | Date: 2026-05-08 Context: A statistical deep-dive into the openclaw/openclaw repository via the Greptile Blog.

I'm Rahul, and I work at Greptile. Our mission is to build AI agents capable of reviewing pull requests. Currently, Greptile provides review services for OpenClaw, a project that experienced an unprecedented explosion in growth, becoming one of the fastest-growing repositories in GitHub's history almost overnight.

The Statistical Shift

The trajectory of OpenClaw provides a stark look at how AI is changing open-source contributions. Last December, the project was quiet, receiving roughly two PRs per week. Following the growth spike, the quality of contributions shifted dramatically.

Period	Merge Rate (%)
Pre-Spike	$\approx 48\%$
Post-Spike	$< 9.3\%$

This decline is largely attributed to "AI slop"—low-effort contributions generated by AI coding agents. The scale of this automation is staggering:

High Volume: One individual submitted 106 PRs in 24 hours.
Impossible Speed: The median time between these submissions was only 3 seconds.

Observation 1: The Necessity of Sender Reputation

The current state of PRs feels like a regression to the early 2000s email era. In 2000, the ILOVEYOU worm compromised 45 million machines in a single day because sending email was essentially free and trust was implicit.

The Evolution of Filtering

To combat the flood of malicious or useless content, email systems evolved. We moved from open trust to:

Blocklists to handle sheer volume.
Reputation infrastructure to identify bad actors.
Confidence-based filters to protect the inbox.

On OpenClaw, we already see a correlation between a contributor's history and their success rate:

First-timers: $8.2\%$ merge rate.
2-5 PRs: $10.3\%$ merge rate.
5+ PRs: $18.6\%$ merge rate.

Case Study: Vouch Mitchell Hashimoto (creator of the Ghostty terminal) faced similar AI-generated slop. His solution was Vouch, a trust management system. In this model, unvouched users are restricted, and bad actors are flagged. While currently project-specific, the goal is for these trust scores to eventually propagate across the open-source ecosystem.

(Note: Despite Vouch's success, Mitchell eventually moved Ghostty off GitHub.)

Observation 2: The Erosion of Cognitive Diversity

Linus Torvalds famously stated: ~~"Given enough eyeballs, all bugs are shallow."~~

Traditionally, this law worked because different humans bring diverse perspectives, different use cases, and unique problem-solving approaches. However, this breaks down when the "eyeballs" are actually the same AI models (Claude, Codex, Cursor, Devin).

The Convergence Problem: When contributors use the same prompts and the same models, they produce identical "independent" ideas. In OpenClaw, we observed:

4 people submitted the exact same title: feat(web-search): add SearXNG as a search provider.
6 people independently "discovered" and fixed the same Brave Search locale bug.
5 people found the same timeout deadlock in the agent runner.

If the underlying thinking is homogenized by AI, the advantage of open source—diversity of thought—disappears.

Observation 3: Thinking vs. Typing

The data reveals a clear divide in what actually gets merged into the codebase:

Novel Features: $9\%$ merge rate.
Refactors: $35\%$ merge rate.

Contributions that require a profound understanding of the existing architecture are nearly 4x more likely to be accepted than new features. This reinforces the idea that thinking is now more valuable than typing.

The "Architect" vs. The "Builder"

Consider the claude-mem project. The way it maps Claude Code's hook-captured tool stream into a resumable Agent SDK observer session is a complex architectural decision.

# Conceptual logic of a deep architectural choice
def observer_session(tool_stream):
    # This requires deep system knowledge to implement correctly
    # An AI cannot 'guess' this without a specific architectural prompt
    return map_to_resumable_sdk(tool_stream)

An AI agent cannot invent this architecture on its own. However, a developer who understands the system can distill that logic into a checklist, creating a prompt that enables the agent to execute it.

This mirrors the historical split in construction: 200 years ago, the designer and the builder were the same person. Eventually, the roles split into Architecture and Construction. We are seeing the same split in software: the contributions that survive are those requiring architectural insight, not just construction capability.

Final Thoughts

OpenClaw evolved into a functional "Jarvis" in months, proving that a small group of humans augmented by a community can build at unprecedented speeds. However, this speed creates friction. To survive, we must develop new primitives for identity, reputation, and validation.

Keep Reading

Engineering: How to Make LLMs Shut Up (Reducing output verbosity) - Dec 18, 2024
Featured: Building TREX (Execution layers for AI review) - Jun 17, 2026
Engineering: The Content-ifica