跪拜 Guibai
← All articles
Frontend · JavaScript

Stronger AI, Weaker Coders: The clearTimeout That Started It

By Mh ·
Read original on juejin.cn ↗ Google Translate ↗ Alt translation

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.

Summary

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.

Takeaways
— A debounce function written dozens of times previously still led to a blank on where `clearTimeout` belongs; the lapse ended with opening an AI chat.
— The core claim: AI doing more means the developer practices less, and coding ability comes from repeated doing, not from reading.
— Reading AI output and understanding it differs from producing it: recognition is not generation.
— AI code runs but carries hidden risks: redundancy, subtle flaws, and style mismatches, and developers without their own standards cannot judge it.
— The boundary that matters: AI substitution of repetitive, low-value work counts as efficiency; substitution of thinking, judgment, and understanding is where skill loss happens.
— The practice list includes thinking before asking, demanding explanations and trade-offs, rewriting core code from memory, keeping offline practice sessions, and verifying ownership of every AI code with three questions: can you explain it, name its edge cases, and know where to start debugging.
— The self-check: complete a common requirement offline, explain a recent AI code chunk line by line, and decide whether the first reaction to a bug is analysis or copy-pasting the error.
— Shift energy toward business understanding, trade-offs, architecture, and problem definition, where AI does not help.
Conclusions

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.

From the discussion
Featured comments
afumu

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.

See top comments, translated →
Source: juejin.cn ↗ Google Translate ↗ Backup ↗