Most cubers who plateau make the same mistakes, and they are not the ones you might expect. They are almost never missing algorithms: they are practice habits. Here are the most common ones, with what actually works to get rid of them.
Learning algorithms before you need them
The symptom: you know fifteen OLLs, but your F2L stalls at every pair and your times don’t move.
Why it’s a problem: algorithms are the visible part of CFOP, but they are not what makes the difference. A twenty-second cuber using 2-look OLL exists; a twenty-second cuber with a hesitant F2L does not.
The fix: follow the order in the overview: pause-free F2L and full PLL before OLL. If you have already learnt some OLLs “ahead of time”, keep them in review, but spend your practice time on F2L.
Watching your fingers
The symptom: during an algorithm or an insert, your eyes follow the turning cube. When it ends, you go looking for what comes next.
Why it’s a problem: your fingers know how to do the algorithm; your eyes are the only tool you have to prepare the next step. Using them to watch something you already know how to do is the biggest waste in a solve.
The fix: the next pair exercise: turn slowly, on purpose, and look for the next pieces during the insert. For OLL and PLL, execute them while staring at a fixed point above the cube: if you get them wrong, you don’t really know them yet (see How to learn an algorithm).
Rotating the cube to look around
The symptom: you turn the cube around in your hands before each step to “see the other side”, in F2L as well as in PLL.
Why it’s a problem: every rotation costs time and, worse, makes you lose your bearings (where is the face that used to be at the front?). And it is almost always unnecessary: the clues you need are visible from the front.
The fix: the Recognising a case section. For PLL, forbid yourself from rotating: two sides are enough, so look up the clue you are missing in the table. For F2L, learn the left and back inserts so you no longer have to bring every slot to the front right.
Timing too early, or all the time
The symptom: every solve is timed, you know your average to a tenth of a second, and you hate solves where you try something new because they are “slow”.
Why it’s a problem: the timer measures what you can already do. It punishes everything you are learning, because learning slows you down at first. The result: you stop daring to change anything, and you plateau exactly at the level where you started timing.
The fix: keep your sessions separate. Untimed practice sessions where you work on one thing (look-ahead, one OLL family, back inserts) and accept being slow. Then, once or twice a week, a timed set to measure. The Fluency page explains when and how to time yourself.
Reciting without understanding
The symptom: you know an algorithm, but if you slip up halfway through you are lost; and you couldn’t say what each part does.
Why it’s a problem: an algorithm you understand can be repaired, lasts longer in memory and can be adapted. An algorithm you only recite is forgotten all at once, and the slightest hesitation breaks it.
The fix: for each algorithm, spot the triggers (R U R' U', R' F R F'…) and watch what each block does on the app’s virtual cube, pausing between moves. No theory: just “this part takes the pair out, that part puts it back in”.
R U R' U'R' F R F'What each trigger does, applied to a solved cube. Seeing the result of each block means knowing where you are halfway through an algorithm.
Switching algorithms all the time
The symptom: you saw a video with a “better” algorithm for Jb, you learn it, then another one the following week.
Why it’s a problem: an algorithm gets fast after hundreds of executions. Switching resets the counter to zero, and two algorithms for the same case interfere with each other: you start one and finish with the other.
The fix: stick with the app’s main algorithm for each case until you have learnt it. Only try an alternative if yours really bothers you (moves your hands don’t like), and only once: you choose, and you stick with it.
Neglecting the cross
The symptom: your cross takes ten moves and three seconds, and you never think about it because “it’s the easy part”.
Why it’s a problem: it is the only step you can plan entirely before you start, so the only one that can cost you nothing in looks. A neglected cross means two lost seconds and a bad start to F2L.
The fix: the Cross page: white on the bottom, planning during inspection, and practising with your eyes closed.
Learning too much new material, not reviewing enough
The symptom: you have “learnt” thirty OLLs, but only about ten come out without hesitation. The others you recognise, but you have to search for the algorithm.
Why it’s a problem: an algorithm that isn’t reviewed at the right moment fades, and relearning it costs almost as much as the first time.
The fix: the pace of the learning plan: two or three new algorithms a week, five minutes of review per session, and a list of what you have truly learnt.
Turning too fast for your level
The symptom: you turn as fast as you can, you miss moves, you “lock up” the cube (one face jams because another isn’t aligned), and you have to fix it.
Why it’s a problem: turning speed is not solving speed. A solve turned at half the speed but with no pauses and no mistakes is faster.
The fix: turn at the speed you can see. If you don’t yet know what you will do after this move, slow the move down. That is where fluency comes from, not from your fingers.
Waiting until you’re “ready”
The symptom: you stay on the beginner method because you are “not fast enough yet” for CFOP, or on 2-look because 21 PLLs feel like too many.
Why it’s a problem: there is no threshold. CFOP is learnt in small steps that never break your solve, and each step starts from wherever you are now.
The fix: Moving from the beginner method to CFOP describes the first step. You can take it today.