Don't Blindly Follow Ebbinghaus: Pitfalls in Learning Algorithms and Alternatives

Why I Stopped Worshipping the Ebbinghaus Curve

2 years ago, when I first built a vocabulary app, I chose the Ebbinghaus forgetting curve as the review algorithm without a second thought. It's in every textbook, has a clear mathematical formula, and looks the most "scientific."

A month after launch, user retention dropped by 40%.

It wasn't the curve's fault. It was my misuse. Ebbinghaus's original experiments used nonsense syllables, but I applied it to real words—words with semantics, context, and roots, which are far easier to remember. The algorithm kept pushing reviews based on the original decay curve, causing over-reviewing and annoying users.

Three Fatal Flaws of the Ebbinghaus Algorithm

Flaw 1: Fixed Time Windows Ignore Individual Differences

The Ebbinghaus curve assumes the forgetting rate is identical for all people and materials. In reality, a word might be new for a beginner but merely confirmation for an advanced learner. Using the same time window either overwhelms beginners or bores advanced users.

Example comparison:

Fixed time windows force all users down the same forget curve—unsatisfying for everyone.

Flaw 2: No Handling of "Already Known"

The Ebbinghaus algorithm is purely time-driven: remind at the scheduled time. It doesn't consider how well the user knows the content.

If a user correctly recalls an item at the first review, SM-2 or Leitner would double the interval. Ebbinghaus doesn't—it sticks to the original plan. The user gets asked to review something they already know, wasting time and patience.

Flaw 3: No Difficulty Feedback

Real learning materials vary in difficulty. "Apple" and "ephemeral" are worlds apart. The Ebbinghaus formula has no difficulty parameter—all items are treated equally.

This means users spend lots of time reviewing easy words while truly hard words get reviewed infrequently.

Alternatives: Comparison of Three Mainstream Algorithms

Leitner System

The simplest manual spaced repetition system. Users prepare several boxes, each with a different review frequency. Correct answers move up a box; incorrect answers move down.

Pros: Intuitive, no computation needed, works for paper cards or simple apps. Cons: Fixed number of boxes, large interval jumps, no individual adaptation.

SM-2 (SuperMemo 2)

Piotr Wozniak's classic algorithm introduces a quality rating (0-5) to adjust intervals and difficulty.

Pros: Adapts to individual performance, intervals grow exponentially with correct answers, proven by Anki and others. Cons: Subjective quality rating; different users rate differently; algorithm is sensitive to rating fluctuations.

**Pseudocode example (TypeScript):**
```typescript
function calculateNextReview(
  quality: number, // 0-5
  repetitions: number,
  previousInterval: number,
  easinessFactor: number
) {
  if (quality < 3) {
    repetitions = 0;
    return { interval: 1, ef: easinessFactor };
  }

if (repetitions === 1) {
    return { interval: 1, ef: easinessFactor };
  } else if (repetitions === 2) {
    return { interval: 6, ef: easinessFactor };
  } else {
    const interval = Math.round(previousInterval * easinessFactor);
    return { interval, ef: easinessFactor };
  }
}

### FSRS (Free Spaced Repetition Scheduler)

A newer algorithm that uses a machine learning model to predict forgetting probability based on user review history, dynamically adjusting intervals.

**Pros:** No user rating needed; automatically learns user memory patterns; high accuracy.
**Cons:** Complex implementation; requires enough historical data (typically >100 reviews) to converge.

## Decision Framework for Algorithm Selection

I later built a simple decision tree:

```text
1. **Does the user need to manually mark mastery?**
   - Yes: Use Leitner (simple) or SM-2 (precise)
   - No: Use FSRS (automatic)

2. **Is the data volume sufficient?**
   - <100 items: Use SM-2 or Leitner
   - ≥100 items: Consider FSRS

3. **Is the product a tool or content?**
   - Tool (e.g., vocabulary app): Recommend SM-2 + difficulty tagging
   - Content (e.g., article reading): Recommend FSRS or custom interval strategy

Engineering Practice Tips

1. Don't Push All Reviews at Once

Many developers compute all pending reviews and push them in one batch. This causes cognitive overload. The right approach is to show 5-10 items at a time, and load more only after finishing the current batch.

2. Allow Manual Skipping

No algorithm is perfect. Provide a "skip/already known" button and record that action as a negative sample in the algorithm.

3. Separate Difficulty from Intervals

Don't mix "difficulty" and "interval." Difficulty is an input parameter; interval is an output. In SM-2, I recommend splitting difficulty into two independent factors:

• Semantic difficulty (root, frequency)
• User historical performance (accuracy, reaction time)

4. Cold Start Strategy

For new users with no history, use a conservative default interval set (e.g., 1d, 3d, 7d, 14d). Collect data from the first 10 reviews, then switch to the main algorithm.

Final Judgment

There is no silver bullet for learning algorithms. The Ebbinghaus curve deserves respect as a theoretical foundation, but using it directly as a product algorithm will likely backfire.

My current practice:

• For small products, use SM-2 (proven for over a decade in Anki)
• With enough data, fine-tune with FSRS
• Always keep a manual override interface for users

Algorithms are the engine; the product is the car. A great engine means nothing if the ride is uncomfortable.

PaxLee