An algorithm you have to read every time isn’t learned. The goal is for it to come out of your fingers as soon as you recognise the case, without going through the letters. Here’s how to get there, one algorithm after another, without forgetting half of them the following month.

Before you start: one algorithm at a time

Learn three algorithms at once and you’ll remember none. Pick one, and only move on to the next when you can do it three times in a row without hesitating, on a scrambled cube, starting from the real case. In the app, the Formulas sheet (“Formulas” menu) shows you the whole method at once; use it to choose, not to swallow everything. The learning plan suggests an order.

1. Break the algorithm into triggers

Almost every algorithm is made of blocks of three or four moves that turn up everywhere. These are called triggers. Once you know them, a twelve-move algorithm becomes a sequence of three blocks.

Trigger Moves Where you’ll meet it
Sexy move R U R' U' most OLLs, the T perm, F2L
Reverse sexy U R U' R' the F2L 3 insert, the end of algorithms
Sledgehammer R' F R F' OLL 33, OLL 37, many corner OLLs
Hedgeslammer F R' F' R mirror of the one above
Sune R U R' U R U2 R' OLL 27, and it’s the basis of the Antisune
F sexy F' F R U R' U' F' OLL 45, edge orientation in 2-look; it has no established name, people read it “F, sexy, F’”

Example: OLL 33 is written R U R' U' R' F R F'. Read letter by letter, that’s eight moves. Read in blocks, it’s sexy move then sledgehammer, two things your fingers already know how to do. The T perm, R U R' U' R' F R2 U' R' U' R U R' F', starts with the same two blocks, then finishes with R2 U' R' U' R U R' F'.

OLL 33
after the sexy move
after the sledgehammer

OLL 33 block by block, where only the yellow matters. The sexy move disturbs the face, the sledgehammer finishes it.

Open the “OLL (yellow face)” step in the app

When you read a new algorithm, start by looking for the triggers you know. Whatever is left between them is what you really have to learn. The app does this spotting for you: on the Formulas sheet and under the virtual cube, each trigger is underlined and named.

2. Understand what it does

You don’t need group theory, but a rough idea of what’s going on helps a lot, both to remember and to fix a mistake halfway through.

  • Spot the piece that moves: in an F2L insert like R U R', the pair comes out, lines up, goes back in. Watch the pair, not your fingers.
  • Spot the structure: many algorithms take the form “A, B, A inverse, B inverse” (a commutator) or “setup, action, undo” (a conjugate). The Aa perm, x R' U R' D2 R U' R' D2 R2 x', is a rotation to change grip, a swap, and the way back.
  • On the app’s virtual cube, pause the algorithm after each block. You see what each piece does, and you know where you are if you get lost.
Start
R
U
R'

The R U R' insert: the pair comes out of the slot, lines up against the edge, goes back in. The pieces in grey don't matter.

Open the “F2L (first two layers)” step in the app

3. Slowly, then fast

The order matters: speed comes from accuracy, not the other way round.

  1. Ten times slowly, reading it. Each time, put the cube back into the starting case (if the algorithm solves an OLL or PLL case, running it several times in a row often brings you back to the starting case; otherwise do the inverse algorithm, or scramble and rebuild).
  2. Ten times without reading, saying the blocks in your head: “sexy, sledge”.
  3. Ten times looking somewhere else, or with your eyes closed. If your fingers finish the algorithm on their own, it’s starting to be yours.
  4. Only then, speed up. Look for the most comfortable way to link the moves: this is the time to work on your fingertricks, not before.

A good test: reciting the algorithm backwards or explaining it to someone proves nothing. What counts is getting it out on a real cube, from the recognised case, without having to think about it.

4. Review before you forget

Finger memory fades quickly at first, then less and less. The rule is simple: go over an algorithm the next day, then three days later, then a week later, then a month later. If at any of these points you have to read it again, restart the cycle from the beginning for that one.

In practice, daily solving is often enough: twenty solves a day means you meet each PLL about once a day on average, and the common OLLs too. Rare cases (the dot OLLs, some G perms) need deliberate review: set them up on your cube with the Formulas sheet and do them on purpose.

5. When an algorithm won’t stick

  • You mix up two similar algorithms (Ja and Jb, Ua and Ub, Sune and Antisune): learn them at different times, and tie each one to its recognition cue rather than to its name. See Recognising a case.
  • You always get stuck at the same spot: that’s the boundary between two blocks. Drill just those two or three moves, ten times, then put them back into the algorithm.
  • It works in the app but not on your cube: check the starting orientation (the case instruction) and the direction of L, B, D and M. See Cube notation.
  • You don’t like it: some algorithms suit other people’s hands better than yours. If the app offers an alternative for this case, try it. Otherwise, stick with the one you have for now; switching algorithms every three days is the best way to end up remembering none.

With this method, an OLL or PLL algorithm sets in after two to five days of daily practice. The rest is a matter of consistency, and of not rushing on to the next one too soon.