Is AI Causing Memory Loss and Forgetfulness? What I Learned From Tracking My Usage

Feb 9, 2026

Cowrie

Dev @ Bswen

The Problem: I Can’t Remember What I Wrote Yesterday

When I started using AI tools like ChatGPT and Claude in my daily work, I noticed something alarming. I’d sit down at my desk in the morning, open a file I worked on yesterday, and draw a blank.

# Looking at yesterday's work
$ git log --oneline -1
b3f7a2d Implement user authentication flow

$ git show b3f7a2d --stat
 src/auth/login.tsx    | 45 +++++++++++++++++++++++++++++++++++++
 src/auth/utils.ts     | 28 ++++++++++++++++++++
 src/types/auth.ts     | 15 +++++++++++

I remember committing this code. I remember getting it working. But when my manager asked me to explain how the JWT validation works, I froze. I couldn’t explain code I allegedly wrote 24 hours ago.

This kept happening. I’d write a function with AI assistance, test it, deploy it, and then have zero recall of the implementation details the next day. I started feeling dependent on AI tools to re-solve problems I’d already tackled.

Then I found a study that explained exactly what was happening.

The Research: 83% Recall Failure

A recent study found that 83% of AI-assisted users couldn’t recall sentences they’d just written with AI help. Let me show you what this looks like in practice.

Here’s a typical workflow that causes memory loss:

1. Receive task: "Add user authentication"
2. Paste prompt into AI: "Implement JWT auth with refresh tokens"
3. Copy AI output into codebase
4. Run tests - they pass
5. Submit work
6. ❌ Next day: Can't explain how it works

I tracked my own usage for two weeks and found the same pattern. When I used AI from the start, my retention dropped dramatically:

Week 1: AI-first approach
- Tasks completed: 12
- Tasks I could explain next day: 2 (16%)
- Tasks requiring AI review to understand: 10 (84%)

Week 2: Manual-first approach
- Tasks completed: 11
- Tasks I could explain next day: 9 (82%)
- Tasks requiring AI review to understand: 2 (18%)

The difference was stark. When I started manually, I retained the solution. When I started with AI, I lost it.

Why This Happens: Cognitive Offloading

The mechanism behind this memory loss is called cognitive offloading. It’s not new to AI—we’ve seen this pattern before.

Historical examples of cognitive offloading:

Smartphones → We stopped memorizing phone numbers
Google      → We lost the ability to retain facts
GPS         → Our spatial navigation skills declined
AI          → We're outsourcing reasoning and problem-solving

When I solve a problem manually, my brain goes through this process:

1. Analyze the challenge
2. Retrieve relevant knowledge
3. Test mental models
4. Formulate solutions
5. Encode the memory

When AI handles steps 2-4, my brain skips the deep processing that creates lasting memories. The key insight: memory forms during struggle, not during solution delivery.

I experienced this firsthand when I tried to explain AI-generated code to a junior developer:

// AI-generated code I couldn't explain
export const validateToken = (token: string): boolean => {
  const decoded = jwt.verify(token, process.env.JWT_SECRET);
  return decoded.exp > Date.now() / 1000;
};

When they asked, “What happens if the token is expired?”, I hesitated. I knew the code worked—I’d tested it. But I couldn’t articulate the edge cases because I hadn’t thought through them myself. AI had done that thinking for me.

What I Tried: Different AI Usage Patterns

I experimented with different approaches to find what actually preserves memory while still using AI productively.

Approach 1: AI-First (Failed)

Workflow:
1. Receive task
2. Ask AI for complete solution
3. Copy-paste code
4. Run tests
5. Submit

Result: Could not explain work 24 hours later
Memory retention: ~16%

Approach 2: Draft-First, Enhance-Later (Success)

Workflow:
1. Receive task: "Implement rate limiting"
2. Sketch solution manually (10 minutes)

   // Pseudo-code draft
   - Track requests per IP
   - Store in Redis with TTL
   - Check count before processing
   - Return 429 if over limit

3. Write initial implementation myself
4. Use AI to review, optimize, catch edge cases
5. Read AI suggestions carefully
6. Implement selectively
7. Write brief summary of approach

Result: Could explain work weeks later
Memory retention: ~82%

Here’s what the draft-first approach looked like in practice:

// My initial manual draft
interface RateLimitStore {
  check: (ip: string) => Promise<boolean>;
  increment: (ip: string) => Promise<void>;
}

// Basic implementation I wrote myself
class RedisRateLimit implements RateLimitStore {
  async check(ip: string): Promise<boolean> {
    const count = await redis.get(`rate:${ip}`);
    return count ? parseInt(count) < 100 : true;
  }

  async increment(ip: string): Promise<void> {
    await redis.incr(`rate:${ip}`);
    await redis.expire(`rate:${ip}`, 60);
  }
}

Then I used AI to enhance:

// AI suggested improvements I implemented:
// 1. Sliding window instead of fixed window
// 2. Distributed locking for race conditions
// 3. Configuration limits per endpoint

class EnhancedRateLimit implements RateLimitStore {
  async check(ip: string, limit: number): Promise<boolean> {
    const now = Date.now();
    const window = await redis.zrange(`rate:${ip}`, now - 60000, now);

    return window.length < limit;
  }

