The math changed
Take a team of eight engineers. Before assistants, they opened about 40 pull requests a week, and two senior engineers spent around half their time reviewing. With assistants the same team opens 80. The seniors didn't get twice as many hours, so each pull request now gets half the attention it used to.
Those numbers are an example, not a benchmark, but the shape is what most teams report. Writing scaled. Reviewing didn't. The patterns that slip through are the well-known ones: injection, hardcoded secrets, disabled checks, outdated packages, missing ownership checks. Those are exactly what scanners are good at, which is what frees human reviewers for design and business logic.
Which scanner catches which AI mistake
| AI mistake | Example | Scanner | Best place to run it |
|---|---|---|---|
| String-built queries, unsafe deserialization | f"... WHERE id = {id}" | SAST | IDE and pull request |
| Security checks switched off | verify=False, @csrf_exempt | SAST, Vibe Code | Pull request (block) |
| Placeholder keys that are real | sk_live_... "for testing" | Secrets | Pre-commit and pull request |
| Made-up or outdated packages | PyJWT==1.7.1, invented names | SCA, Malware | Pull request |
| Open-by-default infrastructure | 0.0.0.0/0, Action: "*" | IaC | Pull request, before apply |
| Old base images, root containers | FROM node:14, no USER | Container | CI image build |
| Real data copied into fixtures | production rows in tests/ | PII | Pull request |
| Missing ownership checks | findById(req.params.id) | API, DAST | Staging, nightly and on deploy |
Put each check where it's cheapest
A finding costs the least when it's fixed while the AI suggestion is still on the developer's screen. It costs the most after release. So push each check as far left as it can reliably run:
Noise is the real risk
A scanner that floods developers with false positives does more harm than good. People learn to click past it, and then they click past the real finding too. With AI multiplying the amount of code, the raw number of findings goes up with it, so triage matters more than it did before.
That's why AquilaX runs every finding through Securitron AI before it reaches a developer. It checks whether the code path is actually reachable and exploitable in context, and drops the ones that aren't. The goal is a short list people actually read.
A rollout that doesn't stall the team
- Week 1: secrets and SCA, blocking on new code only. Low noise, high value, and the fixes are usually a key rotation or a version bump.
- Week 2: SAST high and critical in pull requests. Start with injection, disabled checks and deserialization. Add more rules once people trust the signal.
- Week 3: IaC and container scanning in CI. Block public storage, wildcard IAM and root containers. Warn on the rest.
- Week 4: DAST and API scanning on staging. Nightly, and after each deploy. This is where ownership bugs get caught.
- Baseline the backlog separately. Existing findings go into a tracked list with owners and dates. New code is held to the bar from day one, and nobody gets blocked by a five-year-old issue they didn't write.
Rule of thumb: if a check is fast and precise, block. If it's slow or noisy, report. Move checks from report to block as the signal improves.
Read the rest of the series
This guide ties together the four patterns covered in the other posts in this series: why AI writes average code, fixes that delete security checks, dependencies frozen at the training cutoff, and missing ownership checks. Each one has concrete examples and the matching fix.
One platform for every stage
SAST, SCA, secrets, IaC, container, PII, malware, API and DAST, with AI triage so your team only sees what's real.
See all scanners →