What Spaced Repetition Is Actually For

I have a confession. I bought a second-brain app last year. It had spaced repetition built in. The algorithm scheduled my reviews. The cards never came back. I checked the streak counter once, felt vaguely proud, and then I stopped opening the app at all.

Spaced repetition is one of the most well-validated findings in the entire cognitive science literature — the spacing effect was first documented in 1885, and the testing effect has hundreds of replication studies behind it. The science is not in doubt. The reason it didn't work for me had nothing to do with the science, and everything to do with the container I was putting the cards in.

If you've ever set up an Anki deck and abandoned it, or downloaded a flashcard app and watched the review queue balloon past 200 cards you didn't have time for, this post is for you. The problem isn't you. It's the unit.

Why an index card forces the right kind of small

Spaced repetition only works when each item is small enough to fit on one card. That's the constraint. Not because the algorithm requires it — modern SRS systems will happily schedule a 4,000-character "card" for review. The constraint is cognitive. Your working memory holds roughly four chunks at a time. If a card holds more than one idea, you'll remember the card, not the idea.

An index card is small because the medium is small. You can't put a paragraph on one. You can't put a paragraph-sized idea on one without choosing to compress it, and the act of choosing to compress is itself the learning. The card is the constraint that does the work.

Most apps skip this step. They give you a note with unlimited length, and an SRS layer that schedules it for review. So you write a 500-word note, paste in three sub-ideas, and a week later you remember that you wrote something about velocity but you can't remember which of the three sub-ideas was the load-bearing one. The review fires. You click "good." You've now cemented the wrong memory.

The forgetting curve is a feature, not a bug

Ebbinghaus showed in 1885 that memory decays exponentially without reinforcement. The half-life of an un-reviewed fact is roughly a day. That's not a flaw in your brain. It's a feature: forgetting is what makes pattern recognition possible. If you remembered every detail of every sentence you'd ever read, you couldn't think.

Spaced repetition works by exploiting the curve. Review just before you forget, and the half-life stretches. Review at the moment of forgetting, and you get the maximum strengthening for the minimum effort. Review too early, and you've wasted time re-learning what you already knew. Review too late, and you've started over.

The catch: the algorithm only works if you trust it. If you peek at the card when the queue is empty, you reset the schedule. If you mark "hard" because you're anxious instead of because you actually couldn't retrieve it, you teach the system to show you that card more often than it should. The card is honest. The interface between you and the card has to be honest too.

What goes wrong with note-app SRS

Three patterns, in my own experience and in everyone I've talked to about this. First, the card gets too long. You write what you meant to remember, and it grows. By the third review it's a paragraph. By the tenth you've stopped reading it carefully — you skim for keywords and click "good."

Second, the review queue loses its meaning. When the algorithm is scheduling dozens of cards a day, the queue feels like email. You triage. You mark a stack as "good" to clear the inbox. The cognitive load of actually retrieving each one — the actual learning event — never happens. You've turned the SRS into a checklist.

Third, the cards live in a silo. The thing you wanted to remember doesn't connect to anything else you know. A spaced repetition deck for Spanish vocabulary works because the words connect to each other — you can compose with them. A spaced repetition deck for "facts from a book I read" doesn't connect to anything. It dies with the book.

The card is the constraint that makes the system honest

If the unit of review is one card, and the card is small enough that you can hold it in your head, then every review is either a real retrieval or it isn't. There's no skimming. No "I remember the gist." Either the word comes back, or it doesn't. Either the formula resolves in your head, or it doesn't.

This is why physical flashcard systems lasted as long as they did, and why the people who used them learned faster than the people who didn't. The medium enforced the discipline. You couldn't put more on a card than fit on a card. You couldn't skip a review without losing the card from the deck. The constraint was the system.

An app can replicate this only if the app imposes the constraint. Most don't. They give you a card that holds 50,000 characters, and they call it a card. The medium is lying. The user is the one who has to do the constraint work. Most users don't. Most decks die.

What this looks like in NoteDex

Every card in NoteDex is one card. That's not a tagline — it's the schema. The card has a title (the question, the cue, the thing you're trying to remember) and a body (the answer, the resolution, the thing that should come back when you see the title). When the title surfaces in review mode, the body is hidden. You have to retrieve it.

Because the card is the unit, you can do something the big-note apps can't: you can connect a card to other cards. The connection has to mean something. It's either a reference, a contradiction, or a contrast. You can't connect a card to a paragraph. You wouldn't know what part of the paragraph you were connecting to.

And because the card is small, you can carry a deck of them in your head the way you carry a deck of physical flashcards in your pocket. Twenty cards on a project. Twelve cards on a book's argument. Six cards on the architecture of a system you're learning. The deck is the unit of knowledge. The card is the unit of memory.

How to start (if you've abandoned an SRS before)

Start small. One deck. Twenty cards. Pick something you actually want to remember in a month — a project, a paper, a person's work. The cards should be answerable in under thirty seconds. If a card takes longer, split it.

Write the cards by hand first. Even if you plan to type them, the act of writing forces you to compress. You'll find out which cards you actually have an answer for and which ones are just topics you think you understand. Throw out the ones you can't fill in from memory.

Then schedule reviews at increasing intervals. Day one, three, seven, fourteen, thirty. If you can answer the card at day thirty, you own it. If you can't, the schedule resets, and that's the right answer — you didn't actually know it yet. The system is honest. Trust it.

The goal isn't to know more cards. It's to know more things that you can retrieve on demand, in context, when you need them. Twenty cards you actually own is worth more than two thousand you clicked through.

What spaced repetition is actually for

Spaced repetition is for the things you want to keep. The names you want to remember without checking. The formulas you want to use without deriving. The arguments you want to be able to deploy in a meeting without re-reading the paper. The architecture of the system you work in, so you don't have to look up the diagram every time you change a file.

It's not for everything. It's not for ideas you're still forming — those need space, not compression. It's not for facts you can look up faster than you can recall them. It's for the things where the cost of forgetting is higher than the cost of the review.

Pick those things. Make a deck. Keep it small. Let the cards be cards. Trust the schedule. Review when the system says to. Mark "got it" when you actually got it, and "missed it" when you actually missed it. The forgetting curve is on your side — every honest review stretches the half-life. The system works. The unit just has to be honest too.

The takeaway

Spaced repetition is one of the most validated findings in cognitive science, and one of the most underused, because most apps that offer it don't enforce the constraint that makes it work. The constraint is the size of the card. A card that fits in your head is a card you can review honestly. A card that holds more than one idea is a card you'll skim and forget.

If you've abandoned an SRS before, the failure probably wasn't the algorithm. It was the unit. Try a smaller unit. One card per idea. One card per fact. Twenty cards you actually own, instead of two thousand you clicked through. The system works. The unit has to match the science.