February 2026

AI Is Writing Better Code. That's Not the Problem.

Better snippets are table stakes. The harder problem is understanding how trust and assumptions move across systems.

Shlomie Liberow

Founder & CEO, aisy

Share

Claude Code recently shipped stronger security guardrails: fewer hardcoded secrets, fewer obvious injections, safer defaults. Good, one less thing.

But snippet-level safety is rarely where serious incidents are born. The critical chains I've seen were usually made of components that were individually reasonable. Service A had permissive access controls that were documented as a known risk. Service B had session validation logic nobody escalated because exploitation required auth. Service C trusted internal traffic by default because it lived behind a load balancer.

None of that gets captured by a code assistant in isolation. Most scanners do not tell the story either. Each issue becomes a ticket. Tickets go to different teams. Teams make local choices to fix, defer, or accept risk. Nobody sees the chain, because the chain only appears when you zoom out.

Attackers See Graphs. Defenders See Queues.

I saw this pattern repeatedly while reviewing bug bounty submissions. A researcher would send an open redirect on a marketing subdomain. Medium at best. Pushback was common.

Then a week later they came back with a chain: open redirect into an OAuth flow on another subdomain, that flow trusts same-parent redirects, and now tokens for the main app can be hijacked. The "medium" finding was step one of account takeover.

The researcher found impact by mapping trust relationships across the environment. The internal teams judged each asset in isolation.

That mismatch gets worse as AI speeds up development, because there is more code, more often, connected in more ways than any one team can hold in its head.

Velocity Erodes Context

A team ships a new internal service on Tuesday. By Thursday it handles production traffic. The assumptions inside it about caller identity and upstream validation are implicit and mostly undocumented outside that team.

Six months later, the service appears in a vulnerability report. The original intent is gone. The people who made the trust decision may have moved on. What remains is another ticket with weak context and a triage clock running.

Anyone running vuln management already knows the backlog reality: huge volumes, high noise, limited attention. Finding issues is the easy part; the hard part is knowing which findings become dangerous together.

Missing HSTS matters more on a subdomain receiving OAuth callbacks. Permissive CORS matters more when the endpoint returns session tokens. Severity depends on what surrounds a finding as much as on the finding itself. Our vulnerability prioritization guide covers the signals a severity score misses.

Better Code Raises the Floor

Better code generation is a real improvement. It raises the floor and removes classes of avoidable mistakes.

But the ceiling is different work: understanding how your own environment connects, where assumptions break, and which low-severity findings can be chained into high-impact outcomes. Faster code production does not make that easier by default.

If anything, it makes that systems-level discipline more urgent.

Share

Get new posts by email

New posts only. Unsubscribe any time.

Shlomie Liberow, founder of aisy

Vulnerability management that learns.

Bring a recurring problem from your security backlog. We’ll look at what your team already knows, what it keeps re-checking, and how to get ahead of it.

Shlomie Liberow · Founder, aisy · shlomie@aisy.ai