Biological Packet Loss
AI coding assistants cripple productivity because their latency shatters cognitive flow, turning skilled creators into exhausted editors of mediocre code.
By Frank Osei
Sparked by Ask HN: Is anyone experimenting with different ways of using LLMs for coding? · discussion
Everyone is lying about AI velocity. The executives are currently high-fiving in boardrooms over brightly colored charts displaying raw output going reliably up and to the right. It looks like a corporate miracle. It looks like we just found the holy grail of software development, where you can feed a loosely written Jira ticket into a machine and watch senior-level code pop out the other side at lightspeed.
Meanwhile, on the ground, your best humans are staring at their screens with a quiet, teeth-grinding misery. Brutal reality. Business is noisy with the confident assumption that these tools make us profoundly faster. The raw truth sitting inside your engineering department is that nobody wants to admit the magic autocomplete is slowly driving them insane.
I was reading a thread on Hacker News recently where an engineer perfectly articulated the visceral reality of relying on these systems, describing the experience as exactly like "riding a bicycle that brakes abruptly." They are pedaling furiously, building massive momentum, and the machine repeatedly locks the wheels. Let’s wind the clock back to understand exactly why this systemic friction is breaking your team.
Let us divide the engineering population into a deliberate binary. First, we have The Artisan. This is your top performer operating deep in The Zone. To understand The Artisan, you must understand that the brain operates as a highly optimized, single-threaded processor with an incredibly fragile L1 cache.
When they are deep in a complex problem, they are holding a massive, invisible architecture of dependencies, edge cases, and future logic purely in their working memory. It is a precarious house of cards built out of sheer cognitive willpower. They know exactly where the database call needs to happen. They know why the third variable in that obscure function is a boolean. They are essentially compiling the entire application in their frontal lobe before they even touch the keyboard. As Joel Spolsky observed decades ago regarding the catastrophic cost of dropping and rebuilding this mental state, "task switches take a really, really, really long time."
When a developer is typing, they are executing what we will call The Cognitive Event Loop. The interaction between fingers, keyboard, and screen functions as a continuous feedback cycle. As long as the system responds within the legendary Doherty Threshold—meaning the computer and human interact at a pace (<400ms) that ensures neither has to wait—the loop hums flawlessly. Even if we stretch the grace period, basic human-computer interaction guidelines dictate that 1.0 second is about the limit for the user's flow of thought. Inside that boundary, context remains unbroken. The human feels completely invincible.
Enter the modern AI coding assistant. This is a heavy, invasive piece of machinery. It parses the file, sends a network request, calculates probabilities, and forces a three-to-five-second pause to generate a substantial block of code.
This is a catastrophic, synchronous blocking I/O call inserted violently into the middle of a highly optimized event loop. Hard stop.
What happens during those four seconds of latency? The brain utterly hates being idle. It trips the irrelevance flag. The developer thinks, Wait, why are we stopped? Let me just check Slack… and they are gone. Or maybe they just stare at the blinking cursor, forcing their mind to idle at maximum RPM while praying for the network response to render.
The exact moment that context switch executes, the L1 cache dumps. The invisible architecture collapses into the ether. This is Biological Packet Loss.
When the AI finally finishes generating its payload, the developer must painstakingly rebuild their mental state from scratch to evaluate a block of logic they could have written faster themselves. Dead time. The physiological debt of this constant start-and-stop disruption is staggering. Research from Gloria Mark explicitly demonstrates that knowledge workers try to compensate for interruptions by working faster, but this comes at a price—specifically, more stress, higher frustration, and immense time pressure. By forcing this latency into their workflow, you have aggressively increased their psychological load to the point of structural failure. When the tool halts their workflow for the fiftieth time before lunch, the internal monologue of your top performer reaches an irrational breaking point: I JUST WANTED TO WRITE A FOR-LOOP AND NOW I HAVE FORGOTTEN THE ENTIRE DATABASE SCHEMA.
Stripped of their cognitive momentum, The Artisan undergoes a miserable mutation into our second archetype: The Dispatcher.
The Dispatcher has a fundamentally different job description. They sit there passively waiting, reviewing, and untangling half-baked algorithmic output. The Dispatcher functions as an exhausted middle-manager of mediocre code. They burn all their background processing bandwidth verifying that a machine didn't confidently hallucinate a non-existent API method or quietly introduce a race condition.
This is exactly why your top performers are profoundly cranky. You took a creator who thrives on forward momentum and turned them into a cynical editor of synthetic spam. An Artisan wants to architect a beautiful, robust system. A Dispatcher just wants to clear the queue, appease the metrics dashboard, and go home.
The empirical proof of this fatigue is already manifesting in our repositories. Look at the brutal data from GitClear, which highlights disconcerting trends for maintainability. Code churn is accelerating globally. The result is a mountain of technical garbage. We are reverting significantly more buggy logic because our Artisans are too mentally fatigued from endless context-switching to care. They see a block of generated code, it looks roughly correct, and they hit merge. The system slowly rots from the inside out.
Wait, Frank Osei, the tooling is still early. The executive suite told me this is a mandate. These engineers are just stubbornly resisting the inevitable future of development.
No. Let me translate this raw emotion into a mechanical system for you.
Your best people are resisting because you strapped a massive latency penalty directly to their primary mechanism of creation. The friction here is entirely biological. It stems directly from the sheer cognitive toll of dropping context fifty times an hour to babysit a predictive text engine.
Productivity is unbroken human focus. Lines of generated code are a meaningless distraction. Anything that disrupts the Cognitive Event Loop is an active, aggressive threat to your team's sanity and your product's stability.
Stop looking at the raw output metrics and start looking at the glazed-over eyes in your weekly one-on-ones. Listen to the humans. When you ask them how the new tools are working, pay attention to the hesitation, the deep sigh, and the tired admission that they spend half their day fixing subtle hallucinations.
As a manager, your mandate is singular. Relentlessly protect The Zone. If the tool is breaking the bicycle, you must give them permission to turn the damn thing off. Leaders lead. Turn the noise off.