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.
A leaked AWS access key turns up in a config file committed six months ago. The scanner flags it. An eager autofix opens a PR that deletes the line.
The PR is green. It merges. The key still works.
Deleting a secret from the current commit doesn't revoke it, doesn't remove it from history, and doesn't tell you who used it. The fix closed the alert and left the risk exactly where it was.
An autofix that knows its limits is a tool. One that doesn't is a liability. The limits of automated remediation aren't a weakness to hide. They're the design.
Automated remediation is very good at one shape of problem: a known-bad pattern at a known location, with a minimal change that removes it and a test that proves it. Injection, missing authorization checks, unsafe deserialization, a vulnerable dependency with a clean upgrade path.
It gets worse as the fix depends on facts that aren't in the code. Who owns this credential. What this endpoint is supposed to allow. Whether this behavior is a bug or a contract a customer relies on.
Those cases share a property: the right fix is a decision, not a diff.
A secret's risk lives with the provider, not in the repository. The real remediation is to rotate the credential, check access logs for use, and then remove it from code and history. None of that is a code change.
Nullify doesn't autofix leaked secrets. Secrets Detection verifies live credentials against the provider where it can, tags a suspected owner, and gives rotation guidance. Rotation itself is a provider-side action that Nullify has no standing access to, so the finding goes to manual rotation with a tracking ticket.
An endpoint lets a user apply a discount code twice. Is that a bug? Maybe. Maybe a promotion depends on it. The code can show you what happens. It can't tell you what should happen.
A fixer can propose the restrictive version. It shouldn't open a PR that silently changes pricing behavior. The right output is the finding, the evidence, and a question for the owner.
Tightening an API's input validation may close a vulnerability and break every client that sends the old format. Removing a deprecated auth method may close a downgrade path and lock out a customer's integration.
When a fix changes what outside callers can do, it needs a migration plan, a changelog and usually a deprecation window. That's a product decision.
Some findings aren't a bad line. They're a bad shape: a service that trusts every caller on the internal network, a tenant boundary enforced in the UI and nowhere else. The real fix is a design change across several services. A minimal patch at one call site gives you false comfort and a closed ticket.
If there's no build, no tests and no way to run the scanner again, a generated fix has nothing to stand on. It's a patch nobody can check. The honest output is fix guidance, not a PR that implies confidence the evidence doesn't support.
"Don't autofix" doesn't mean "ignore." Each of these needs a different path:
| Finding | Wrong automated response | Right response |
|---|---|---|
| Leaked secret | Delete the line | Rotate at the provider, check usage, then clean code and history |
| Unclear business logic | Patch the behavior | Send the evidence and a question to the owner |
| Public contract change | Tighten validation silently | Plan a migration and a deprecation window |
| Architectural flaw | Patch one call site | Raise a design ticket with the attack path |
| Unverifiable fix | Open a PR anyway | Give fix guidance and a reproduction ticket |
The pattern is the same in every row. When the fix is a decision, route the decision to the person who owns it, with the evidence attached.
It's tempting to judge an autofix tool by how many PRs it opens. That's the wrong scoreboard. A tool that opens a PR for every finding is guaranteed to open some that are wrong, and every wrong PR spends trust you need for the right ones.
The better measures are whether the PRs it does open get merged, and whether the findings it doesn't fix still reach someone who can act on them.
Nullify's Autofix only works on findings that triage has confirmed are real and worth fixing. It covers code vulnerabilities, dependency issues, cloud misconfigurations and validated pentest findings. Leaked secrets are deliberately out of scope.
When a generated fix isn't appropriate, Nullify falls back to fix guidance and a ticket with reproduction steps, tagged to the owner, and keeps the context for later. When it does open a PR, the change has passed an independent review for root cause, behavior and minimality, and the PR records which checks ran. Nullify's documentation says plainly that a generated fix is a proposal, not a guarantee.
Security leaders can tighten this further with an autonomy policy and blocked action types that control when Nullify opens PRs, files tickets or messages people.
Nullify never merges. A human always makes the final call.
The leaked key didn't need a PR. It needed a rotation and a look at the logs. An autofix that knows its limits is a tool. One that doesn't is a liability.
Not properly. Deleting a secret from code doesn't revoke it or remove it from git history. The credential has to be rotated at the provider and its usage checked. Tools can detect, verify and route leaked secrets, but rotation is a provider-side action.
Findings with a known-bad pattern at a known location and a minimal, testable fix: injection, missing authorization checks, unsafe deserialization, and vulnerable dependencies with a clean upgrade path. The more a fix depends on intent, ownership or external contracts, the less suited it is.
The main risks are fixes that close the alert without removing the risk, fixes that change legitimate behavior, new dependencies or vulnerabilities, and review fatigue from too many PRs. Guardrails such as triage-only fixing, independent review, PR caps and human merge approval reduce them.
No. Automation can prepare a fix through checks, CI repair and reviewer assignment, but a human should approve every security change. The merge is where someone accountable confirms the fix is right for the system.