AI will find you an endless supply of problems. Catching the ones it throws back is the new job.
Last month I pointed an agent at a security backlog. A long list of overdue items spread across a dozen repos: dependency alerts, base-image CVEs, a few real vulnerabilities. The kind of list that sits untouched because nobody has a free afternoon and half the repos belong to people who moved on.
The agent went through all of it in one pass. It collapsed the whole thing down to a handful of actual pieces of work. It caught that two of our scanners disagreed, where one had flagged serious issues the other missed, and told me not to wait on the automated PRs that were never coming. It opened the safe fixes as draft PRs, one repo at a time, tests green.
Then it did the interesting thing. A few of the findings were real vulnerabilities that needed code changes and a judgment call about how bad they actually were. For those, the agent wrote a remediation plan and stopped. Hand back, no auto-fix. It also flagged one fix that was blocked purely on a human review approval, and said so plainly: needs a human, not code.
That last move is the whole story. The agent was happy to find everything and fix the boring stuff. The moment a finding needed someone to own it — accept the risk, put a name on the merge — it tossed the potato back to me.
Finding got cheap. Owning didn’t.
We spent years treating “find the problem” as the hard part. Static analysis, scanners, linters, test suites, security tools, all aimed at surfacing issues, because surfacing issues was expensive and slow.
AI knocked the bottom out of that. Finding is close to free now. An agent will read a codebase it has never seen, cross-check two scanners, dedup a backlog, and spot the thing your linter missed, all while you sleep. It is unreasonably good at this.
It got good at the mechanical half of fixing too. Bump the dependency. Rebase the branch. Write the test. Open the PR. Tedious, not risky.
What it hands back, correctly, is judgment and accountability. Is this vulnerability actually exploitable in our setup, or only on paper? Do we ship the fix now or accept the risk until next sprint? Who signs off that this merge won’t take down a customer? Those aren’t detection questions. They’re ownership questions, and an agent can’t own anything. It has no skin, no pager, no consequences.
So the potato comes back to a human. Every time.
The pile doesn’t shrink. It arrives faster.
Here’s the part people miss when they get excited about AI review. When finding becomes free, the backlog doesn’t get quieter. It gets louder.
Point a naive agent at a diff and tell it to find problems and it will find problems: a firehose of maybe-bugs, style nits, hallucinated concerns, and “consider adding error handling” on a function that already handles errors. The good systems spend most of their engineering on the opposite job. A coordinator dedups the findings, judges which ones are real, drops the noise, and decides what’s worth a human’s attention. The best prompt trick in those systems is telling the model what not to flag.
Think about that. We built machines that find issues for free, then had to build a second layer whose whole job is deciding which of those issues anyone should care about. The judgment didn’t disappear. It moved up a level.
Now multiply it across a team that’s already underwater. Every agent surfaces more findings than the humans have context to resolve. The repos nobody remembers still generate alerts. Reviews slow down because assessing an unfamiliar fix takes as long as writing it. The agent keeps handing back potatoes and there aren’t enough hands to catch them. So the potato gets thrown sideways, to another person, another team, a backlog labeled “later.” It doesn’t get dropped. It circulates.
That circulation is the work now, not the finding.
Don’t stop at the easy part
Finding is the half we’ve gotten comfortable with. It makes a good demo and it feels safe, because a finding is just information. You read it and move on. So most teams point AI at their code, collect a list of problems, and stop there. They’ve turned a frontier model into a smarter linter.
The same model that spotted the bug can usually propose the fix, write it, test it, and hand you a diff to read. That’s the higher-value half, and we use it least. Finding a problem and doing nothing about it is the cheapest outcome there is. If the agent is good enough to find the issue, make it earn its keep on the solution.
There’s a double standard here worth naming. We trust the agent to find problems. We act on what it finds. We reorganize the week around its list. Then we don’t trust it to fix those same problems. Look at that honestly and it’s backwards. Finding the right problem is usually the harder call. Deciding a vulnerability actually matters, that a design is wrong, that this is the root cause and not a symptom, that’s judgment. Bumping the version once you know is mechanical. We’ve chosen to trust the model on the hard half and babysit it on the easy half.
The obvious objection is that fixing is more complex than finding. True, and that argues for keeping a human on the diff, not for refusing the fix. We already read the fix line by line while acting on the finding without re-deriving it, so the harder task gets more scrutiny, not less.
Some of the hand-back is real. Irreversible changes, security calls, anything with a wide blast radius should come back to a human. Strip those out, and the rest is usually one of two things: it feels safer, or you don’t have the guardrails to accept changes at this pace. The second is the honest one. AI didn’t break your confidence. It exposed that your tests, CI, review, and rollback were never strong enough to let you say yes fast. Where the guardrails are good, you accept the fix without thinking. Where they’re missing, it feels reckless, and the agent isn’t the reckless part. A change that’s small, tested, reversible, and behind a flag costs almost nothing to accept. A change that isn’t shows you what to build next.
What this changes if you run a team
Stop being impressed by finding throughput. An agent that opens 200 findings is not ten times more useful than one that opens 20. Findings are cheap. The scarce resource is the capacity to own the resolution: the context to judge it and a person willing to put their name on the call.
A few things I’m trying to hold onto.
Measure what got owned, not what got found. Count the issues that actually got resolved, merged, and closed by someone who understood them. How many the tools surfaced is a vanity number now.
Build the catching layer on purpose. The finding agent is the cheap part. The value is the routing and judgment around it: what’s real, what matters, who owns it, and when it’s allowed to auto-fix instead of handing back. The better internal reviewers I’ve seen bake this in, with a strict “hand back to a human” rule for anything serious and an override so a person can always take the wheel. Let the agent fix what’s safe and reversible. Route everything with real consequences to a named human.
Watch where the potato lands. When the same unfamiliar repo keeps generating findings nobody can own, that’s not an AI problem. It’s an ownership problem the AI made visible. The honest fix is consolidating who owns what, not buying a better scanner. Sometimes the most useful thing an agent does is show you which parts of your org have no one home.
Keep humans on the hand-back items on purpose. Risk acceptance, security calls, cross-cutting merges. These should hand back, because someone has to be accountable, and accountability is the one thing you can’t hand to something with no stake in the outcome.
The skill that used to matter was finding the problem. That skill just got commoditized. The skill that matters now is catching what gets thrown at you, fast enough and with enough judgment that the pile actually goes down.
AI will find you an endless supply of issues. It will fix the easy ones and hand the rest back with a tidy summary. It will never decide which ones are worth your afternoon, or put its name on the merge.
That’s still the job.