  async increment(ip: string): Promise<void> {
    const now = Date.now();
    await redis.zadd(`rate:${ip}`, now, `${now}:${uuid()}`);
    await redis.zremrangebyscore(`rate:${ip}`, 0, now - 60000);
  }
}

Because I’d written the initial draft myself, I understood:

• Why rate limiting was needed
• What approach I was taking
• What tradeoffs I was making
• Why AI’s suggestions were improvements

Two weeks later, I could still explain the sliding window algorithm and why it beats fixed windows.

Practical Strategies That Work

Based on my experiments, here are the approaches that preserve memory while maintaining AI productivity gains.

Strategy 1: Draft First (5-10 Minutes)

Before touching AI, I sketch the solution myself:

Task: Implement caching layer

Manual draft (7 minutes):
- Use Redis as cache store
- Cache key pattern: resource:id
- TTL: 5 minutes for user data, 1 hour for static
- Cache-aside pattern
- Invalidations on updates

Only then do I ask AI: "Review my caching approach and suggest improvements"

This short manual drafting forces my brain to engage with the problem before AI takes over the optimization work.

Strategy 2: Active Review of AI Output

I never copy-paste blindly. Instead:

# Process for reviewing AI-generated code
1. Read AI output line by line
2. Explain aloud what each section does
3. Identify what's different from my approach
4. Ask: "Why did AI suggest this?"
5. Implement selectively, not wholesale

# Example: AI suggests this
const memoize = (fn) => {
  const cache = new Map();
  return (...args) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
};

Instead of just pasting it, I’d walk through:

• Why use Map instead of object? (Key can be any type)
• What’s the weakness? (JSON.stringify on objects)
• When would this fail? (Circular references)

This active engagement creates memory encoding.

Strategy 3: The 70/30 Rule

I aim for 70% manual work, 30% AI enhancement:

Task breakdown:
- 70%: Core logic, structure, problem-solving (manual)
- 20%: Optimization, edge cases, refactoring (AI-assisted)
- 10%: Boilerplate, repetitive code (AI-generated)

What I avoid:
- Letting AI write core business logic from scratch
- Using AI for tasks I'm still learning
- Copy-pasting without understanding

Strategy 4: Weekly AI-Free Sessions

I dedicate 20% of my coding time to AI-only work:

Weekly schedule:
Monday: AI-free deep work (2 hours)
  - Solve complex problems manually
  - Implement core features without assistance
  - Strengthen mental models

Tuesday-Friday: AI-enhanced productivity
  - Use AI for code reviews
  - Leverage AI for optimization
  - Apply AI to documentation

Strategy 5: Documentation for Future Self

I keep brief summaries of AI-assisted work:

# Rate Limiter Implementation

Date: 2025-01-15
AI used: Yes - for sliding window optimization

My approach: Fixed window counter
AI improvement: Sliding window with Redis sorted sets

Why AI's approach is better:
- Handles burst traffic more smoothly
- No sudden resets at window boundaries

Key implementation detail: ZADD with timestamp scores

When I revisit this work months later, the summary jogs my memory faster than re-reading the code.

Common Mistakes I Made

Here’s what I learned to avoid:

Mistake 1: Starting with AI immediately
I used to paste prompts without thinking first.
Result: Worst memory retention

Mistake 2: Blind acceptance of AI output
I didn't read or understand AI-generated content.
Result: No memory formation

Mistake 3: No manual drafting
I jumped straight to AI assistance.
Result: Skipped cognitive work that builds expertise

Mistake 4: Over-reliance on autocomplete
I let tools complete everything.
Result: Reduced active problem-solving

Mistake 5: No documentation
I failed to keep records of AI-assisted work.
Result: Future recall impossible

Why Memory Matters for Developers

I initially thought, “Who cares if I remember? I can just ask AI again.” But I learned that memory is the foundation of expertise:

Memory enables:

1. Expertise development
   - You can't become senior without retained experience
   - Pattern recognition requires stored mental models

2. Problem-solving innovation
   - Past solutions inform future approaches
   - Analogies come from remembered examples

3. Communication and collaboration
   - Explaining your work requires remembering it
   - Teaching others demands internal knowledge

4. Interviews and meetings
   - You must discuss work without AI assistance
   - Whiteboarding requires recall, not generation

5. Code reviews
   - Recognizing issues needs remembered patterns
   - Spotting bugs requires retained experience

When I rely on AI to re-solve problems I’ve already tackled, I’m not building expertise—I’m building dependency.

Summary

In this post, I investigated whether AI causes memory loss through cognitive offloading. I tracked my own usage patterns and found that AI-first approaches led to 84% forgetfulness, while manual-first approaches preserved 82% retention.

The key point is drafting first before using AI helps preserve memory formation. When I sketch solutions manually before engaging AI, my brain forms memories through active problem-solving. AI then enhances rather than replaces my thinking.

The solution isn’t to avoid AI—it’s to use AI as an enhancement tool, not a replacement for cognitive work. By drafting manually, engaging actively with AI output, and maintaining regular AI-free practice, I can leverage AI’s productivity benefits while preserving memory and cognitive sharpness.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

• 👨‍💻 MIT Study on ChatGPT
• 👨‍💻 Reddit Discussion

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags:

• ai
• performance

Long-Term Effects of AI on Brain Development: What Parents and Developers Should Know

Does Using ChatGPT Reduce Brain Activity? What the MIT Study Actually Found