From scanning cells to scanning units

Most beginner solvers scan one cell at a time. Most experienced solvers scan rows, columns, and 3×3 boxes. The difference is the most important one in mid-level Sudoku, and almost everything that distinguishes a slow medium-puzzle solver from a fast one comes down to which mode the eye is in.

This piece is about the shift. What it looks like in practice, why it produces faster moves, and how to make it automatic without thinking about it.

Cell-first thinking

The natural beginner approach is cell-first. You pick an empty cell, mentally list the digits not in its row, column, or box, and look at what's left. If exactly one digit survives, you place it. If two or more survive, you move to the next cell.

This is the naked-single technique, and it works well on easy puzzles where naked singles are common. On medium and harder puzzles, it works less well, because medium puzzles are calibrated to run out of naked singles after the first ten or twelve placements. After that, cell-first scanning produces a lot of "this cell could be 4 or 6 or 7" — interesting information, but not actionable.

The cell-first scan also has a subtle cost. It encourages you to think about cells in isolation. The cells are constrained by the units they sit in, and reasoning about them one at a time hides the cross-cell patterns that pairs, triples, and pointing pairs depend on.

Unit-first thinking

Unit-first scanning starts from a unit (row, column, or box) and a digit, not from a cell. You pick a unit and ask which digits it's missing. For each missing digit, you scan the empty cells in the unit and ask where the digit could legally go. If the answer is exactly one cell, that's a hidden single. Place it.

The same scan finds hidden pairs and triples — when two digits in a unit can only go in the same two cells, those cells are claimed; when three digits share the same three candidate-cells, those cells are claimed for the triple. None of these patterns is visible from a cell-first perspective, because they depend on knowing where in the unit each digit could go, which is a unit-level property.

Unit-first thinking also pairs naturally with the opening-scan habits in where to look first on a fresh grid. Counting digits, identifying the most-given box, finding the digit with the most existing placements — these are all unit-first moves, and they produce the strongest opening placements.

The trick of switching between them

Experienced solvers don't pick one mode and stay there. They switch fluidly, often within a few seconds. A typical mid-puzzle scan might go: cell-first across the most-constrained cluster (looking for naked singles), unit-first across the rows the placements affect (looking for new hidden singles those placements created), back to cell-first for the next cluster. The switching is fast because the same constraints inform both modes — the only thing that changes is the question shape.

The shift is harder than it sounds at first because it requires holding two questions in your head at once. "What goes here?" and "where does this digit go?" feel like the same question to a beginner; with practice they become distinctly different questions, and the eye learns to ask whichever one will produce the faster answer.

What changes once you can switch

Most solvers find that the biggest single jump in their solve times happens around the moment unit-first thinking becomes automatic. Hidden singles surface immediately. Naked and hidden pairs become visible in the way naked singles already were. Pointing pairs (which are unit-level patterns spanning a box and a line) become possible to spot at all, where previously they were invisible. The medium puzzle that took twelve minutes starts taking eight, and the hard puzzle that took thirty starts taking twenty.

The shift doesn't happen all at once, and there's no single moment where it clicks. It happens gradually over twenty to fifty puzzles of deliberate practice — paying attention to which question you're asking when you scan, deliberately choosing unit-first when cell-first stops finding moves. After that period the choice becomes invisible, and you're a faster solver without quite remembering when it changed.