Spaced repetition: what it is and how to apply it to lessons and code

Spaced repetition in plain terms

Spaced repetition is a technique in which you return to what you have learned after increasing gaps of time. Not five times in one evening, but once today, a second time in a day or two, a third time after several days, a fourth after a week or two. The intervals grow because each successful review keeps the knowledge for longer.

The second key feature is that the review is active. You do not reread your notes or rewatch the video. You try to recall: answer a question, write the code from memory, explain the idea in your own words. The effort of recall is what makes the review useful. So if someone asks "what is spaced repetition", the precise answer is: active recall spread across a calendar.

The forgetting curve: why everything fades without review

The method rests on an observation made by Hermann Ebbinghaus in the late 19th century: forgetting does not happen evenly. Right after learning, we lose material quickly, and then more and more slowly. If you plot the share of material still in memory against time, you get a curve that drops steeply in the first hours and days and then levels off. That is the forgetting curve.

Two practical conclusions follow. First, the most dangerous period is the first day or two after a lesson. If nothing is done during that time, most details disappear. Second, each review "resets" the curve, but with a flatter decline. After several successful reviews, knowledge lasts for weeks and months.

Why "I watched it and understood" is not the same as "I remember it"

After a good video lesson, everything feels clear. That feeling is misleading: the brain confuses recognition with understanding. When you see familiar code on screen, you recognize it, but that does not mean you can write it yourself. It is like studying a route map instead of making the trip: you think you know the way, and at the first junction you find out otherwise.

Passive watching barely sends the brain a signal that something is important, so the information stays in short-term memory. Spaced repetition solves both problems: it makes you recall, which tests real knowledge rather than recognition, and it does so at the moment memory has started to weaken.

Why spaced repetition beats repeating in one go

Cramming before an exam is familiar to everyone: in one evening you can load a lot, and it even works the next day. But a week later little remains. Repetitions done back to back happen while the material is still fresh, so you barely have to recall anything. There is no effort and no strengthening.

When there is a gap between reviews, some of the material fades. Recalling becomes harder, and this useful difficulty makes the brain rebuild and strengthen the links. That is why one review after three days gives more than three reviews in the same evening. The only caution is not to wait too long: if the material is forgotten completely, you have to learn it again.

The basic spaced repetition schedule

There are no exact "correct" intervals: they depend on how complex the material is and how easily you recalled it last time. But a simple growing schedule is a good start. Count from the day you studied the topic.

The flexibility rule: if you recalled something easily, you can lengthen the next interval. If you struggled or could not recall it, shorten the interval and come back sooner. Apps work the same way, but they calculate intervals automatically.

Spaced repetition for programmers

Programming is a skill, not a set of facts. Flashcards of "definition and answer" are not enough: you need to review by doing. A useful three-step pattern for each new topic:

1. Day 1: reproduce from memory. After the lesson, close the video and write the code you saw yourself. You may peek, but mark each hint: those are the places to review.
2. Day 3: change it. Take the same code and modify it: a different condition, different data, an extra check. This tests understanding rather than mechanical memory.
3. After a week: a new task. Solve a problem where the topic is needed but not named. This trains you to recognize when a technique applies.

Example: bubble sort

Say the lesson covered bubble sort. Day 1: you study the algorithm and watch the implementation. Day 2: you write it from scratch without hints.

def bubble_sort(items):
    n = len(items)
    for i in range(n - 1):
        for j in range(n - 1 - i):
            if items[j] > items[j + 1]:
                items[j], items[j + 1] = items[j + 1], items[j]
    return items

Day 5: you change the function to sort in descending order and add an early exit if a pass makes no swaps. Day 12: you apply the same pairwise-comparison idea to a new task, for example sorting a list of dictionaries by a field. Each step is harder than the last, and by the end of the second week the topic is no longer "familiar" but yours.

What to review and what not to

Review what you will actually use: language syntax, key constructs, commands you need every day, principles such as working with collections or queries. Do not turn everything into cards, for example rare function parameters that are easier to look up in the documentation. A useful filter: "Do I want to be able to do this without searching?"

Applying spaced repetition to video lessons

A video course is easy to turn into a review system while you watch. Pause after each meaningful block and record three things: the main idea in your own words, an example from the lesson, and your own question. These notes become the material for reviews.

• Phrase questions so you can answer them without hints: "how does a list differ from a tuple", "how do I undo the last commit without losing my changes".
• For code, note the task rather than the code: "write a function that removes duplicates while keeping the order".
• Quizzes and self-check questions after lectures are ready-made review material: go through them again a few days later without opening the lesson.

If a topic does not come back at all, rewatch only the relevant fragment, not the whole lesson. A review should be short: 10 to 20 minutes covering several topics.

Spaced repetition apps

The best-known tool is Anki, a free flashcard app that calculates when to show each card. You rate how easily you recalled the answer, and the app lengthens or shortens the interval. Other programs use the same principle, such as SuperMemo, where many of the spaced repetition algorithms began.

Tips for programmer flashcards:

• One card, one idea. "What does git stash do" is better than "all git commands".
• Ask about application: "how do I get the last 3 items of a list" rather than "what is a slice".
• Add task cards: "write a function that...", and check the answer by running the code.
• Do not accumulate hundreds of cards at once: the daily queue should fit in 15 to 20 minutes, or you will quit.

A manual schedule: a calendar instead of an app

If you do not like flashcards, a regular calendar is enough. A useful analogy for developers: spaced repetition is committing knowledge, the calendar is your version control, and regular review sessions are merging new knowledge into the main base. Without review, what you learned remains uncommitted changes that are easy to lose.

How to keep a manual schedule:

1. As soon as you finish a topic, create 3 to 4 calendar events: in one day, in 3 days, in a week, in 2 to 3 weeks.
2. Write a concrete task in each event, not "review Python". For example "solve 2 recursion problems", so the result is measurable.
3. Group topics into blocks with tags (#python_basics, #git, #sql) and review related topics together, so connections form between them.
4. For each session, use the Pomodoro technique: 25 minutes of work and 5 minutes to review what worked, what did not and when to come back.

If a review did not happen, move it to the nearest day rather than cancelling it. Missing one review is not a problem; abandoning the chain is.

Common mistakes

• Rereading instead of recalling. Reading notes creates the same feeling of recognition as a video. Try to answer first, then check.
• Reviewing everything equally often. Easy topics can have long intervals; spend your time on the hard ones.
• Reviewing without practice. For code, review means writing code. Knowing syntax without a task does not turn into a skill.
• A queue that is too big. If reviews take an hour a day, the system will not survive. Fewer topics, reviewed regularly, is better.
• Reviewing with the phone in your hand. Distractions break focus, and recall becomes a formality.

Summary

Spaced repetition is active recall at growing time intervals. It rests on the forgetting curve: material is lost fastest in the first days, and each review from memory slows the forgetting. For a programmer, the best format is to review through code: write it from memory, change it, apply it to a new task. The tools can be Anki or a plain calendar with concrete tasks. How to build reviews into watching video lessons is covered in practice in the course "How to learn effectively from video courses".