Large language models hallucinate chess moves because they generate the most probable next text, not the most legal next move. Without an engine in the loop, an LLM will confidently recommend illegal moves, invent tactical lines that don't exist, and mis-identify pieces. The fix is to wire a chess engine in first, validate every chess claim against engine output, and drop or rewrite anything the engine doesn't support before showing it to a user.
Illegal moves
The LLM recommends a move the position doesn't allow — a piece that's pinned, a square that's blocked, a king move into check. It looks fluent because the syntax is right; it's wrong because the LLM never checked the position.
Invented tactical lines
The LLM describes a sequence of forced moves that wins material — except the sequence doesn't work because the opponent has a defense the LLM didn't search. The line reads cleanly. The line is fiction.
Mis-identified pieces and squares
The LLM confuses which side has which piece, swaps file labels, or misreads the orientation of the board. These bugs are obvious to a human but routine when text generation isn't grounded in the position.
A large language model is trained to predict the next token given prior tokens. It learns a distribution over chess-y text — opening names, common tactical phrases, the cadence of how a strong player annotates a game. Given a position description, it produces text that sounds like a strong player's commentary on that position.
What it doesn't do is search the move tree. It doesn't verify that the moves it recommends are legal. It doesn't check whether the principal variation works. If most training data describes "Nxf7 winning a piece"-style tactics in similar positions, the LLM will write that sentence whether or not it actually applies to your board.
The result is a tool that sounds like a coach but is statistically incentivized to be confidently wrong on edge cases. The pattern: high confidence, plausible reasoning, incorrect chess.
A grounded AI chess coach runs a chess engine first — Stockfish, in Chess Masti's case — and reads the engine's evaluation and principal variation before generating any explanation. The LLM's job is to translate the engine's output into plain language. The engine handles correctness; the LLM handles communication.
That's necessary but not sufficient. The LLM can still confidently invent a tactical line outside the engine's principal variation. So a grounded coach also needs a validator: a layer that checks every chess claim the LLM makes against engine output and drops or rewrites anything the engine doesn't support. Chess Masti runs this validator pipeline before showing you the response.
Test 1: ask about an unusual position.
Give it a weird endgame or a non-standard opening. If the explanation feels generic or recycled from a more common position, the coach is probably text-pattern-matching, not position-evaluating.
Test 2: verify the recommended line.
Take the coach's suggested variation and play it on a real engine. If the engine rates the result very differently from what the coach claimed, that's a hallucination.
Test 3: ask the same question twice.
Reset the chat. Ask the same question about the same position. If the two answers are substantively different — different recommended moves, different reasoning — the coach isn't grounded in a stable evaluation.
See how Chess Masti avoids this
The free AI chess coach page covers the full grounded pipeline: Stockfish evaluation, Claude AI explanations, and the validator layer that checks every claim before display.
Open the free AI chess coach pageTry a grounded AI chess coach
Stockfish-evaluated. Claim-validated. Free.