I've Been Writing Code with AI for Half a Year — Looking Back, These 5 Abilities Are Atrophying

Since the beginning of this year, I've been using Claude Code or Cursor to write code almost every day. Efficiency has definitely improved — a CRUD page that used to take half a day now gets done in twenty minutes.

But something recently made me alert: a colleague asked me the difference between Promise.allSettled and Promise.all, and I opened my mouth, only to find I needed to "think about it" before answering. Two years ago, I could have answered that instantly.

It's not that I've gotten dumber. It's that I handed this muscle over to AI to exercise for half a year, and it has atrophied.

A recent study by Anthropic gave a concrete number: developers who heavily rely on AI programming tools scored 17 percentage points lower in independent debugging and code reading ability than the manual coding group. A report from the American Psychological Association this year also pointed out that over-reliance on generative AI reduces critical thinking and job-specific skills.

A new term even appeared on The Register: "AI Atrophy" — skill atrophy caused by AI.

I spent a weekend taking stock of my own changes. The following 5 degradations are the most noticeable.

1. Debugging Ability: The First Reaction to Bugs Has Changed

Before, when I encountered a bug, my process was: read the error message → locate the file → set a breakpoint → check the call stack → find the cause.

Now? When I see a red squiggly line, my first reaction is to copy the error and give it to AI.

// Before: I would read this error and think about why
// Type 'string | undefined' is not assignable to type 'string'
// → Oh, maybe the optional chain returned undefined, need to provide a default value

// Now: directly throw it to AI
// "Help me fix this TypeScript error"
// AI instantly replies: just add ?? ''
// Me: Oh okay, next

The problem isn't whether AI's answer is right — most of the time it is. The problem is that I skipped the step of "understanding why the error occurred."

Skip this step for half a year straight, and your mental model of the type system becomes blurry. Before, you could intuitively judge "there might be a null value here"; now you have to wait for TypeScript to report an error before you know.

Self-test method: Next time you encounter a TypeScript error, don't ask AI first; read the error message yourself. If you find you can't understand it — that's a signal of atrophy.

2. Code Reading Ability: Reading Others' Code Has Become Harder

Before, when reviewing a colleague's PR, I would read line by line, think about edge cases, consider performance.

Now? Opening a 200-line component, my first reaction is to have AI summarize it for me.

// Before, reviewing this code, I would notice the problem
function useDebounce(value, delay) {
  const [debouncedValue, setDebouncedValue] = useState(value);
  
  useEffect(() => {
    const timer = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);
    return () => clearTimeout(timer);
  }, [value, delay]);
  
  return debouncedValue;
}

// Problem: when delay changes, the timer resets, potentially causing it to never trigger
// Before, I could spot this problem at a glance
// Now, I need to "think about it" to realize it

That "17% lower code reading ability" in the Anthropic study is exactly this. It's not that you can't understand the syntax; it's that the density of active thinking while reading code has decreased.

You've gotten used to having AI summarize code and explain logic, and your own "reading muscle" is atrophying. Just like someone who takes a taxi every day suddenly finds they don't remember the route.

Self-test method: Find an open-source project you haven't participated in, randomly open a core module, and read for 15 minutes. If you find yourself frequently thinking "this is complicated, let AI explain it" — that's a signal of atrophy.

3. Ability to Build from Scratch: Can't Start Without a Template

Now, without using create-next-app, without AI, starting a React project from an empty folder — can you do it?

# Do you still remember what you need to start from scratch?
mkdir my-app && cd my-app
npm init -y
npm install react react-dom
npm install -D webpack webpack-cli webpack-dev-server
npm install -D babel-loader @babel/core @babel/preset-react
# Then what? How do you write webpack.config.js?
# entry, output, module rules, devServer...
# Do you still remember?

I found I don't remember. Before, I could write these with my eyes closed; now I need to check the docs.

It's not that you should manually set up every time — scaffolding tools exist to save time. But knowing how the underlying layer works and not knowing are two different things.

When your create-next-app throws a strange build error, someone who knows the underlying principles can locate the problem; someone who doesn't can only ask AI and hope for the best.

Self-test method: Try to manually set up a minimal React development environment without any scaffolding. If you find you need to look up even the basic structure of webpack.config.js — that's a signal of atrophy.

