{Insights}
by alchemain team

AI is writing more of your code every quarter. For Java teams, that code arrives with a problem the compiler can't see.
The number every Java team should know
Veracode's Fall 2026 GenAI Code Security update tested 18 models across four languages. It covered four classes of flaws: SQL injection (CWE-89), broken cryptography (CWE-327), cross-site scripting (CWE-80) and log injection (CWE-117). Each model got 20 tasks per language, and static analysis judged whether the output was secure.
The results split cleanly. Python passed 64% of the time, C# 60% and JavaScript 57%. Java passed 31%, 26 points behind the next language.
The code wasn't broken in the usual sense. Syntax was close to 100% across every language. The Java simply compiled, ran and carried a known vulnerability in most cases.
Veracode is careful about what this means, and we agree. The language isn't the problem. Its best explanation is training data: decades of public Java written before SQL injection, XSS and log injection were well understood. Models learned those patterns and reproduce them. Veracode expects Java to improve and level off somewhere around 50 to 60%, which would still leave it last.
The industry agrees: fixing is the job
Read the AppSec vendors' feeds last week and one message repeats. Snyk said finding vulnerabilities is getting easier and fixing them at AI speed is the work. Black Duck said finding is only part of the challenge and fixing at scale is what matters. Endor Labs joined OpenAI's Daybreak Defense Factory, where Codex writes and tests the fix for Endor's findings. Snyk joined Factory's Cyber Defense Network, where Factory's agents do the same.
That is real progress in how the industry talks. Detection vendors are saying out loud that a list of findings isn't the outcome.
But look at the shape of the answer. Findings stay with one vendor. Fixing moves to another vendor's general-purpose agent. Someone on your team still has to decide whether the fix is real.
Why a handoff isn't enough for Java
In Veracode's data, log injection and XSS were the hardest categories. Both depend on tracing how data moves through the code. A fix for them has to understand that path too.
A fix that makes the scanner go quiet can still break a Spring call chain. A fix that compiles can still leave the flaw reachable. In Java, the same tracing work that makes the bug hard to find makes the fix hard to get right. That work has to happen against your build, your JDK and your tests.
The harness around the model matters as much as the model. Endor Labs reported last week that the same model wrote secure code 29% of the time in one harness and 19% in another. A better model doesn't close that gap. A better loop does.
Closed-loop remediation: Detect → Refactor → Verify → Deliver
00felix is built as one loop, not a handoff between tools.
Detect. Executability & Reachability Analysis checks whether a finding can actually be reached, so your team stops spending time on noise.
Refactor. AST refactoring rewrites the vulnerable call site, for example string-built SQL into a parameterized query.
Verify. A Self-Healing Compile-to-Test Loop runs the change against your real build and tests, and repairs it until they pass.
Deliver. One Build-Verified PR lands in your repo. Your engineer stays the final reviewer.
Without 00felix | With 00felix |
|---|---|
SAST flags every string-built query, reachable or not | Executability & Reachability Analysis keeps the findings that matter |
A ticket asks a developer to rewrite the code | AST refactoring rewrites the call site |
A fix counts as done when the scanner goes quiet | The Self-Healing Compile-to-Test Loop proves the build and tests still pass |
Audit evidence is a ticket marked closed | A Build-Verified PR, reviewed and merged by your engineer |
What to do this quarter
Treat AI-generated Java as high-risk by default, as Veracode advises. Keep static analysis and human review in place.
Then change what you measure. Stop counting findings and start counting verified fixes merged. A backlog that only grows is a detection program. A backlog that shrinks with every green PR is a remediation program.
Shift-Left made developers the bottleneck. Autonomous remediation takes that weight off them.
See how 00felix turns SAST and SCA alert backlogs into green pull requests.
Just Fix It.
