Home / University / Module 06 / Article

When AI Forgets: Recovery Patterns

Module 06: Context Window Mastery | Expansion Guide

Back to Module 06

The Problem

You're 30 messages deep. Earlier, you told the AI you're using PostgreSQL. Now it's suggesting MongoDB queries. You explained your auth system uses JWT. Now it's writing session middleware. You showed it your error handling pattern. Now it's inventing a new one.

The AI didn't forget. It's drowning in context.

Long conversations create information overload. Old details get deprioritized. Contradictions emerge. The AI starts treating suggestions from message 5 as facts by message 25. You're no longer collaborating - you're debugging the AI's confusion.

The Core Insight

Context degradation is inevitable. Detection and recovery are skills.

Human conversations work because both parties remember the important stuff and forget the noise. AI treats everything as potentially important. After 20 messages about authentication, middleware, database queries, and error handling, the AI can't tell what matters anymore.

The best developers don't try to prevent context loss. They detect it early and reset cleanly.

Detection Signals

Early Warning Signs (Recovery Window: High)

Medium Degradation (Recovery Window: Medium)

Critical Degradation (Recovery Window: Low)

The Overconfidence Trap

When context degrades, AI often becomes MORE confident, not less. It fills gaps with plausible-sounding fabrications. Never trust confidence level - verify against your codebase.

Recovery Patterns

Pattern 1: Targeted Re-grounding

When to use: Early degradation. AI lost track of one specific thing.

How: Re-inject the critical context explicitly.

# AI suggested MongoDB, but you're using PostgreSQL
"Quick reminder: This project uses PostgreSQL, not MongoDB.
Here's the current schema: @db/schema.sql
Now, back to adding that feature..."

Why this works: Reinforces one fact without throwing away the entire conversation.

Pattern 2: Checkpoint and Reset

When to use: Medium degradation. Multiple things are confused.

How: Summarize progress, then start fresh chat with summary as context.

# In old chat:
"Let me summarize what we've built:
1. JWT auth in @middleware/auth.js
2. User routes in @routes/users.js using auth middleware
3. PostgreSQL schema in @db/schema.sql
4. Error handling pattern: custom AppError class

Next step: Add password reset functionality"

# Copy that summary to NEW chat:
"Project context:
[paste summary from above]

Let's implement password reset following these patterns."

Why this works: Fresh context window with only essential information. No noise from failed attempts.

Pattern 3: Hard Reset with Artifacts

When to use: Critical degradation. AI is actively harmful.

How: New chat. Attach key files. Zero carryover from old conversation.

# New chat with file attachments:
@middleware/auth.js
@db/schema.sql
@ARCHITECTURE.md

"I need to add password reset. Here's the current state."

Why this works: Complete context reset. AI starts from known-good state.

Pattern 4: The Correction Loop

When to use: AI keeps making the same mistake despite corrections.

How: Explicit, numbered corrections with verification.

"Three corrections:
1. We use 'userId' not 'user_id' (camelCase, not snake_case)
2. Auth tokens go in cookies, not headers
3. Errors return {error: string}, not {message: string}

Confirm you understand these three rules before proceeding."

Ask for confirmation. Forces AI to process corrections before continuing.

Prevention Tactics

Tactic 1: Proactive Session Splitting

Don't wait for degradation. Plan resets:

Tactic 2: Periodic Summaries

Every 10-15 messages, summarize state:

# Your message:
"Quick checkpoint - here's what we've done:
- Created Payment model
- Added payment routes
- Implemented Stripe integration

Current state: Working on error handling for failed payments"

This re-anchors the AI to facts.

Tactic 3: Context Documents

Create a SESSION_CONTEXT.md file that travels across resets:

# SESSION_CONTEXT.md
## Tech Stack
- Node.js + Express
- PostgreSQL with Knex
- JWT auth in cookies

## Patterns
- Error handling: AppError class, centralized handler
- API responses: {data, error} structure
- Validation: Joi schemas in @middleware/validation.js

## Completed
- User authentication
- Basic CRUD for posts
- File uploads to S3

## Next
- Add commenting system

Include this in new chats. Instant re-grounding.

The Golden Rule

If you spend 3+ messages correcting AI, you've already lost. Reset the session. Fighting degradation wastes more time than starting fresh.

Recognizing False Degradation

Sometimes the AI is right and you're wrong. Signs you're misdiagnosing:

Verification test: Ask AI to explain its reasoning. If it cites specific details from your codebase, it's not degraded - it's informed.

Tool-Specific Recovery

Claude (Desktop/Web)

Cursor

Claude Code (CLI)

Quick Reference

Detection Checklist:

Recovery Decision Tree:

  1. One thing confused? → Targeted re-grounding
  2. Multiple confusions? → Checkpoint and reset
  3. Completely lost? → Hard reset with artifacts
  4. Same mistake 3x? → Correction loop with verification

Prevention Schedule:

Emergency Reset Template:

# New chat message:
"Project: [name]
Stack: [key technologies]
Current files:
@file1.js
@file2.js

Goal: [what you're building now]

Constraints:
- [pattern 1]
- [pattern 2]

Let's proceed."