Your Brain Has a Garbage Collector — And It's Deleting Your Vocabulary Right Now

The Real Reason You Keep Forgetting Vocabulary (It's Not What You Think)

You studied 30 words last Monday. You reviewed them again on Tuesday. You felt good.

By Friday — gone. Maybe 8 words left. Maybe less.

Here's the counterintuitive truth that changes everything: you don't have a memory problem. You have a scheduling bug.

The vocabulary isn't disappearing because your brain is weak. It's disappearing because your brain is doing exactly what it was designed to do — running a garbage collector on information it has no reason to keep.

Hermann Ebbinghaus figured this out in 1885. His finding has been replicated in hundreds of studies since. And it explains, precisely, why every vocabulary method you've tried has failed — and what the fix actually looks like.

This is the Ebbinghaus Forgetting Curve, explained the way developers actually think.

What is the Ebbinghaus Forgetting Curve? The Ebbinghaus Forgetting Curve describes how memory retention decays exponentially over time without reinforcement. Discovered by Hermann Ebbinghaus in 1885 and replicated in hundreds of studies since, it shows that within 24 hours of learning something new, the brain discards roughly 67% of it — unless a timely review interrupts the decay cycle. (Last updated: July 2026)

What the Forgetting Curve Actually Tells You

In 1885, German psychologist Hermann Ebbinghaus spent years memorizing and testing himself on thousands of nonsense syllables. He was the subject and the researcher. What he found — later named the Ebbinghaus Forgetting Curve — remains one of the most replicated results in all of cognitive science.

The pattern:

Within 24 hours, two-thirds of what you studied is gone. Within a week, three-quarters.

This isn't a flaw. Your brain treats unreinforced memories as low-priority cache entries and prunes them to conserve energy. The brain consumes ~20% of the body's energy while being only 2% of its weight. Aggressive garbage collection is a feature, not a bug.

The second finding is the one that changes everything: each time you successfully recall something before it's fully forgotten, the forgetting curve resets — but at a shallower slope. The memory becomes progressively more resistant to decay with each retrieval.

In other words: the fix is not studying more. The fix is timing your reviews correctly.

The Software Analogy: Memory as a Distributed Cache

Think of your long-term memory as a distributed cache with an aggressive garbage collector running on a schedule you can't directly observe.

interface MemoryEntry {
  item: string;
  ttl: number;        // Time To Live — days until GC prunes it
  strength: number;   // Resistance to garbage collection
  lastReviewed: Date;
}

function onSuccessfulRecall(entry: MemoryEntry): void {
  // Each recall resets TTL and increases resistance to pruning
  entry.ttl = entry.ttl * entry.strength;
  entry.strength = entry.strength * 1.3;  // SM-2 ease factor equivalent
  entry.lastReviewed = new Date();
}

function onFailedRecall(entry: MemoryEntry): void {
  // Failed recall: back to 1-day TTL, strength floor at 1.3
  entry.ttl = 1;
  entry.strength = Math.max(entry.strength * 0.75, 1.3);
}

Without intervention, the GC runs and removes the entry. Every time you recall before the GC fires, you extend the TTL and increase strength — so the next safe window gets longer.

This is the core mechanic of spaced repetition: schedule the review at the last viable moment before the GC would run.

Not immediately after learning (too early — the recall is effortless and barely strengthens the memory). Not after you've already forgotten (too late — the GC already ran). Exactly at the inflection point.

Why Most Study Methods Are Scheduling Bugs

Here's the bug in most vocabulary study approaches, written as code:

// ❌ What most apps and study habits do
function scheduleNextReview(word, daysSinceStudied) {
  return "tomorrow"; // Fixed interval, ignores memory state entirely
}

// ❌ What cramming does
function crammingSchedule(wordList) {
  // Review everything in one session regardless of individual recall
  return wordList.map(word => reviewNow(word));
  // Result: strong short-term retention, near-zero retention at 1 week
}

The bug: fixed-interval review treats all vocabulary as equivalent, regardless of how well you actually know each word. You review words you've already mastered too frequently (wasted time) and words you keep forgetting not frequently enough (they disappear).

// ✅ What spaced repetition does
function scheduleNextReview(word, recallPerformance, currentEaseFactor) {
  if (recallPerformance < 0.6) {
    return 1; // Failed recall: review again tomorrow
  }

  // Successful recall: interval grows exponentially per ease factor
  const nextInterval = Math.round(word.lastInterval * currentEaseFactor);
  return nextInterval;
}

// A word consistently rated "Good" with default ease factor 2.5:
// Day 1 → Day 2 → Day 7 → Day 18 → Day 45 → Day 112 → Day 280...

// A word consistently forgotten (ease factor drops to floor of 1.3):
// Day 1 → Day 1 → Day 1 → Day 1... (daily until recalled correctly)

Spaced repetition is the patch for the scheduling bug. Personalized review timing, per-word, based on actual recall performance — not a fixed calendar.

The SM-2 Algorithm: The Scheduler That Implements the Fix

Modern spaced repetition uses SM-2 (SuperMemo 2), developed by Piotr Woźniak in 1987. The algorithm is deceptively simple.

Every vocabulary item has two values:

After each review, you rate your recall on a 0–5 scale. The algorithm updates both values:

A word consistently rated "Good" (EF stays at 2.5):

Day 1 → Day 3 → Day 8 → Day 21 → Day 53 → Day 132 → Day 330...

A word consistently struggled with (EF drops to 1.3 floor):

Day 1 → Day 1 → Day 1 → Day 1...  ← stays daily until you actually learn it

The key insight: SM-2 doesn't let you graduate a word you haven't actually learned. It's honest about recall in a way fixed schedules never are. If you find this concept interesting, see our deep-dive into the SM-2 algorithm and how spaced repetition actually works →

The Counterintuitive Part: Struggling to Remember Is the Mechanism

Here's what trips up most developers when they first encounter spaced repetition:

The harder the recall, the stronger the memory it creates.

Cognitive scientists call this the desirable difficulty effect (Bjork, 1994). When retrieval is easy — you just reviewed the word yesterday — the recall is almost effortless. Your brain barely strengthens the memory trace because there was nothing hard about the retrieval.

When retrieval is effortful — you haven't seen the word in three weeks and have to really search — the struggle is expensive, and the memory strengthens significantly as a result.

# Simplified model of memory strengthening from retrieval effort
def memory_strengthening(recall_effort: float) -> float:
    """
    recall_effort: 0.0 (effortless) to 1.0 (maximum struggle)
    returns: memory_strength_gained (non-linear — struggle is disproportionately effective)
    """
    return 0.3 + (0.7 * recall_effort ** 0.5)

# Easy recall — reviewed yesterday
easy = memory_strengthening(0.1)   # → 0.52  (minimal strengthening)

# Effortful recall — not seen in 3 weeks
hard = memory_strengthening(0.8)   # → 0.93  (near-maximum strengthening)

The practical implication: when a word feels hard to recall, that's not failure — that's the mechanism working. The struggle is what builds durable memory. Skipping hard words or marking them "easy" to feel productive defeats the entire system.

This is also why Wordrop doesn't let you review words before their scheduled interval. The timing isn't arbitrary — it's calibrated to maximize the recall effort at exactly the right moment.

Why This Matters for Technical Vocabulary Specifically

Developers learning English or Japanese for work face a unique version of this problem.

Technical vocabulary — deprecate, refactor, idempotent, regression, throughput — tends to appear in clusters: during code reviews, in API documentation, in standup meetings. You encounter a word intensely for a week, then it disappears from your context for a month.

Without deliberate review scheduled to the forgetting curve, that technical vocabulary follows the same decay pattern as everything else:

Read "idempotent" in docs → understand it → 
don't see it for 3 weeks → 
encounter it in a PR review → blank → 
look it up again → feel frustrated

This loop has nothing to do with intelligence. It has to do with the absence of a review scheduled before the GC fired.

The fix: treat technical vocabulary the same way you treat code dependencies. You don't wait until a library breaks to check it — you maintain it proactively. The same logic applies to vocabulary.

If you want a practical approach to building vocabulary around your workflow, see how developers learn vocabulary without disrupting their workday →.

The Optimal Review Schedule (Based on the Forgetting Curve)

If you were to design the review schedule manually — without an algorithm — this is what the research says it should look like for a word learned from scratch:

Notice: each interval gets longer as the ease factor accumulates. After 5–7 successful reviews across 3–6 months, a word reliably persists with only occasional reinforcement.

This is the compounding effect. It's the same reason compound interest outperforms lump-sum investing over time — small, consistent actions at the right intervals produce exponentially better outcomes than large, irregular efforts.

The Engineering Principle

One sentence summary of everything above:

Review just before the forgetting threshold — not immediately after learning, not long after forgetting, but precisely at the point of maximum desirable difficulty.

A well-tuned spaced repetition system maintains 85–95% vocabulary retention with 10–20 minutes of daily review. Traditional study methods at 10× the time investment produce 20–40% retention.

The difference isn't effort. It's scheduling.

Your brain has a garbage collector. The forgetting curve describes its schedule. Spaced repetition is the caching strategy that runs reviews before the GC fires — so vocabulary stays accessible instead of being pruned.

If you're ready to see how spaced repetition actually applies to language learning as a developer →, the next step is understanding how to build this into your daily workflow without it becoming another thing to manage.

Try spaced repetition in Wordrop — built for developers →

Frequently Asked Questions

Is the Ebbinghaus Forgetting Curve still considered valid today?

Yes. The exponential decay pattern has been replicated in hundreds of studies across different materials, languages, populations, and time scales since 1885. The exact retention percentages vary based on material difficulty and individual differences, but the exponential decay shape and the memory-strengthening effect of timed retrieval are among the most robust findings in cognitive science.

Why doesn't the brain just retain everything it encounters?

Energy conservation. The brain consumes approximately 20% of the body's energy despite being only 2% of its weight. Keeping all encoded information active would be metabolically unsustainable. The garbage collector — forgetting — is a deliberate optimization, not a failure mode.

If I know about the forgetting curve, why am I still forgetting words?

Because knowing about the curve doesn't generate a review schedule. The forgetting curve tells you what happens. A spaced repetition algorithm tells you when to review. Without automated scheduling, you're relying on willpower to review at precisely the right intervals — which consistently fails under real workload conditions.

How many reviews does a word need before it's in long-term memory?

With SM-2, approximately 5–7 successful reviews across 3–6 months. Once a word reaches a review interval of 60+ days and maintains high recall accuracy, it's reliably in long-term memory with minimal ongoing maintenance needed.

Does spaced repetition work for technical English vocabulary or just general words?

It works especially well for technical vocabulary because technical terms have clear, discrete definitions — exactly the question-answer pair format that SRS is optimized for. Idempotent, throughput, regression, deprecate — these all have unambiguous meanings and benefit significantly from scheduled retrieval practice.

Why do I feel like I "know" a word during review but can't produce it in conversation?

Recognition and production use different retrieval pathways. SRS that tests only in one direction (foreign word → native translation) builds recognition. Active production — native translation → foreign word, or using the word in a sentence — requires deliberately training both directions. Wordrop's Reverse Recall mode addresses this specifically.