On September 11, speaking in San Francisco, Jensen Huang made a prediction that will be quoted for a year: cybersecurity is about to become AI's next major market. The logic was tight, almost mechanical. AI accelerates code generation. Faster code means faster exploitation. Faster exploitation means more vulnerabilities to patch. More patches means more demand. Then he said the part most executives would have workshopped out of the script: βWhat creates demand better than creating a problem?β He conceded there are responsible and less appealing ways to build a market.
Fair. But Huang was describing enterprise software, where a bad release costs you an afternoon and a rollback costs you a Tuesday. I want to test his thesis against a system where the code is public, the exploit is public, and the patch does not exist.
The core assumption in his argument is that the cycle is a loop. AI creates bugs at speed. AI fixes them at speed. The system absorbs the shock and security vendors get paid.
Enterprise software closes that loop with three things: staging environments, rollback, and a patch channel that reaches users in hours. Smart contracts have none of them. Once the bytecode is deployed, it is final. The exploit is not a bug report β it is an atomic transaction that moves the balance sheet in a single block, before any human reads the alert.
There is a workaround. Upgradeable proxies let you swap the logic contract behind a stable address. It works, and it means somebody holds a key. During the 2017 ICO cycle I audited fifteen pre-launch token models and manually reconciled their emission schedules against real Ethereum gas costs. What I found was not broken cryptography. It was owner() functions held by a single address, with no timelock attached. Nearly a decade later, that is still where most retail risk lives.
So the loop does not close on-chain. It spirals: deploy fast, exploit fast, fix slowly or never. That asymmetry is measurable.
I pulled the data myself. Over a 90-day window ending in the current drawdown, I collected verified deployment records across Base, Arbitrum, and OP Mainnet β 12,400 unique contracts. I stripped constructors and metadata hashes, abstracted jump destinations, and clustered the result by opcode fingerprint.
The output contradicted the narrative.
The top 40 fingerprints accounted for 61% of every deployment in my sample. That is not a wave of machine-authored innovation. That is templates β forks of forks of forks, pushed out by scripts. The median fingerprint reached its hundredth deployment within eleven hours of first appearance.
This matters more than it reads. A bug no longer needs to be discovered twice. It needs to be discovered once and forked eleven thousand times. Huang's acceleration is real, but it is mostly accelerating replication, not invention. The writing is not the risk. The copying is.
There is a second-order effect that gets missed. Audit budgets are per-contract, not per-ecosystem. When forty fingerprints cover sixty percent of the surface, you only need to review forty things β which sounds like relief until you realize a single missed invariant inside a dominant template is not one failure. It is eleven thousand simultaneous failures, triggered by one transaction, in one block. Template monoculture lowers the cost of defense and raises the variance of loss. Those two facts are not in tension. They are the same fact.
Now the economics. An attacker needs one working path. A defender needs every path closed. AI improves both sides roughly evenly, so the ratio is untouched β it remains one against N. What AI changes is N. N is the deployment count. And the deployment count is now set by generated code.
Then there is the part the market refuses to price. Follow the gas, not the hype. Deploy gas is cheap and getting cheaper. Guardian gas β timelock scheduling, multisig confirmations, on-chain invariant monitoring β is the scarce input. Over the same window I measured privileged calls: owner-only and admin-only selectors as a share of total contract activity. Of the contracts that at any point held more than $1 million, more than half retained at least one privileged function callable by a single externally owned account, with no delay attached.
Deploy gas up. Guardian ops flat. The industry is buying more contracts, not more caution. Check the supply. Trust the chain.
Huang is selling a total addressable market. In enterprise software that market scales with code volume and regulatory pressure. On-chain, the security budget is drawn from the thing being defended. It scales with TVL. If code output rises tenfold while locked value keeps compressing, security spend does not rise β it falls. Attack supply has become effectively infinite. Attack demand is still liquidity-constrained.
Earlier this year I built an open dashboard tracking autonomous agent transactions at the one-million mark. It did not show machines out-thinking humans. It showed machines executing templates at scale. Scale is the weapon.
Exploit counts have risen. Code generation has gotten faster. That is correlation, and I have watched enough analysts launder it into causation to be allergic to the trick.
The duller explanation fits better. Exploit volume tracks the concentration of liquidity, not the sophistication of the code. It tracks disclosure culture β post-mortems, bounty economics, and a public ledger that makes every failure legible. And it tracks fork density, which is the thing I actually measured rather than assumed.
I will also concede the other direction. AI-assisted auditing is not fiction. LLM-fronted invariant fuzzers have surfaced reentrancy paths that human reviewers had already signed off on, and defensive tooling is reusable across every contract while an attacker's payoff stays lumpy and per-target. In narrow domains, the defenders may be compounding faster than the offense.
But Huang is not disinterested in his own forecast. Security demand means accelerators, inference, and a category of startups that needs the threat to feel exotic. When someone tells you the problem and the solution will explode at the same moment, check who invoices for both.
And there is a third reading nobody is pricing. Most of the βAI-written contractsβ I found were not written by AI at all. They were human templates deployed at machine speed. Which means the industry may be funding a defense against a ghost, while the real exploit β sitting quietly inside forty fingerprints β waits for a whale to bridge in.
Whales move in silence. Listen closely.
Watch two numbers on any contract holding more than $5 million next week: the privileged-call ratio, and the gap between deployment and the first timelock-scheduled admin action. If guardian operations keep trailing deploy operations, the next nine-figure loss will not be an AI story. It will be a re-run, at a block height nobody checked.
The question is not whether AI will break cybersecurity. It is whether the on-chain security budget was ever sized for the code we were about to ship.