Question

I failed my 12 week FAANG prep plan because I skipped recursion — and it broke everything after it.

What I figured out, in retrospect

• The order topics appear in a 90 day plan isn't cosmetic. It's load-bearing in a way you only notice when you violate it.
• "Stay on schedule" is the worst advice for a prep plan. It treats the plan as the goal rather than the prep.
• Dependency order means recursion before backtracking before DP. Skipping a layer doesn't save a week. It costs four.
• The right response to a slow topic isn't to skip it. It's to extend the plan and let the next topic move faster on top of solid foundations.
• Productive struggle and spinning look identical from the inside. They have opposite prescriptions.

Where the approach was breaking

The Week 7 mistake was treating recursion as a topic to cover rather than a prerequisite to internalise. The recursion videos were watched. Four or five recursion problems were solved with the explanation sitting next to them. With the explanation gone, reproducing the same trace from a blank screen wasn't possible. Arrays could be written from scratch. Recursion could only be followed.

The Week 7 plan said this was fine because the topic could be revisited later. Then Week 8 arrived, and Week 8 was backtracking. Backtracking is recursion with state restoration. The first backtracking problem stalled on the recursive structure, which had supposedly already been covered. Week 9 was graphs. Graphs use recursion for DFS. Stalled again. By Week 10, every new topic was failing on the same earlier gap, and the gap was getting harder to fix because there was less time.

The plan didn't fail at any specific topic. It failed at one decision: the moment a slow week got treated as a scheduling problem rather than as the plan signalling what needed to keep building.

What changed on the second attempt

The shift was simple to describe and slow to absorb. Two rules:

Old rule	The rule that replaced it
If a topic is slow, push through to stay on schedule.	If a topic is slow, extend the plan by exactly the time the topic needs. The total prep time often ends up the same.
If a topic is covered once, it's covered.	A topic is covered when you can produce the core pattern from a blank screen, with no reference, in roughly the time an interview gives.
Practise without a timer until you're "ready" to add pressure.	Add a timer at Week 6. The pressure is the practice, not a test of it.
Skipping a topic costs you one week.	Skipping a topic costs you four. Backtracking, graphs, and DP all sit on top of recursion.

Once Week 7 stopped being a scheduling problem and started being the plan saying to slow down on recursion, the rest of the plan started working. The total prep extended by one week. The extra week paid back twice over because backtracking and graphs moved faster, not slower, when recursion was solid.

What that looked like on the next problem

The problem that finally made it click was a simple recursive enumeration: generate all subsets of an array. The textbook solution had been seen before. Recursion with two branches at each index, include or exclude the current element, base case when the index reaches the end. Reading it was easy. Writing it from a blank screen wasn't.

I sat with the problem for a full afternoon, no walkthrough, no reference. Four wrong attempts came out. The fifth attempt looked like this:

def subsets(nums):
    result = []

    def helper(index, current):
        if index == len(nums):
            result.append(current[:])
            return
        # exclude nums[index]
        helper(index + 1, current)
        # include nums[index]
        current.append(nums[index])
        helper(index + 1, current)
        current.pop()

    helper(0, [])
    return result

The fifth attempt wasn't just correct. It was the first time the role of current.pop() made sense: the recursive call mutates current for its own subtree, and the parent frame needs the mutation undone before its own next branch fires. Once that explanation came together, every backtracking problem in Week 8 fell into place. The N Queens problem, the permutations problem, the parentheses generation problem, all the same shape with different state restoration.

That afternoon ate one of the "scheduled" study days. It also unblocked the next three weeks. Net, the plan came out ahead.

A second example: where productive struggle ends

Later in the same week, a different kind of stuck showed up. The problem was on combinations. The prompt got read three times. Nothing came to mind. The same approach as subsets didn't fit the structure. A fourth read, still nothing. Ten minutes of staring at a blank screen, then finally looking up the solution.

The reason this is a different kind of stuck is that there was no specific question to articulate. With subsets, you can say "the role of pop isn't clicking." With combinations, the screen was just blank. That's the generation effect telling you to do something you weren't doing: generate an attempt, even an obviously wrong one, before reaching for the solution. The blank screen wasn't a signal to read more. It was a signal to write something, anything, even broken, and then read.

When the rule became "write a wrong attempt first, then check the solution against it," the difference between productive struggle and spinning collapsed into a single test: can you name what's missing? If yes, more practice on that specific gap. If no, generate first, check second.

Why this works (the science I dug into later)

None of this was clear during the original Week 7 collapse. The retrospective is what surfaced the underlying reasons. Two effects from the cognitive science literature explained what was actually happening, both linked from the Wikipedia learning sciences article:

The first is the spacing effect. Practice distributed across weeks, with each week building on the last, retains better than the same volume crammed late. The dependency-ordered roadmap isn't only logical, it's also the configuration of practice that the spacing effect rewards. Skipping a week and trying to make it up later isn't just a time problem, it's a retention problem.

The second is the generation effect. Producing an answer (even a wrong one) before checking the reference produces stronger encoding than reading the reference first. Part of the Week 8 collapse was that Weeks 5 and 6 had been heavy on reading and light on writing, so when Week 7 demanded that recursive structures be generated from scratch, the muscle wasn't there. Adding the timer at Week 6 (which became standard practice on the second attempt at this plan, six months later) is what built that muscle while the material was still fresh.

What I'd tell someone in the same spot

If you're three or four weeks in and a topic is starting to feel slow, here's what would actually help:

1. Don't skip. Extend the plan by the days you need on the slow topic. The catch up time at the end is almost never less than the time you'd have spent doing it right the first time.
2. Treat recognition speed as a separate skill from solution knowledge. If you can read the solution and follow it but can't write it from a blank screen, you have a generation gap, not a knowledge gap.
3. Add the timer at Week 6 even if you don't feel ready. Especially if you don't feel ready. The discomfort of timed practice while the material is still fresh is the discomfort that builds retrieval speed.
4. Use the Recursion for the layer between the call stack and DP if you can find one with worked examples that can be attempted before reading the solution. Generation first, walkthrough second. That's the order that closes the gap.
5. When you hit a blank-screen moment on a problem, write a wrong attempt before looking up the solution. The wrong attempt surfaces the specific missing piece more cleanly than another round of passive reading.

This is exactly why I built codeintuition, to structure recursion → backtracking → DP as a dependency chain instead of isolated topics.

What's the week of your own prep where the order finally locked in for you, and what was the topic that broke it open?