Nullify

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse varius enim in eros elementum tristique. Duis cursus, mi quis viverra ornare, eros dolor interdum nulla, ut commodo diam libero vitae erat. Aenean faucibus nibh et justo cursus id rutrum lorem imperdiet. Nunc ut sem vitae risus tristique posuere.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse varius enim in eros elementum tristique. Duis cursus, mi quis viverra ornare, eros dolor interdum nulla, ut commodo diam libero vitae erat. Aenean faucibus nibh et justo cursus id rutrum lorem imperdiet. Nunc ut sem vitae risus tristique posuere.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse varius enim in eros elementum tristique. Duis cursus, mi quis viverra ornare, eros dolor interdum nulla, ut commodo diam libero vitae erat. Aenean faucibus nibh et justo cursus id rutrum lorem imperdiet. Nunc ut sem vitae risus tristique posuere.

Security PR Fatigue: How Many Fix PRs Can an Engineering Team Actually Absorb?

Security PR fatigue is what happens when automated fixers open security pull requests faster than engineers can review them. The PRs pile up, reviewers start skimming or ignoring them, and the fixes that matter wait behind the ones that don't. The answer isn't fewer fixes. It's pacing fixes to the review capacity a team actually has.

One of the questions security leaders ask us most often right now sounds like a compliment: "If AI can write the fix, why not fix everything at once?"

It's a fair question. The cost of generating a patch has collapsed. A harness pointed at a backlog of a few thousand findings can open a pull request for every one of them before lunch.

And that's exactly the problem.

The bottleneck moved from writing fixes to reviewing them

For most of the history of AppSec, the scarce resource was the engineer who wrote the fix. Backlogs grew because nobody had time to write patches.

That constraint is gone. The scarce resource is now the engineer who reviews and merges the fix.

Every security PR still needs someone who understands the code to read it, decide it's safe, and accept responsibility for merging it. That person also has a roadmap, an on-call rotation and their own PRs waiting for review. Their attention doesn't scale with your token budget.

So when a fixer opens two hundred PRs against one team, the team doesn't get two hundred fixes. It gets a queue.

What PR fatigue looks like in practice

The pattern is consistent, and it looks a lot like alert fatigue with a new costume:

  • PRs age in draft. Nobody is assigned, so nobody feels responsible.
  • Reviewers start bulk-closing. After the tenth low-value PR in a week, the eleventh gets closed without being read.
  • Important fixes get buried. The PR for an internet-facing critical sits in the same list as a dozen test-only findings.
  • Trust erodes. Engineers learn that "security bot PR" means "probably noise," and that label sticks to the good PRs too.

That last one is the most expensive. Once a team stops trusting security PRs, every future fix costs more to land.

The wrong takeaway

The wrong takeaway would be that automated fixing doesn't work, or that teams should go back to tickets and spreadsheets.

That's not what the problem says. Automated fixing works. The failure is treating PR volume as the goal.

A security program doesn't need the maximum number of PRs open. It needs the maximum number of merged fixes on the findings that matter, per hour of engineering attention. Those are very different targets.

How to pace security fixes so they merge

Fix only what triage says is real

The easiest PR to absorb is the one you never open. Unreachable code, test fixtures and dead dependencies shouldn't become pull requests at all. Triage before you fix, on reachability, exploitability and business context, not raw severity.

Cap open PRs per repository

A small, fixed number of open security PRs per repository keeps any one team from being flooded. When one merges, the next one opens. The queue moves at the team's pace, not the fixer's.

Send the most important fix first

With a cap in place, order matters. The fix for the reachable, exploitable critical should be the one in front of the reviewer, not the one behind forty lower-priority PRs.

Route each PR to a person, not a repository

A PR assigned to the engineer who last touched the code gets reviewed. A PR assigned to "the repo" gets ignored. Ownership should also account for how much that person already has open.

Make every PR easy to say yes to

Minimal diffs, matching code style, passing CI, and a description that explains the bug and the evidence. Every PR that a reviewer can approve in five minutes protects the trust you need for the next one.

Group work into campaigns with a goal

"Upgrade every CVE-affected dependency in payments services this quarter" is a goal a team can plan around. Two hundred unrelated PRs are not. Campaigns give the work a scope, an owner and an end.

The economics of restraint

This is where the AI economics get interesting.

We buy tokens. Customers buy security outcomes. The value of a fixer is not how many PRs it can open. It's how efficiently it turns tokens and engineering attention into fixes that merge.

A fixer that opens a PR for every finding spends both badly. It spends tokens on fixes nobody will review, and it spends engineer attention sorting good PRs from bad ones. A fixer that triages first, caps volume and works each PR to green spends less of both and lands more.

How Nullify paces fixes

Nullify's Autofix is built around this constraint. It only fixes findings triaged as real and worth fixing. It opens at most three fix PRs per repository at a time and five new PRs per remediation plan. These are campaign limits by design, not a global throttle.

Each PR is routed to the recent authors of the changed lines, then CODEOWNERS, then the owning team, with no more than three reviewers. Nullify works the PR after it opens, fixing CI failures, replying to review comments and rebasing, so the reviewer sees something ready to approve. It never merges.

In Security Program Management, security leaders run the work as campaigns with a scope and an autonomy policy. Assignment accounts for each person's open PRs and tickets, and stalled security PRs are escalated through Slack with the risk and SLA stated.

The real question

The question isn't "how many fixes can AI write?" Almost any number.

The question is how many fixes your team can absorb, and whether you're spending that capacity on the ones that matter.

Frequently asked questions

What is security PR fatigue?

Security PR fatigue is when engineers receive more automated security pull requests than they can review, so PRs age, get closed unread, or are merged without proper review. It's the pull-request version of alert fatigue, and it grows as automated fixers make patches cheap to generate.

How many security PRs should be open per repository?

There's no universal number, but it should be small and fixed. A cap of a few open security PRs per repository, with the next one opening only when one merges, keeps the queue moving at the team's pace. Nullify uses three open fix PRs per repository.

How do you get developers to review security PRs?

Send fewer, better PRs. Fix only triaged, real findings; route each PR to the engineer who owns the code; keep diffs minimal and CI green; and explain the bug and evidence in the description. Escalate stalled PRs with the risk and SLA, not just a reminder.

Is it better to batch security fixes into one large PR?

Usually not for code fixes. Large PRs are harder to review and riskier to merge. Batching works for simple, same-ecosystem dependency bumps. For code changes, small PRs paced to review capacity tend to merge faster.