Stronger AI, Weaker Coders: The clearTimeout That Started It
A few days ago I ran into a small thing: I needed to write a debounce function. My hands were already on the keyboard, but for a moment I couldn't remember which line clearTimeout should go on. I froze for a few seconds, and in the end I opened the AI chat box.
This incident itself is minor, but it made me uneasy. I've written this function dozens of times; in the past I could type it out with my eyes closed. When did it become something I "need to ask about"?
Conclusion first
AI getting stronger and us getting weaker aren't contradictory; the two are two sides of the same thing: The more AI does for us, the fewer opportunities we have to practice ourselves.
Programming ability is built through practice, not "learned by watching." AI quietly takes away the "practice" step, leaving only "acceptance."
How ability quietly erodes
1. Missing the process of writing from scratch
In the past, when faced with a requirement, we had to break down the problem ourselves, look up information, try and error, debug, and finally write it out. This process was slow, but every step built a connection of "problem → solution."
Now it is: describe the requirement → get code → looks fine → commit. The most valuable "thinking and trial-and-error" in the middle is skipped. It's like watching cooking videos: no matter how much you watch, you'll still be flustered when you cook yourself.
2. Mistaking "understanding" for "knowing how"
AI-written code is usually well-written and reads smoothly. So we get the illusion: I understood it all, so I know how to do it.
But being able to read and being able to write are two completely different abilities. Reading requires only recognition; writing requires generating from a blank page. A person who can read an English article doesn't necessarily mean he can write an article of the same quality.
3. Losing the experience of being stuck
When encountering a bug, in the past we'd be stuck for a long time: adding logs, setting breakpoints, guessing causes, verifying. This painful stuck-ness is exactly what trains the ability to locate problems.
Now we habitually throw errors directly at AI and have answers within seconds. The problem is solved, but the understanding of "why it happened" isn't built. Next time we hit a similar problem, we can only ask again.
4. Memory and feel are degrading
API spellings, details of common patterns, parameters of certain tools — these "muscle memories" formed by repeated use no longer need to be memorized since we can ask at any time.
This seems harmless in daily work, but when the network is down, AI gives wrong answers, or during an interview, whiteboard session, or urgent online incident, lacking these foundations leaves you very passive.
5. Judgment is being diluted
The most dangerous point: we gradually lose the standard for judging whether code is good.
AI code mostly "runs," but isn't necessarily reasonable: it may have redundancy, hidden risks, or be inconsistent with project style. Without enough accumulation of our own, it's hard to spot these problems, and we can only choose to trust. When you can't evaluate the output, you've essentially handed over the decision rights.
Does this mean AI shouldn't be used?
No.
After calculators appeared, nobody practiced large-number pen calculation anymore, but mathematicians didn't disappear; they put their energy into more important problems. Same with AI — boilerplate code, repetitive work, queries to unfamiliar APIs: it's reasonable to hand these to AI.
The real problem isn't "use or not," but: which part we let AI replace.
- Replacing repetitive, low-value parts: no problem, that's efficiency.
- Replacing thinking, judgment, understanding parts: that's where ability loss happens.
How to use AI as an amplifier
Below are several approaches I've tried that work for me.
1. Think first, then ask
Before asking AI, spend a few minutes thinking of an approach yourself, even a rough one. Then compare your plan with AI's; the differences are the most valuable learning points.
2. Let AI explain, not just give answers
Don't just ask "how to write it"; ask more "why write it this way," "are there other options," "what are the trade-offs." Treat it as a patient teacher, not a code vending machine.
3. Rewrite important code yourself
For core logic, after reading AI's implementation, close the window and write it yourself from understanding. Places you can't write are places you haven't truly mastered.
4. Keep time for "bare writing"
Each week set aside a little time, turn off AI, and complete a small feature or work through a few problems. The goal isn't efficiency; it's maintaining the feel, just as athletes don't stop running because they have a car.
5. Own every piece of AI code
Before committing, ask yourself three questions: Can I explain this code clearly to a colleague? What are its edge cases? If it breaks, do I know where to start investigating? If you can't answer, you don't yet "own" this code.
6. Shift energy to higher-level abilities
AI is good at writing implementations but not at understanding business, weighing trade-offs, designing architecture, or defining problems. These abilities are exactly where investment is now more worthwhile. Writing code has become cheap, and knowing "what to write and what not to write" has become more valuable.
A simple self-check
If you want to know whether you're "regressing," try this:
- Without network, can you independently complete a common requirement?
- Pick a random piece of recent AI code you committed — can you explain it line by line?
- When you hit a bug, is your first reaction to analyze, or to copy-paste the error?
If the answers make you a little uneasy, no need to be anxious. It just means it's time to adjust how you use these tools.
Summary
AI has made "producing code" unprecedentedly easy, but "becoming a good developer" hasn't become easier — it's just hard in a different way.
The stronger the tool, the more we need to stay clear-headed: Don't let AI think for us; let it type for us. Treat it as an amplifier and your ability gets amplified; treat it as a crutch and after a while your legs really can't walk.
I just rewrote that debounce function by hand. This time, I remembered where clearTimeout goes.
Top 1 from juejin.cn, machine-translated. The original thread is authoritative.
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.