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

Last week I ran an experiment: uninstall Claude Code, don't touch Codex, go back to writing code purely by hand, and stick with it for a full week. Not to prove anything, but because one day while coding I realized I couldn't even remember the callback parameter order for Array.reduce — something I used to be able to write with my eyes closed. That scared me.

Why I ran this experiment

Some background first. I started using Claude Code as my primary development tool at the beginning of this year, and I've also used OpenAI's Codex on and off. It's been about half a year now.

In those six months, my development efficiency really did improve a lot. Need a new component? Describe it in natural language in the terminal, and Claude Code generates the entire file. Write unit tests? One sentence — "fill in the test cases for this module" — and it's done in bulk. Encounter an unfamiliar API? No need to look through docs, just ask it directly. Even refactoring, debugging, writing documentation — it can handle the whole pipeline.

But last Wednesday, while on a high-speed train with no internet, I was writing a very simple data processing function:

const total = orders.reduce((  // I stopped right here

My mind went completely blank.

Is the first parameter of the reduce callback the accumulator or the current element? What about the second parameter? Where does the initial value go?

These things used to be muscle memory, no thinking required. But in that moment, without Claude Code to autocomplete for me, I was actually stuck.

It's not that I can't write code anymore, but I'm losing the ability to "write code without relying on AI."

This made me deeply uneasy. So I decided to turn off all AI programming tools and write purely by hand for a week, to see just how much I had degraded.

Experiment rules

• Uninstall Claude Code CLI
• No Codex, Copilot, or any AI coding agent
• Editor limited to VS Code's native features (variable completion, import paths, and other non-AI completions)
• Allowed to look up documentation, but cannot use ChatGPT / Claude to ask code questions
• Duration: one full work week, Monday to Friday

That week happened to have a moderately complex requirement: add a data export feature to a backend admin system, supporting CSV and Excel formats, with filter conditions and paginated export. Not trivial, but not particularly difficult either.

Day 1: Like going back to 2023

The biggest feeling on day one was — slow.

Not just a little slow. The kind of slow where you think, "how do I even need to think about this?"

Writing a React form component. Before, I'd say to Claude Code in the terminal, "write me a registration form with validation," and 30 seconds later the entire file would appear. Now I needed to:

1. Manually write the useState declarations
2. Manually write the onChange handler functions
3. Manually write preventDefault in onSubmit
4. Manually write the form validation logic

None of these steps are hard individually, but together they're just slow. Before, Claude Code could generate an entire component in half a minute; now I spent forty minutes handwriting it.

What made me more anxious was that I found myself frequently going back to look at previous code — not because I needed to understand business logic, but because I'd forgotten how to pass parameters to some utility function.

For example, the project's wrapped request function:

// I remember it was roughly like this, but I can't recall the parameter order
const res = await request('/api/export', {
  method: 'POST',
  // Is the second parameter config or data?
  // Which layer do headers go in?
});

Half a year ago, I was the one who wrote this wrapper. Half a year later, I need to dig through the source code to confirm how to use it.

Day 1 output: about 60% of what I'd normally finish in a day.

Day 2-3: The most painful phase

Day two and three were the hardest.

Not because I couldn't write code, but because my brain was constantly doing one thing: resisting the impulse to "open AI."

Every time I hit a spot that required two seconds of thought, my first reaction wasn't to think — it was to switch to the terminal and type claude. This reaction is unconscious, like how your hand automatically reaches for your phone when you want to look something up.

The habits formed by agent-type tools like Claude Code and Codex are even scarier — because they don't just "complete a line" for you, they "finish an entire task" for you. You don't even need to think about code structure; you just describe the requirement in natural language. This means once you leave it, it's not just that your typing slows down — you have to re-adapt to even "how to break down a task."

I counted: on Day 2 alone, I had 37 urges to open AI.

Roughly:

• 15 times because I forgot how to use some API (solvable by checking docs)
• 12 times because I didn't want to write boilerplate code (before, I'd just have Claude Code generate the whole file)
• 7 times because I encountered a problem that genuinely required thinking (these were the valuable ones)
• 3 times because I wanted AI to write a regex for me (regex really should be done with tools)

Interesting finding: out of 37 urges, only 7 were times I genuinely "needed" AI help. The other 30 were, essentially, laziness and habit.

By the afternoon of day three, something started to happen — my fingers began to "remember."

Writing useEffect, I no longer needed to think about parameter order. Writing fetch, the then chain flowed out naturally. Writing CSS Flex layouts, I no longer got stuck on whether justify-content or align-items was horizontal vs vertical.

These things hadn't been lost; they had just been "covered up" by AI's instant completions — you didn't need to retrieve them from memory, so their retrieval pathways weakened. But they were still there.

Day 2-3 output: recovered to 70-75% of normal.

Day 4-5: An unexpected discovery

By day four, something unexpected happened.

The quality of the code I wrote got higher.

Not a subjective feeling — objective metrics. I compared two pieces of code:

AI-assisted export module (a similar requirement from a month ago):

async function exportData(filters, format) {
  const data = await fetchAllData(filters);
  if (format === 'csv') {
    const csv = data.map(row => 
      Object.values(row).join(',')
    ).join('\n');
    downloadFile(csv, 'export.csv', 'text/csv');
  } else if (format === 'excel') {
    const wb = XLSX.utils.json_to_sheet(data);
    const workbook = XLSX.utils.book_new();
    XLSX.utils.book_append_sheet(workbook, wb, 'Sheet1');
    XLSX.writeFile(workbook, 'export.xlsx');
  }
}

Handwritten export module (this week):

type ExportFormat = 'csv' | 'excel';

interface ExportOptions {
  filters: FilterParams;
  format: ExportFormat;
  pageSize?: number;
  onProgress?: (percent: number) => void;
}

async function exportData({ filters, format, pageSize = 1000, onProgress }: ExportOptions) {
  const totalCount = await fetchCount(filters);
  const pages = Math.ceil(totalCount / pageSize);
  const allData: ExportRow[] = [];

  for (let page = 1; page <= pages; page++) {
    const chunk = await fetchPage(filters, page, pageSize);
    allData.push(...chunk);
    onProgress?.(Math.round((page / pages) * 100));
  }

  const exporter = exporters[format];
  exporter(allData);
}

const exporters: Record<ExportFormat, (data: ExportRow[]) => void> = {
  csv: (data) => {
    const headers = Object.keys(data[0]).join(',');
    const rows = data.map(row => 
      Object.values(row).map(v => `"${String(v).replace(/"/g, '""')}"`).join(',')
    );
    downloadFile([headers, ...rows].join('\n'), 'export.csv', 'text/csv');
  },
  excel: (data) => {
    const ws = XLSX.utils.json_to_sheet(data);
    const wb = XLSX.utils.book_new();
    XLSX.utils.book_append_sheet(wb, ws, 'Data');
    XLSX.writeFile(wb, 'export.xlsx');
  },
};

What's the difference?

1. Paginated export + progress callback: Won't pull all data at once and blow up memory when the dataset is large. The AI-generated version directly calls fetchAllData — it chokes on ten thousand records.
2. CSV value escaping: The handwritten version handles quote escaping (""); the AI version doesn't — exported CSV would misalign columns if data contains commas.
3. Type safety: The handwritten version has full TypeScript type constraints; the AI version is all any.
4. Extensibility: Uses an exporters object instead of if-else; adding a new format just requires adding one key.

Why is handwritten code higher quality?

Because when you write by hand, you think.

AI completions are so fast that you don't have time to consider "what edge cases do I need to think about here?" Claude Code and Codex are even more extreme — you don't even look at the code. You say, "write me an export feature," and the entire file appears. You glance at it, "yep, it runs," and move on.

But when handwriting, you're forced to slow down. Slowing down makes you think: what if the data is large? Are there special characters? Is it type-safe? How do I extend this for new formats later?

Speed is the enemy of code quality. AI makes you too fast.

Day 4-5 output: recovered to 85% of normal, but code quality was noticeably higher.

My conclusions

1. AI doesn't cause "skill degradation" — it causes "skill dormancy"

Those API parameter orders and syntax details haven't disappeared from your brain. They've just become slower to retrieve because they haven't been called upon for a long time. Three days after turning off AI, most of them came back.

But if a junior developer relies entirely on AI to write code from day one, they may never have built those memories in the first place. That's the truly dangerous scenario.

2. While AI completions "accelerate coding," they also "accelerate skipping thinking"

The most valuable part of writing code isn't hitting the keyboard — it's figuring out how to write it. AI compresses the "keyboard time" to near zero, but the side effect is that it also compresses the "thinking window."

3. I won't quit AI, but I've changed how I use it

After the experiment ended, I reinstalled Claude Code. But I made two adjustments:

Adjustment one: Handwrite core logic, use AI for boilerplate.

Code involving business decisions, data processing, and state management — I'll write by hand. Forms, lists, CRUD — repetitive code like that — I'll keep letting Claude Code or Codex generate.

Adjustment two: Reserve half a day each week for "no-AI coding time."

Just like athletes can't only train with machines, programmers also need regular "bare-handed" coding to keep foundational skills from atrophying.

Finally

I'm not telling you to turn off AI. It's 2026 — not using AI to write code will indeed get you left behind.

But I suggest you try this: turn off AI and write code purely by hand for one day.

You don't need a full week — just one day. See if you, like me, get stuck on reduce's parameter order.

If you do get stuck — don't panic. Your ability is still there. But it's a signal, reminding you to occasionally "detach from assistance" and practice.

How long has it been since you wrote complete code without relying on AI? Tell us in the comments.