Security researchers at an American startup have publicly disclosed a serious vulnerability in the Java environment. According to the report, the flaw allows code to be executed remotely – in technical terms Remote Code Execution, i.e. the injection and launching of one's own commands on a third-party system without having physical access to it. Because Java is embedded in countless applications, the affected circle ranges from private users to very large companies.

What is remarkable is less the discovery itself – serious vulnerabilities in widely used technologies appear regularly – than the way it was made: The associated exploit, i.e. the concrete exploitation code, is said to have been created with the support of an AI model for around 200 dollars. That is an order of magnitude that was previously associated more with an afternoon of research than with a full-scale security analysis.

Why the cost question is the real signal

Vulnerability research was long a specialist topic with a corresponding price tag. Anyone who wanted to find an exploitable vulnerability in a widely used library needed experienced people, time and often luck. It was precisely this hurdle that protected projects in practice: Not every application is worth someone searching for weeks.

If AI-assisted analysis massively lowers the cost per attempt, this calculation changes. Attacks that were previously not economically worthwhile suddenly become interesting – not only for large targets, but broadly distributed. For operators of web applications, portals and CMS installations, this means: The assumption "too small to be noticed" carries less far than it used to.

What this means for code reviews

Classic code reviews are primarily geared towards comprehensibility, architecture and technical correctness. Security often runs alongside – depending on how experienced the reviewing person is and how much time is available. This model comes under pressure when the other side searches for vulnerabilities in an automated and cheap way.

Three shifts are emerging:

  • From selective to continuous: A security audit at project completion describes a state that is already outdated after the next dependency update. Checks belong in the ongoing pipeline, not just in acceptance.
  • From own code to supply chain: The discovery concerns a widely used technology, not a single application. What matters therefore is which third-party components are in the project and how quickly they can be updated.
  • From checklist to responsiveness: The relevant metric is no longer just how thoroughly checks were carried out, but how many hours or days lie between a published vulnerability and the applied patch.

Using AI on the defence side

The same tools that make attackers cheaper are also available to development teams. It makes sense to use them as an additional review layer, not as a replacement for human reviews:

  • Automated review of pull requests for typical patterns such as unvalidated input, insecure deserialization or overly broad permissions.
  • Explanatory analyses of dependencies: Which library is used for what, and is it even still needed?
  • Support in writing tests that cover error cases and limit values – not just the expected flow.
  • Prioritisation of scanner reports so that teams do not drown in warnings without real exploitability.

Follow-up checking remains important. AI models deliver plausible but not necessarily correct assessments; a finding marked as non-critical is no carte blanche. Conversely, they generate false alarms that tie up capacity without expert evaluation.

Concrete homework for project owners

Regardless of this individual discovery, a sober stocktake is worthwhile:

  1. Keep an inventory: Which applications run in production, on which runtime environments, with which libraries? Without this list, every vulnerability report is a guessing game.
  2. Clarify update paths: Who is allowed to apply a security update, how long does a deployment take, and is there a tested procedure for this outside the regular release planning?
  3. Check maintenance contracts: Does the existing agreement cover security updates, or does it end at feature maintenance?
  4. Name legacy systems: Applications without vendor or community support are the real risk, because no patch comes for them.
  5. Practise the emergency: A short run-through of how the team reacts to a critical report uncovers gaps in responsibilities faster than any policy.

Assessment

For web and software projects, the focus thus shifts from one-off safeguarding to robust operational processes: Anyone who knows their dependencies and can patch within days instead of months is significantly better positioned than a team with perfect but frozen code. AI-assisted checks should in future become as self-evident as automated tests – as an additional layer that makes routine errors visible early. Professional responsibility for architecture, data flows and permissions, on the other hand, remains with the development team.

Sources