A seven-line fix I didn't type got merged into Hugging Face transformers the day it was opened (#45611). The maintainers reviewed it like any other PR. Since April, the same agent has had fixes merged into Deno, ClickHouse, Envoy, Keycloak, Apache Airflow, Tesseract and Google's gemini-cli: 115 pull requests merged by maintainers, across 46 open-source projects with 1,000+ stars.

The agent is superhuman, the open-source Claude Code plugin I build. It picks an issue, reads the repo's last 10–20 merged PRs to learn how that project wants code, writes the fix, runs the repo's own CI, scores its own PR, and opens it from my account with a line in the body saying it was made with superhuman.

With 115 merges, I had enough to ask a better question than "does it work?": what do maintainers actually accept? So I went through the public record, the merges and the reviews.

How I looked

Everything here is public GitHub data, so you can check it:

gh search prs --author gaurav0107 --created ">=2026-04-01" 

I kept repos with 1,000+ stars, pulled the size and files of every merged PR, and read every human review comment, including on the PRs that didn't land, because those comments say most clearly what a maintainer wants.

What didn't decide it: size and tests

I expected "small diffs with tests" to be the whole story. It isn't. The median merged PR changed 129 lines across 3 files, and more than 8 in 10 touched a test file. PRs that didn't land were, if anything, a little smaller, and touched tests just as often.

Some merges were tiny: the transformers fix was 7 lines, and Tesseract #4563, a crash fix for a disabled-legacy build, was 11. Others weren't: Deno #36321 was about 100 lines with a test, merged the next day. Tests and a tight diff are the entry ticket. What decides the merge is everything around the code.

What maintainers merge

1. Fixes for issues that are open to outside contributors

Many big projects tell you, in writing, which issues they'll review outside PRs for. gemini-cli and GitHub's own cli/cli review outside PRs only when they're linked to an issue labeled help wanted, and a bot enforces it. Others need a signed CLA, a linked issue, or a specific base branch such as dev.

So the first check isn't the code. It's the issue: is it labeled for outside help, is there a CLA, which branch does the project want? That's a two-minute read of CONTRIBUTING.md, and it was the cheapest lesson in the whole set.

2. Work nobody else is already doing

In this data, the most common way a working fix missed out was another fix landing first, often a maintainer's own. Before writing anything, read the PRs already linked to the issue, closed ones too. One review told me the approach I'd taken had already been discussed and turned down on an earlier PR. That's information you can get before writing a line.

3. PRs that read like a person wrote them

A Neovim reviewer called one of my diffs solid and still asked for the description to be rewritten in my own words. The merged PRs follow the repo's own template, title format and tone, which is why the agent reads the last 10–20 merged PRs before it writes anything. A description that sounds like a generated summary costs the reviewer time, even when the code is right.

4. Contributors who answer review

Some merges are instant. Others take weeks: pytorch-lightning #21686, which fixed torch.compile breaking toggle_optimizer, merged 34 days after it was opened. Either way the PR stays alive only while someone answers the reviewer. When I let a review sit for a couple of weeks, the PR went stale and was closed.

5. Maintainers will carry a good fix over the line themselves

This was the best surprise. On openapi-generator #23622 the maintainer asked me to regenerate the samples, then merged the fix through their own PR with me as co-author. Seven more shipped the same way: a maintainer (or, at Bazel, their import bot) landed the commit through their own PR, with credit. If the fix is right and easy to verify, maintainers will often do the last mile.

What changed in the agent

All of this is in superhuman's public README and changelog:

  • Disclosure on by default. Every PR body ends with a line saying it was opened with superhuman (v0.6.0). Commits stay authored by the human who runs it.
  • It grades itself first. A 10-dimension rubric, including process compliance and PR format, scores the PR before it's opened. It fixes the weakest dimension, or stops and explains what's blocking it.
  • Review comments become rules. A lesson-distiller turns reviewer feedback into rule cards the planner must follow next time. A rule that shows up in three or more repos is enforced everywhere (v0.6.0).
  • It focuses where it's welcome. Repos where PRs keep getting rejected or ignored go on a cooldown and are skipped.
  • Caps. By default, at most 6 PRs a day, and a repo where you already have 2 open PRs is skipped.
  • A sweep for what needs you. /contribution-sweep records merges and closes, and lists PRs where a reviewer is waiting on you.

Not on that list yet: reading a repo's gates (help wanted, linked issue, CLA, base branch) before the agent starts. On this data, it's the cheapest gap left.

The short version

From 115 merges, maintainers accept:

  • a fix for an issue that's open to outside contributors;
  • that nobody else is already working on;
  • written the way that repo writes PRs, in a human voice, with a test;
  • from someone who answers review within days.

None of that is about AI. It's what maintainers have always asked of a first-time contributor. The agent just has to meet the same bar every time.

The repo's here if you want to follow along: https://github.com/gaurav0107/superhuman