Karpathy’s "long-form verbal prompting" went viral last week. And I immediately saw the audit trail of a dozen broken contracts.
The method is elegant on the surface: speak your raw, chaotic thoughts into an AI for ten minutes, let it ask clarifying questions, then have it reconstruct a coherent output. As a fellow engineer, I respect the intent. But as a blockchain due diligence analyst who has traced $3.6 million thefts through ETC reorgs and watched Terra’s peg dissolve in real time, I measure risk in gas units, not in hope. Applying this approach to smart contract development—or worse, autonomous DeFi agents—is structurally dangerous. The code doesn't lie, but the AI’s reconstruction can hallucinate entire vulnerabilities into existence.
Here’s the pre-mortem: we will see a major exploit traced back to a developer using this method to write a Solidity function. The exploit won’t come from a syntax error. It will come from a missed invariant, a misread intent, or a creative "clarification" the AI invented to fill a gap in the user’s chaotic speech. The fork was inevitable; the error was optional.
The Context: From Hype to Hazard
Andrej Karpathy, former OpenAI co-founder and now at Anthropic, recently shared his personal workflow for interacting with large language models. Instead of crafting precise, structured prompts, he uses voice input—rambling, incomplete, sometimes contradictory—and lets the model reconstruct the objective through a series of targeted questions. He describes it as "a small interview" where the AI becomes an active collaborator, not a passive command line.
In the blockchain world, this resonates deeply. We are surrounded by hype about AI agents that write smart contracts, perform yield farming, and even conduct audits. Startups like those building on "AI Layer2s" or "autonomous DeFi" have latched onto the idea that natural language input lowers the barrier for developers. Why write careful specifications when you can just talk your way to a contract?
But blockchain is not content generation. It is deterministic execution under adversarial conditions. Every line of code must account for reentrancy, integer overflow, economic incentives, and oracle manipulation. A fuzzy understanding reconstructed by an AI from a ten-minute monologue is a single point of failure waiting to be exploited.
During the Terra Luna collapse in 2022, I didn’t panic sell. I spent four days analyzing the delta-neutral hedging failure of the UST algorithmic stabilizer. The reserve’s $2.5 billion in assets was largely illiquid LUNA, making the peg mathematically impossible. I wrote a blunt report titled "The Ponzi Geometry." No amount of natural language collaboration would have saved that protocol—only cold, hard data verification. The same logic applies to any AI-generated smart contract: verification is not a step; it is the entire process.
The Core: Forensic Code Skepticism Meets Weak Prompt Engineering
Let’s dissect Karpathy’s method from a blockchain developer’s perspective. I’ll use my own audit experience to highlight the failure modes.
1. The Illusion of Intent Reconstruction
Karpathy claims the model can "reconstruct your true goal" from chaotic speech. In my experience auditing Ethereum Classic’s 2017 hard fork response, I manually traced transaction hashes to find three critical gaps in the community’s response to a 51% attack. The "community governance" was a facade for technical incompetence. The actual goal—preventing double-spends—was clear to any engineer, but the execution required precise code changes, not reconstructed intent.
For a smart contract, the "true goal" might be "allow users to withdraw funds after lock period." The AI, after hearing a rambling description, could reconstruct this as "allow users to withdraw funds after a condition check." The difference between "lock period" and "condition check" can mean the entire contract being drained. The code doesn't tolerate ambiguity. Chaos is just data waiting to be compiled—but compilation requires exact parameters.
2. The Fragility of Active Questioning
Karpathy emphasizes that the model should ask clarifying questions, turning the interaction into an "interview." In my reverse-engineering of the Olympus DAO bonding contract in 2021, I spent three weeks decompiling the code to discover infinite minting loops. No amount of questioning would have revealed that flaw—it came from a subtle interaction between mint and redeem functions. The AI would ask "Is there a mint cap?" The answer would be "no," which is exactly the vulnerability. The AI lacks the adversarial mindset to ask the right questions: "What if someone calls mint twice in the same transaction?" "What if the reward token is the same as the deposit token?" These are the questions a skilled auditor asks. A passive model that only clarifies surface-level ambiguities cannot simulate adversarial thinking.
3. Token Cost and Incentive Misalignment
Karpathy’s method consumes massive tokens: ten minutes of speech (~1,500 words) plus multiple rounds of questioning. For a blockchain startup deploying on L2, every API call costs gas in the form of real money. The cost of generating a single function through this method could exceed the cost of deploying it. More importantly, the model’s incentive is to keep the conversation going (it wants to please), not to minimize cost. This creates an implicit bloat: the AI will ask questions to extend the interaction, wasting computational resources and, for blockchain use cases, potentially hitting rate limits or budget caps during a critical deployment.
During my 2024 Bitcoin ETF structural review, I found that three major asset managers relied on legacy banking infrastructure violating self-sovereignty. The custodians used multi-sig thresholds that were "institutional grade" but centralized control. The AI, if asked to design a custody solution via verbal prompting, might reconstruct a perfectly compliant but centralized model—missing the entire point of self-custody. The cost of that mistake is billions in locked funds.
4. Security: ASR Leaks and Supply Chain Attacks
The method requires audio input processed by an automatic speech recognition (ASR) service. For blockchain developers, that audio may contain private keys, seed phrases, or sensitive design decisions. Even if the ASR is encrypted, the transcript is stored. In a bear market, security budgets are cut. A compromised ASR log could lead to a targeted social engineering attack. I measure risk in gas units, not in hope. The attack vector is real.
During the 2026 AI-agent smart contract exploit I analyzed, an autonomous agent was manipulated into signing a malicious permit due to a subtle gas optimization flaw in the ERC-20 allowance interface. The exploit originated from the agent’s inability to verify contextual intent. Now imagine a human using verbal prompting to train an AI trading agent. The agent learns to trust chaotic instructions. The same chaos that allows creativity also allows adversarial manipulation.
The core insight is simple: blockchain requires formal verification, not conversational reconstruction. The method works for content creation (blog posts, marketing copy) because the cost of error is low. For smart contracts, the cost of error is irreversible liquidation.
The Contrarian: What the Bulls Got Right
I am not here to dismiss the entire approach. That would be lazy cynicism. As a cold dissector, I must acknowledge where the bulls have a point.
The method genuinely lowers the barrier for idea generation. When I first started analyzing Terra Luna, I spent hours writing down my thoughts in a structured memo. If I had used Karpathy’s method to dump all my observations into an AI and let it reconstruct a framework, I might have saved a day. For brainstorming protocol architecture, tokenomics models, or even attack vectors, verbal dumping followed by AI-structured questions can accelerate the initial conceptual phase.
Moreover, the "interview" format forces the AI to surface assumptions. In my Due Diligence work, I often write long, messy notes before formalizing them. An AI that asks "What is your worst-case assumption about the stablecoin’s peg?" could catch an oversight. The method is not inherently flawed—it is mismatched for execution.
Additionally, the shift toward "AI as collaborator" aligns with the trend of no-code blockchain development platforms. Tools like those that allow drag-and-drop smart contract creation already exist. Verbal prompting could make them even more accessible, enabling non-coders to prototype ideas. The key is to ensure the output is reviewed by a human who understands the underlying economics and security. In that sense, the method serves as a rapid prototyping tool, not a final production pipeline.
I have used similar techniques myself when analyzing the Olympus DAO bonding contract. I spoke my observations into a voice memo, then asked the AI to list potential failure modes. It helped me generate a checklist. But I never trusted the AI’s code output; I only trusted its ability to organize my own thoughts. That is the correct use: the AI is a tool for cognitive amplification, not for code generation.
The Takeaway: Accountable Engineering, Not Verbal Magic
The method will spread. Developers will use it to write smart contracts for yield farming, NFT bridges, and AI agents. And some of those contracts will break. The question is not if, but when. I predict the first major exploit tied to this workflow will occur within six months of widespread adoption. The exploit will be traced back to a missing require statement that the AI omitted because the user’s verbal description skipped that detail. The code doesn't lie, but the AI’s reconstruction will omit truth.
As an industry, we need to adopt a new rule: any AI-generated code must be treated as fresh from the forge—untempered and brittle. The human developer remains the sole source of accountability. We cannot let the ease of verbal prompting seduce us into bypassing manual review. The fork was inevitable; the error was optional. We choose the error the moment we treat AI as a trustworthy colleague rather than a flawed co-pilot.
I advise every developer reading this: go ahead, use Karpathy’s method to brainstorm and prototype. But before you deploy, revert to the cold, hard audit. Trace every line of code as if your reputation depends on it—because in blockchain, your reputation is your only stablecoin.
Chaos is just data waiting to be compiled. Make sure you compile it with your own hands.