The time for imperfect software is over

Recently I attended a Bitcoin++ event in Berlin where I listened to a panel discussion titled "Can Bitcoin Payments Survive the AI Onslaught?". This article paraphrases the topics discussed on that panel, combined with some of my own research.

The writing on the wall

Since the invention of computers, humans have written the programs that machines execute. Humans are prone to errors, so software has always had bugs and unintended behaviours. This has led to critical software carrying security vulnerabilities, which in turn has led people (both lawful and chaotic) to discover and exploit them.

Security has always been a cat-and-mouse game: defenders try to write secure software, while attackers try to find holes in that security. When only humans were involved, finding vulnerabilities was an artisanal process that very few people could perform at the highest level. That dynamic has now changed.

A clanker will not tire

Up until now cybersecurity has operated under constraints inherent to human nature:

• Finding a zero-day vulnerability or a cryptographic logic flaw requires years of specialised knowledge. You need a deep understanding of memory management, applied cryptography, programming languages, and system architecture.
• Auditing a massive open-source codebase containing millions of lines of code by hand is painfully slow.
• Because the process is so slow and expensive, human attackers have to be selective. They focus their attention on the most lucrative or strategically important targets. This creates a false sense of security for less prominent systems ("security through obscurity").
• If a codebase is massive, a vulnerability buried deep within it might survive simply because no human has the stamina to find it.

But now the barrier to entry has plummeted. You no longer need a Ph.D. in computer science, all you need is a credit card. An LLM does not get bored or tired, it can trace a million execution paths in minutes. Attackers no longer need to be selective as they can deploy swarms of AI agents to analyze everything.

The main project repository on GitHub is no longer the only target. AI can scan every deployment for new bugs, every version of every dependency, every release, and every announced zero-day vulnerability. Defenders need to be right 100% of the time, while attackers only need to succeed once and that asymmetric reality has magnified exponentially.

This shift means security can no longer be a final checkbox checked by human auditors before software ships. Organizations must now assume that an AI adversary is actively reading every line of public code they deploy. Even worse, AI can be used to decompile packaged software, effectively making all distributed software "open source." To counter this defenders are forced to adopt the same tactics, integrating LLMs directly into their CI pipelines to hunt for vulnerabilities before software is ever released.

The next steps of this evolution are already underway. LLMs can uncover bug classes that human auditors would never conceive, and the first of these novel exploits have already appeared in real-world attacks. Existing legacy technical debt combined with these new attack surfaces means the target area for automated exploits is massive.

Case studies

Case 1:

If you follow the crypto or AI security space, you have likely heard about the Coldcard (an air-gapped hardware wallet) vulnerability. It has been analysed extensively, so here are the key takeaways:

The Coldcard incident was a textbook example of a bug that was practically invisible to human reviewers but easily surfaced by automated AI analysis. In March 2021, a firmware update introduced a build configuration error. Due to this error, the system silently stopped calling the hardware's True Random Number Generator and fell back to a weak software pseudo-random number generator. This flaw collapsed the cryptographic entropy of generated seed phrases from 128 bits down to roughly 40 bits. The 24-word seed phrases looked completely normal, but they were computationally predictable.

The flaw sat in the public open-source code for five years without any human noticing. It was only in July 2026 that an adversary using AI to scan the repository identified the vulnerability.

Because the seed space was reduced to 40 bits, attackers were able to brute-force every possible seed, check the generated addresses against the blockchain, and drain the funds. Starting July 30, 2026, over $116 million (approx. 1,816 BTC) was drained.

Case 2:

While the Coldcard incident involved AI scanning code to uncover a long-standing logic flaw, the Kimi K3 incident demonstrated how agentic AI can actively hunt and weaponize new vulnerabilities in critical infrastructure.

In July 2026, security researcher Chaofan Shou deployed 32 Kimi K3 agents in parallel to analyze Redis, an in-memory database used worldwide. In less than two hours, the swarm of AI agents discovered and weaponized multiple zero-day vulnerabilities across several versions of Redis.

This was a watershed moment because it was the first widely documented instance of an accessible model autonomously discovering zero-days in widely used, critical software. It proved that LLM agents can perform sustained offensive security work at a volume and speed that human software patching cycles cannot match (at machine speed). It also demonstrated that relying on safety guardrails in commercial LLMs is largely futile: if a model has the reasoning capacity to find a vulnerability, an attacker will find a prompt or jailbreak to make it do so.

The future

Both sides are burning compute tokens at such an rate that we will probably run out of fresh water by 2030... But eventually legacy code will be patched, AI-driven security pipelines will mature and a new status quo will be reached. The infrastructure providers hosting these models are laughing all the way to the bank, but the genie cannot be put back into the bottle.

Was Anthropic right to restrict public access to Mythos (their frontier security-focused model)? At the very least it gave maintainers of critical infrastructure time to prepare. But with willing Chinese models now readily available, proprietary guardrails matter no more.

Vibe-coded software written with minimal oversight will contain security holes, just as human-written software always has. Moving forward, maintaining any baseline of security requires auditing code (human or machine-written) with AI, manual review alone is no longer viable.

How this dynamic plays out long term remains open. Whenever a more capable model is released, both attackers and defenders are forced to upgrade. The most capable models are also the most expensive, and with frontier labs facing profitability pressures, security operations will face escalating costs. It is an arms race where offensive capabilities scale cheaply, but defenders have no choice but to pay to keep up.