Stronger AI, Weaker Coders: The clearTimeout That Started It
Reliance on AI for routine work erodes the judgment and muscle memory that still matter when the network drops, a whiteboard or interview session starts, or AI returns a subtly wrong result. The cost also shows up in review and debugging: code that runs but nobody can defend is a liability Western engineering teams are already paying for.
Frozen hands at the keyboard, unable to recall which line `clearTimeout` should sit on in a debounce function — the moment ended in an AI chat. That lapse, after dozens of prior writes of the same function, frames a broader trade-off: every task handed to AI removes one round of practice, and coding skill is built from doing, not from watching clean output scroll by. Reading AI code and understanding it counts as recognition, not generation, and instant bug answers skip the stuck-and-debugging experience that builds the ability to locate problems. Judgment goes next: code that runs but carries redundancy, hidden risks, or style mismatches escapes notice without an internal standard.
Countermeasures in the source: sketch a rough approach before asking AI and compare the two, demand explanations and trade-offs instead of answer strings, rewrite important code with the window closed, schedule offline practice, and run a three-question ownership check before committing any AI code. The endpoint is a transfer of attention upward — AI handles implementation, and the expensive skill becomes knowing what to write, what not to write, and why.
The prescribed countermeasures — thinking first, rewriting from memory, offline practice — all slow output, which collides with the speed metrics most engineering teams operate under; the real investment here is a personal one.
Interviews, whiteboards, and emergency incidents are the moments where skills surface, and they show the concern reaches beyond day-to-day productivity into being assessed without AI, which is a different standard from being effective with AI.
The bright-line split between repetitive work and thinking work assumes those categories are visible in advance; eroded judgment is precisely what blurs that line.
My feeling isn't that my ability has gotten weaker — it's that the debugging muscle is atrophying. Previously, when I hit a panic, I'd read the stack trace and binary-search with comments; now my first reaction is to paste the whole block back to the AI and let it fix it. By the fourth round, I can't remember what the code originally looked like. Recently, I've imposed a self-discipline: separating 'generation' from 'understanding'. Generation can be delegated to it, but when something goes wrong, I must first locate the exact line myself; if I can't locate it, it's not allowed to touch it. If I hold this line, I'm still the author; if I don't, I become a reviewer — and reviewing is far more tiring than creating.