4. API Memory: Need to Ask AI Even for Common Methods

// Can you still write these without looking them up?

// Array deduplication
[...new Set(arr)]  // or Array.from(new Set(arr))? Both work

// Deep copy
structuredClone(obj)  // Do you still remember this API? Or would you write JSON.parse(JSON.stringify())?

// Date formatting
new Intl.DateTimeFormat('zh-CN', { 
  year: 'numeric', month: '2-digit', day: '2-digit' 
}).format(date)  // Or just ask AI directly?

// URL parameter parsing
const params = new URLSearchParams(window.location.search)
params.get('id')  // Do you still remember URLSearchParams?

// Array grouping (ES2024)
Object.groupBy(items, item => item.category)  // Do you know this one?

This isn't a memory problem. It's that you no longer need to remember these — asking AI is ten times faster than browsing MDN. But the cost is: your mastery of the JavaScript standard library has gone from "at your fingertips" to "know there's such a thing but need to look it up."

The fluency while writing code is gone. Before, writing code felt as natural as speaking; now it feels like translating — you know what you want to do, but need AI to help "translate" it into specific API calls.

Self-test method: Open an empty file, without looking anything up, write a function: accept a URL string, return an object of all query parameters. If you get stuck on the usage of URLSearchParams — that's a signal of atrophy.

5. Solution Design Ability: No Longer Thinking About Architecture Yourself

This one is the most subtle, and the most dangerous.

Before, when encountering a new requirement, I would first go through it in my head: what does the data flow look like for this feature? Where does the state go? How to split components? Should I use Context or a state management library?

Now? Directly tell AI the requirement and let it produce a solution.

// Previous thought process
// Requirement: build a data table supporting filtering, sorting, and pagination
// My thinking:
// 1. Put filter and sort state in URL params (easy to share/retain on refresh)
// 2. Manage data with React Query (caching + automatic refetch)
// 3. Use cursor-based pagination instead of offset (better performance for large datasets)
// 4. Separate table component and data logic (hook manages data, component only handles rendering)

// Current "thought process"
// → "Help me build a data table supporting filtering, sorting, and pagination"
// → AI directly outputs 500 lines of code
// → I see it runs, so I use it

The solution AI produces isn't necessarily bad. But you skipped the process of "thinking about why it's done this way." Next time you encounter a similar requirement, you still won't know whether to use cursor pagination or offset pagination, and you'll still need to ask AI.

Technical solution design ability is unlike writing code — it requires continuous judgment, mistakes, and corrections in real scenarios to build intuition. Hand this process over to AI, and your "technical intuition" stops growing.

Self-test method: Try to draw (on paper, without looking at anything) the frontend architecture diagram of your current project — data flow, state management, API call layer, component hierarchy. If you can't draw it — it's not because the architecture is complex, but because you haven't truly thought about it.

Ability Atrophy Self-Test Checklist

Ability	Atrophy Signal	Self-Test Method
Debug	Encounter error, ask AI first without reading the message	Next error, read it yourself first
Code Reading	Look at PR and think "let AI summarize it"	Read a core module of an open-source project for 15 minutes
Build from Scratch	Don't know how to start without scaffolding	Manually set up a minimal React dev environment
API Memory	Need to ask AI for common methods	Write a URL parameter parsing function without looking anything up
Solution Design	Directly throw requirements to AI	Draw your current project's architecture diagram on paper

Not Telling You to Quit AI

Let me be clear: I'm not saying AI shouldn't be used. AI has saved me countless hours over the past half year, that's a fact.

What I'm saying is: AI is an exoskeleton, not a replacement organ.

Wearing an exoskeleton lets you lift 200 kilograms, but your own muscles need to be able to lift at least 40 kilograms. Otherwise, one day the exoskeleton malfunctions — network down, API down, or you need to write code in an environment where AI can't be used — you're done.

The large-scale banning of domestic accounts by overseas AI programming tools last month is still fresh in memory. Those developers who completely relied on AI suddenly found they "couldn't write code anymore."

Spend 2 hours a week writing code without AI. It doesn't need to be much. Just like fitness doesn't require going every day, but requires maintaining frequency. Keep your "programming muscles" from atrophying.

How long have you been writing code with AI? Have you noticed similar atrophy?