Two Ways to Reveal a Chess Puzzle Solution—and What Each Costs

On a chess learning platform, a puzzle has exactly one moment that matters for learning: the gap between "I don't know" and "here's the answer." How you fill that gap decides how much of the answer sticks. We added a Show Solution button next to retry and analysis, gated the next puzzle behind a real attempt, and gave the reveal two modes — one that costs the learner almost nothing, one that asks for a little more. The point of this post is the tradeoff underneath that choice: a reveal is effort traded against learning, and the interface should let the learner set the exchange rate.

A puzzle trainer lives or dies on the attempt. The learning happens while the player is stuck — searching the position, rejecting candidate moves, committing to one. Everything before the answer is the part that builds skill.

The failure mode is quiet. A learner gets stuck, wants to move on, and reaches for the exit. If the interface lets them jump straight to the next puzzle, the stuck moment evaporates with nothing to show for it — no attempt, no answer seen, no trace of the position in memory. They churn through positions and feel productive while learning very little. The board fills with activity and empties of retention.

There was also a narrower gap: a stuck learner had retry and analysis, but no clean, direct way to just see the solution. Retry asks them to try again when they've already given up; analysis is a heavier tool than "show me the moves." The one thing a stuck learner most wants — the answer — was the hardest thing to reach.

The obvious fix is a Skip button. Give up, click skip, next puzzle. It's honest about what the learner wants and it's trivial to build.

It also quietly defeats the trainer. Skip rewards the exact behavior that produces no learning: bail before attempting, bail before seeing the answer, repeat. A learner can run a whole session on skip and never once sit in the productive discomfort of a position they can't crack. You'd be shipping a fast path around the only part that works.

The opposite over-correction is just as bad: force every learner to grind each puzzle to a correct answer before moving on. That's a wall, not a trainer. Some positions sit above a learner's current level, and being trapped on one they can't solve is how you get someone to close the tab. "No exit" and "free exit" are both wrong. We needed an exit that costs something small and leaves something behind.

We made the next puzzle appear under exactly two conditions: the learner solves it, or the learner presses Show Solution. There is no third door. You cannot advance without either producing the answer yourself or asking to be shown it — and either way, your attempt on the current position is preserved before the answer appears.

That single rule reframes the whole interaction. Show Solution stops being a shortcut and becomes an honest transaction: I'll give you the answer, and in exchange this counts as engaging with the puzzle, not skipping it. The learner still gets unstuck and still moves on, but never without the position registering. Retry and analysis stay right where they were; Show Solution joins them as the direct, no-friction way to end a position you can't finish.

The tradeoff we accepted is explicit. Gating the next puzzle adds a small step for a learner who just wants to churn — you can no longer machine-gun through positions. We took that cost on purpose, because the friction lands exactly where the value is: it converts a skip into a seen answer.

The reveal is where the design gets interesting, because "show the solution" is not one behavior — it's a spectrum of how hard the learner has to work to absorb what they're shown. We built two modes at opposite ends of that spectrum.

Arrows — all moves at once. The board draws every move of the solution simultaneously as arrows over the current position. It's the lowest-effort reveal available: one glance and the whole line is visible. Nothing plays out; nothing waits for the learner. The tradeoff is real — an at-a-glance answer is easy to see and easy to forget, because the learner never has to reconstruct the sequence.

Auto-play — one move at a time. The board steps through the solution move by move, playing them in order. It costs the learner a little more: they have to follow the line as it unfolds, hold each move against the position, and watch the answer develop rather than take it in as a static picture. It's still a reveal — no one is being asked to find the move — but the small extra engagement of following a sequence tends to leave more behind than a single flat glance.

The gate sits in front of both. Whichever mode a learner picks, the same rule holds: the attempt is preserved, and only then does the next puzzle appear. The diagram below shows the two reveal modes side by side and the gate between any reveal and the next position.

Two modes is not a hedge — it's the argument made concrete. The reveal is an effort dial, and different learners, or the same learner on different days, want it set differently. Someone confirming a line they nearly saw wants the arrows; someone who was genuinely lost gets more from watching it play out. We didn't pick the exchange rate for them; we handed them the dial.

The surprise was how much of the design pressure moved off the reveal and onto the gate. We spent our attention on the two reveal modes — the visible, interesting part — but the behavior that actually changes what a learner keeps is the boring rule underneath: you can't advance without an attempt or a reveal. The modes decide how an answer is absorbed; the gate decides whether it's engaged with at all. The unglamorous constraint was doing the heavy lifting.

The second realization was that a reveal is not the opposite of learning. It's easy to treat "showed the solution" as failure and bury it behind friction. But a stuck learner who sees the answer and moves on has learned more than one who skipped and saw nothing. Putting Show Solution right beside retry and analysis was us admitting that being shown the answer is a legitimate way to learn — as long as the attempt came first.

We're reporting the design honestly rather than dressing it in numbers we didn't collect. What changed is structural and observable in the flow itself:

• There is no longer a path to the next puzzle that bypasses the current one. Every advance is now either a solve or a reveal, and every advance preserves the attempt that came before it.
• Show Solution is a direct, first-class action alongside retry and analysis, so a stuck learner has an honest exit instead of a dead end or a churn button.
• The reveal offers two clearly different levels of engagement — glance-and-go arrows or step-through auto-play — so the learner controls how much they work for the answer.

The measurement we'd watch next is straightforward: how often each reveal mode is chosen, and whether revealed positions reappear as solves later. Those are the numbers that would tell us the effort dial is doing its job.

• A trainer's value is in the attempt, so protect the attempt. Gate the next item behind a solve or a reveal; never ship a path that advances with nothing preserved.
• Skip is the enemy, not the reveal. Being shown the answer after an attempt beats seeing nothing after a skip. Make "show me" a first-class action, not a hidden one.
• A reveal is effort traded for learning. How you show the answer sets the exchange rate — arrows cost nothing and fade fast; a stepped auto-play costs a little and leaves more.
• Hand the learner the dial. Different learners want different exchange rates; offering two reveal modes lets each set their own instead of you guessing for them.
• The boring constraint often carries the design. The gate, not the fancy reveal, is what actually changes what a learner keeps.