Activation Impedance and the math of the short-leash AI
Keeping AI coders on a short leash increases shipped velocity because the human time required to verify code mathematically eclipses generation time.
By Ted Benson
Sparked by The short leash AI coding method for beating Fable · discussion
I was scrolling through Hacker News yesterday when I hit a fascinating debate. The thread was arguing about whether to put AI coders on a short leash or let them YOLO entire features unattended.
The YOLO camp argues that stopping to verify the model's work every step ruins your velocity. It sounds intuitively right. You bought a rocket ship; why are you stopping at every red light?
But I think they're looking at the wrong side of the equation.
Both sides of this thread are anchoring entirely on the model's generation speed. They are treating the AI like an engine. And as Martin Fowler recently pointed out in his evaluation of GenAI, reading code is fundamentally harder than writing it. The bottleneck in software engineering is rarely the keystrokes. It's our ingestion.
Imagine you're a driving instructor. Your teenager is at the wheel.
The car is easily capable of doing 80mph on the highway. But you cap them at 30mph in a suburban subdivision. Why? Because you aren't driving. You are verifying.
If your teenager swerves at 80mph, your reaction time to hit the passenger brake is mathematically too slow to prevent a crash. Your eyes have to register the swerve, process the trajectory, and fire the muscle impulse to your foot. That physical latency is a hard limit.
To stay safe, you don't upgrade the engine. You artificially limit the speed to match your stopping distance.
Now apply that passenger brake to unconstrained AI coding.
Let's do the literal back-of-the-napkin math. A 5-second generative burst from a modern LLM can easily spit out 500 lines of system architecture. The engine is roaring. The car is doing 80mph.
But what happens when it swerves?
Let's say you asked it to scaffold a new billing service. In 5 seconds, it dumps a massive Pull Request into your lap. It looks gorgeous. But buried on line 342, it hallucinated a Stripe.Customer.list_upcoming_invoices() method that doesn't actually exist in the v2 API, and it subtly wired your database migration to drop a staging table.
When you factor in subtle, documented security vulnerabilities and the massive downward pressure on code quality from AI-generated churn, reverse-engineering this hallucinated data model is crushing. You aren't just reading text. You have to hold the entire proposed state in your head. You have to cross-reference it against the actual undocumented quirks of your codebase. You have to go read Stripe's documentation. Then you have to manually unwind the migration that, if deployed, would have nuked your users table.
That process routinely takes a human developer 30 minutes just to figure out what the AI thought it was doing.
The model generated the code in 5 seconds. It took you 1,800 seconds to verify it. You are constantly crashing.
I call this metric Activation Impedance.
In electrical engineering, impedance is a circuit's opposition to alternating current. In AI-assisted software engineering, it is the ratio of Time-to-Generate versus Time-to-Verify.
When you let the AI YOLO a whole feature, the impedance is massive. You aren't actually going faster. You're just deferring a massive cognitive bill to the code review stage. The math of the passenger brake doesn't care how fast the engine runs. If your verification time is orders of magnitude slower than the generation time, the system grinds to a halt. You end up manually untangling a spaghetti-code hallucination because you outran your own cognitive headlights.
This is exactly why the "short leash" method works in practice.
By guiding the AI 50 lines at a time, you keep the car at 30mph. You review a single function. You approve a single schema migration. You stay completely inside your cognitive stopping distance. Generating 50 lines might take 2 seconds. Verifying it takes 15 seconds. The Activation Impedance drops from a ratio of 1:360 down to roughly 1:7.
That is mathematically manageable. And ironically, your actual shipped velocity over the course of a week goes up, because you never spend an entire afternoon recovering from a 500-line crash.
This structural math explains a lot of the recent shifts in the AI ecosystem.
It's why strict sandboxing protocols like Anthropic's Model Context Protocol are suddenly becoming the industry standard. We are building invisible sandboxes not because we want to cripple the models, but because we desperately need a speed limit. We need the car to pause at the intersection so the instructor can check the mirrors. We have realized that the engine is already fast enough; what we lack is control.
If Activation Impedance is the real bottleneck, it completely changes the calculus for developer tooling.
The next billion-dollar dev tools won't be faster text-generation engines. They'll be better mirrors and passenger brakes. Look at GitHub Copilot Workspace. It's already pivoting away from pure text-expansion in your IDE into a steering and review dashboard. They are building interfaces designed explicitly to lower the Time-to-Verify, forcing the AI to show its intended trajectory before it floors the gas.
My guess?
In five years, we won't be talking about generation speed at all. The tooling wars will be entirely about who builds the best passenger brake.. assuming we're still in the car.