跪拜 Guibai
← All articles
Frontend · JavaScript · AI Programming

A Week Without AI Coding: What Actually Degrades and What Comes Back

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

Heavy AI coding tool use doesn't erase knowledge, but it weakens retrieval speed and compresses the thinking window that produces robust, edge-case-aware code. The risk is highest for junior developers who may never form those memories in the first place.

Summary

After half a year of using Claude Code and Codex as primary tools, a developer found they could no longer recall the parameter order of `Array.reduce` — something that used to be muscle memory. That moment triggered a one-week experiment: uninstall all AI coding tools, write everything by hand, and track what happened.

The first three days were slow and uncomfortable. Output dropped to 60% of normal, and the developer logged 37 urges to open AI in a single day — only 7 of which involved genuinely hard problems. The rest were laziness and habit. By day three, dormant knowledge began returning; syntax and API details resurfaced once retrieval pathways were exercised again.

Days four and five brought a surprise: handwritten code was measurably better than AI-assisted code written for a similar feature a month earlier. The hand-built export module included pagination, progress callbacks, proper CSV escaping, full TypeScript types, and an extensible exporter registry — all things the AI-generated version skipped. Slowing down forced the kind of edge-case thinking that AI's speed suppresses.

Takeaways
— After six months of heavy AI coding, the developer blanked on `Array.reduce` callback parameter order — a sign of retrieval atrophy, not permanent loss.
— Day 1 output fell to 60% of normal; the slowdown came from forgotten utility-function signatures and the sheer friction of handwriting boilerplate.
— On Day 2, the developer counted 37 impulses to invoke AI; only 7 involved genuinely difficult problems, the rest were habit and aversion to boilerplate.
— By Day 3 afternoon, dormant syntax knowledge began returning — `useEffect` parameter order, `fetch` chains, Flexbox axis rules all resurfaced.
— Handwritten code on Days 4–5 was objectively better than a comparable AI-generated module: it included pagination, progress callbacks, CSV quote escaping, full TypeScript types, and an extensible format registry.
— AI-assisted code skipped edge cases entirely — it fetched all data at once with no escaping, used `any` types, and hardcoded format branches.
— Speed is the enemy of code quality: AI completions are so fast they eliminate the pause where a developer considers boundary conditions and extensibility.
— The developer reinstalled Claude Code afterward but now handwrites core business logic and reserves half a day per week for no-AI coding.
— Junior developers who never build syntax and structure memories without AI face a deeper risk — they may never form the mental models that experienced developers can recover.
Conclusions

The experiment distinguishes between skill loss and skill dormancy: retrieval pathways weaken from disuse, but the knowledge itself persists and returns within days of deliberate practice.

Only 7 of 37 AI impulses involved genuine problem-solving; the rest were muscle-memory avoidance of boilerplate and documentation lookup — tasks that are tedious but not cognitively demanding.

The quality gap between AI-generated and handwritten code is not about intelligence but about pacing. AI removes the natural pause where edge-case thinking occurs, producing superficially correct code that fails under real-world data conditions.

Agent-style tools like Claude Code and Codex compound the problem beyond line-completion tools: they replace task decomposition itself, so the developer loses practice in breaking down requirements — a higher-order skill than syntax recall.

The developer's new workflow — core logic by hand, boilerplate by AI, plus a weekly no-AI session — mirrors how athletes mix machine-assisted and unassisted training to maintain foundational strength.

Concepts & terms
Skill dormancy vs. skill degradation
A distinction drawn in the experiment: knowledge like API signatures doesn't disappear from memory under heavy AI use, but its retrieval speed drops sharply because the recall pathway is never exercised. Degradation would mean the knowledge is gone; dormancy means it's still there and returns with practice.
Agent-type AI coding tools
Tools like Claude Code and Codex that accept natural-language task descriptions and autonomously generate entire files or features, as opposed to line-completion tools like early Copilot. They remove not just typing but task decomposition — the mental step of breaking a requirement into code structure.
Thinking window compression
The observation that AI's speed eliminates the natural pause during coding where a developer considers edge cases, type safety, extensibility, and failure modes. The result is code that runs but lacks robustness.
From the discussion

The core tension is whether deliberately returning to manual coding is necessary self-discipline or pointless self-punishment. One side argues that preserving the feel of writing code from scratch sharpens code taste and prevents atrophy into a prompt-only puppet. The opposing view holds that AI is simply the next abstraction layer, no different from pasting snippets or leaning on autocomplete, and that fighting it is a form of needless hustle culture. A lighter thread runs through the comments: the uneasy illusion of competence AI creates, where a Flutter dev suddenly feels like a cross-platform expert.

— Manual coding practice preserves code taste, programming mindset, and the sensitivity needed to catch issues during AI code review.
— Resisting AI assistance is unnecessary self-imposed pressure when the career span is already short and AI is just another tool.
— Pre-AI workflows already relied heavily on copy-paste, autocomplete, and documentation rather than memorizing syntax, especially for polyglot developers.
— AI creates a deceptive sense of mastery, making specialists feel falsely proficient across unfamiliar platforms and stacks.
— Daily development has already shifted so far that returning to fully manual coding feels nearly impossible.
Featured comments
用户2970241317327 1 likes

I also think maintaining the feel of ancient-method programming is absolutely necessary. Ancient-method programming effectively consolidates code taste and programming mindset, making you more sensitive to potential issues when reviewing AI code. You have to constantly be on guard against being hollowed out by AI, becoming a puppet who can only press Enter to code. (DMT, I used to be able to use three keys, now I only know how to use one)

kyriewen

Haha, before it was Ctrl C V, now only Enter is left

用户9380793098154 2 likes

Is this really necessary? You can't do this job for many years anyway. You stop using AI and now you start rolling up on yourself again

kyriewen

Haha, occasionally my hands get itchy and I practice a bit [lightbulb moment]

用户9380793098154  → kyriewen

Sigh, hang in there buddy

金钟罩 1 likes

There's nothing to be afraid of. Even without AI coding, I was always copying and pasting old code, or relying on auto-suggestions plus docs and search. I could never remember the details anyway. Because I need to span 4 or 5 languages, from hardware interfaces all the way to front-end UI, there's simply no way to memorize that much syntax.

kyriewen

Big shot, crossing languages with zero foundation must be tough, right? [lightbulb moment]

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