---
title: "Engine analysis for chess coaching: using Stockfish"
description: "Use engine analysis for chess coaching by checking evaluations, lines and search limits, then choosing a position the student can understand."
canonical: "https://chesscore.io/blog/engine-analysis-for-chess-coaching"
author: "Abhishek Tiwari"
datePublished: "2026-06-10"
dateModified: "2026-10-18"
---

Written by Abhishek Tiwari. Drafted with AI, fact-checked and approved by a human before publishing. Editorial standards: https://chesscore.io/editorial

Engine analysis for chess coaching works when Stockfish is a detector, not a teacher: it shows where the evaluation moved and which line it expects, and the coach picks one moment a student can understand. Read every number with its perspective, depth and settings in mind, then turn the moment into a habit to practise.

## Key takeaways

- Stockfish is a blunder detector and a second opinion, but it does not explain, prioritise, or know your student, so the coach supplies the translation layer.
- An engine score is only meaningful with its perspective, depth and settings: the same position read +24 for Black and -0.24 for White, and a different number of lines changed it again.
- As a coaching heuristic, start with the largest swings, and read each against the position it started from: a smaller slip near equality can cost more than a bigger one in a decided game.
- Pick exactly one teachable moment per game, name the concept behind it, and let the student find a better move before anyone looks at the engine's top line.
- Engine analysis hurts when it runs first: a student who states their own assessment before the engine speaks learns to think instead of waiting for the bar.

- Stockfish is free and open source, so any coach can run engine analysis at no software cost.
- Stockfish's displayed centipawn value is normalised: +1.00 corresponds to a 50% win probability in engine self-play at 60+0.6 seconds per game, so it is not a literal pawn count.
- The UCI protocol reports an engine's score from the engine's point of view, which is why the same position can read +24 for Black to move and -0.24 from White's side.
- Lichess says losing 300 centipawns in an equal position is a major blunder, while losing 300 when the game is already won or lost makes almost no difference.
- Almost every chess platform exports games as PGN, a plain-text standard that both humans and engines can read.
- The Lichess API lets a coach export a student's games programmatically and free of charge, which is what makes batch-wide review practical.

## What does chess engine analysis actually give a coach?

Chess engine analysis gives a coach three things: a blunder detector that does not get tired, a second opinion that is hard to argue with, and a ranking of the moments in a game by how far the evaluation moved. Stockfish marks where the evaluation swung; the coach then picks one moment, names the concept, and turns it into a habit the student can practise.

That is the complete list. Engine analysis does not give explanations, it does not know which of its findings the student can absorb, and it has no idea that the child who played the game is nine years old and cried after losing.

The detector alone is worth a great deal. Stockfish is free and open source \[1\], and it has sat at or near the top of computer chess rating lists for years \[2\]. Tired eyes at the end of a long teaching day miss things, and an engine does not tire. It is still a search with limits: at a fixed depth it can score a deep or closed position differently from a longer search, and two runs with different settings can return different numbers. Treat every evaluation as a measurement taken with stated settings, not as a verdict.

What the engine outputs is a score, a principal variation (the sequence of moves it expects from both sides) and the depth it reached. A student cannot eat any of those. A score tells them they went wrong; it does not tell them why, and the best line shows what a machine would have played, not what they should learn to see. The gap between engine output and student learning is the coach's entire job in game review. We call it the translation layer: the engine detects, the coach selects and explains, the student practises.

> **The translation layer in one sentence** Stockfish answers the question 'where did the evaluation change and what was objectively best', and the coach answers the only question the student actually has: 'what should I do differently next time'. The two questions sound similar and are not.

## How do you read an engine line without misreading it?

Read an engine line as four separate things: a score with a perspective, a principal variation, a depth, and the settings that produced them. The score says who is better and by how much under those settings, and the line shows one sequence the engine expects. Neither tells you what a student should have seen, and a different depth or number of lines can change both.

| Part of the output | Example from the position below | What it tells you | What it does not tell you |
| --- | --- | --- | --- |
| Score (centipawns) | score cp 24, Black to move | How the engine rates the position on Stockfish's normalised scale, where +100 corresponds to a 50% chance of winning in engine self-play at 60+0.6 seconds per game \[7\]. | A literal pawn count, or the chance that a nine-year-old wins. |
| Perspective | Raw +24 for Black is -0.24 from White's side | Whose side the number favours. The UCI score is given from the engine's own point of view, so it changes sign with the side to move, and many boards convert it to White's perspective \[9\]. | Who is better, if you do not know which convention your tool shows. |
| Principal variation | pv c6a5 c4d5 f8e7 g5f6 | One line of play the engine expects from both sides. | The line a student can find, or the only sensible plan. |
| Depth and lines | depth 16, MultiPV 1 | How far the iterative-deepening search got, roughly in half-moves, and how many lines it kept \[7\]. | A fixed truth: other settings can return another score. |

Two warnings follow. Never compare numbers from two tools until you have checked the perspective and the settings of each. And do not teach that a positive score always favours the side to move: in raw UCI output it does, but most analysis boards show White's perspective, where a positive number favours White whoever is to move. In the worked example below the same position reads +24 in one convention and -0.24 in the other.

## What does one position look like from FEN to a teaching point?

Take 5...Nxe4 from the first game in a made-up sample set. Before the move the position is level; after it, White wins the queen. The engine's number moved by 9.20 pawns on White's scale, and the coach's work starts after that number: why it moved, what the student can see, and the one sentence to practise. The games are legal teaching fixtures, not a student's record or a Lichess game.

| Step | Input or output | Value |
| --- | --- | --- |
| 1 | FEN before 5...Nxe4, Black to move | r1bqkb1r/ppp2ppp/2np1n2/4p1B1/2B1P3/3P1N2/PPP2PPP/RN1QK2R b KQkq - 2 5 |
| 2 | Engine and settings | Stockfish 19, depth 16, 1 thread, 16 MiB hash, MultiPV 1, hash cleared with ucinewgame |
| 3 | Raw score | score cp 24 with Black to move, so +24 for Black |
| 4 | The same score from White's side | -0.24 pawns |
| 5 | FEN after 5...Nxe4, White to move | r1bqkb1r/ppp2ppp/2np4/4p1B1/2B1n3/3P1N2/PPP2PPP/RN1QK2R w KQkq - 0 6 |
| 6 | Raw score | score cp 896 with White to move, so +8.96 for White; line begins 6.Bxd8 |
| 7 | Swing | From -0.24 to +8.96 on White's scale: 9.20 pawns, or 920 centipawns, lost by one move |
| 8 | Win% on the Lichess model (our arithmetic) | White 47.8% to 96.4%; Black 52.2% to 3.6% |

Why the number moved: Black's knight on f6 stood in front of the queen on d8, and White's bishop on g5 pinned it. Moving the knight let White play 6.Bxd8. In the sample game Black recaptured with 6...Nxd8 and then lost the knight on e4 to 7.dxe4.

Ask for two lines before choosing what to show. With MultiPV 2 at the same depth, Stockfish ranked 5...Na5 first (score cp 10 for Black) and 5...h6 second (score cp -1). Both are close to equal, and the first number differs from the +24 above only because the settings changed. That is the limit to teach: another run gives another small number, so do not build a lesson on a gap of a tenth of a pawn.

> **Saved engine output, 16 October 2026** Stockfish 19, Threads 1, Hash 16 MiB, hash cleared before each run. Before 5...Nxe4, MultiPV 1: info depth 16 seldepth 22 multipv 1 score cp 24 pv c6a5 c4d5 f8e7 g5f6 e7f6 a2a4 a5c6 b1d2 e8g8 e1g1 a7a5. After 5...Nxe4, MultiPV 1: info depth 16 seldepth 20 multipv 1 score cp 896 pv g5d8 e4f2 e1f2 d6d5 c4d5 c6d8 h1e1 c7c6 e1e5 e8d7 d5c4 d7d6. Before 5...Nxe4, MultiPV 2: multipv 1 score cp 10 pv c6a5 c4b3 a5b3 a2b3 f8e7 e1g1 e8g8; multipv 2 score cp -1 pv h7h6 g5d2 c8g4 h2h3. These are local measurements on made-up games, not output from a ChessCore customer account.

Why this moment and not another is the coach's call, and the reasons below are an illustrative choice, not engine output. The swing is the largest in the game. The cause is something a student can see on the board, a pinned piece standing in front of the queen. And the same pin appears in three dated games in the sample, so it is a habit and not a one-off. The engine's first choice, 5...Na5, is a good move but rests on attacking the bishop on c4. The coach would more likely stop before the mistake and ask the student to find a move that deals with the pin, such as 5...h6, which is the engine's second line.

One more caution on the percentages. Lichess turns a centipawn score into a Win% with an equation fitted to games between 2300-rated players, and says the equation may change \[8\]. It is that site's population model, not a prediction for a child. Using its published equation, the 920 centipawn swing above is a fall from 52.2% to 3.6% for Black.

## Which engine outputs should a coach look at first?

Look first at the largest swings, and read each one against the position it started from. This is a coaching heuristic, not an engine rule and not a research finding. Its practical reason is that many games between younger players turn on a hung piece, a missed fork or a one-move tactic, and those show up as the biggest swings. Adjust it to the students you teach.

![Chess board with a fallen knight marking a large mistake while small arrows fade behind.](https://chesscore.io/images/blog/engine-analysis-for-chess-coaching-b1.webp)

*Start with the largest swings; the smaller ones can wait.*

Smaller differences are harder to teach. A move scored +0.4 against a preferred +0.7 is a gap most students cannot see, and at a fixed depth it can move with the settings. A useful discipline is to decide in advance which outputs you will leave out of a lesson, and to say that the rule is yours:

- Differences under about half a pawn: real engine differences, but few students can act on them and they shift with the search settings.
- The engine's full principal variation beyond two or three moves: machine-length lines that the student cannot reproduce.
- Accuracy scores as a headline: Lichess itself says accuracy is not a test grade, because in lopsided positions most moves barely change the winning chances and the score can stay high even if the conversion was clumsy \[8\].
- Opening evaluation differences between playable lines: for most students the opening did not decide the game.
- Multi-line analysis with three engine alternatives: one good human move is worth more than three equally scored machine moves.

One reframing helps younger students more than any other: talk in plain words, not centipawns. 'You are clearly worse here' or 'this is equal' lands immediately, where +2.0 means little to a child. If you want a number for chances, Lichess's Win% is a population model from 2300-rated games \[8\], so quote it as that and not as a personal probability. The centipawn number is for you; the story it tells is for them.

## Does the same swing mean the same thing in every position?

No. Lichess makes the point itself: losing 300 centipawns in an equal position is a major blunder, while losing 300 when the game is already won or lost makes almost no difference \[8\]. That is why a coach reads the starting evaluation before the size of the swing.

| Mover's evaluation before | After a slip | Win% before to after (Lichess model) | Win% lost |
| --- | --- | --- | --- |
| 0.00 (equal) | -3.00 after a 300 cp slip | 50.0 to 24.9 | 25.1 |
| +9.00 (winning) | +6.00 after a 300 cp slip | 96.5 to 90.1 | 6.4 |
| -5.00 (already losing) | -8.00 after a 300 cp slip | 13.7 to 5.0 | 8.7 |
| 0.00 (equal) | -1.50 after a 150 cp slip | 50.0 to 36.5 | 13.5 |

Read the last row against the third. A 150 centipawn slip from equality costs more Win% than a 300 centipawn slip from a lost position. As a coaching heuristic, not an engine rule: spend lesson time on slips that change the result, and give the same slip in a decided position a lower priority. The Win% figures are our arithmetic from the equation Lichess publishes, rounded to one decimal, and they describe that model, not any one student.

## How do you turn an eval swing into a teachable moment?

You turn an eval swing into a teachable moment by picking exactly one swing per game, naming the concept behind it, and making the student do the discovering. A student game can contain several flagged moments. Resist the urge to cover them all. A review that touches six mistakes teaches none of them; a review that lands one concept hard enough that the student can repeat it back in their own words changes how they play next week.

Picking the one moment is a judgement call with three criteria. First, size: prefer the swing that decided the game, because the student already feels its weight. Second, comprehensibility: the mistake must be explainable at the student's level, so a hung piece beats a subtle pawn structure error every time for an 1100 player, even if the structural error came first. Third, recurrence: if this is the third game in a month where the student traded queens while losing, that swing wins even if a bigger one exists, because you are not reviewing a game, you are coaching a player.

The conversation itself has an order of operations that matters more than any software. Set up the position one move before the mistake, with the engine hidden. Ask what they were thinking when they played the move; the answer tells you whether this was a calculation error, a missed opponent threat, or a wrong plan, and those are three different lessons. Then ask them to find a better move now, with no time pressure. Most students find it, and a move a student finds themselves is worth ten moves they are shown. Only then do you name the concept: loose pieces drop off, check every capture, trade pieces when ahead and pawns when behind, ask what the opponent's last move threatens. The concept is the takeaway, not the move.

This is also why showing a nine-year-old the engine's top line can backfire. The engine's first choice can be a move that only works because of a precise machine-depth follow-up: a quiet rook lift justified by a tactic four moves later, a pawn sacrifice that needs many accurate moves to pay off. The child cannot reproduce the idea, cannot verify it, and may learn one thing from seeing it: that the answer comes from the machine and not from them. Repeat that weekly and you risk a player who moves fast, checks the bar, and has outsourced their thinking. A lower-ranked engine line is sometimes the human move, the one built from a nameable idea, and that can be the line worth showing if you show one at all.

Close the loop by writing the concept down against the student's record, in the student's own words where possible. 'Stop hanging pieces' is a complaint; 'before I move, I check what my opponent's last move attacks' is a habit with a trigger. The written sentence is what turns a fifteen-minute review into curriculum material later, and our guide on how to review a student game in 15 minutes builds its whole routine around producing that one sentence.

A ChessCore game review: Stockfish marks every eval swing on the move list, so the coach can skip straight to choosing the one moment worth teaching. The data is from Demo Chess Academy, a made-up academy.

## How do recurring mistakes become a training plan?

Recurring mistakes become a training plan when you tag every reviewed mistake with a category and look at the tags across five to ten games instead of one. A single game tells you what happened on Tuesday. Ten games tell you who the player is: the student who hangs pieces after move 30 when tired, the one who wins material and then trades into lost endgames, the one who never asks what the opponent's move threatened. The engine finds each instance; only the record across games reveals the pattern, and the pattern is the thing worth training.

Keep the categories few and plain: hanging material, missed opponent threat, wrong trade, endgame technique, time trouble collapse, no plan after the opening. As a rule of thumb, when one tag appears in about a third of a student's games it has stopped being feedback and become next month's theme. Homework then writes itself from the student's own positions, which is the approach our guide to turning analysed games into chess homework lays out in detail, and themed puzzle sets on Lichess let the student drill the exact motif by name, free, the same week \[5\].

A season timeline in a made-up demo academy: games, reports and payments on one line, which is where a mistake the reviews keep finding shows up as a pattern across months rather than a single bad game.

| Recurring pattern in games | Concept to name | Drill that fits |
| --- | --- | --- |
| Pieces hang after move 30 | Every move, scan for undefended pieces | Blitz the scan habit on the student's own late-game positions |
| Wins material, then loses anyway | Trade pieces when ahead, simplify | Replay their own won positions against the coach from the point of advantage |
| Misses opponent threats | Ask what the last move changed | Cover the board after each opponent move and say the threat aloud |
| Trades into lost endgames | Count the endgame before the trade | King and pawn endgame sets, then re-evaluate their own trade decisions |
| Drifts after the opening | Find the worst piece and improve it | Pause their games at move 12 and ask for a plan in one sentence |
| Collapses in time trouble | Decide faster in equal positions | Play training games with the student's real increment, not classical time |

Patterns also explain plateaus better than ratings do. A rating is just compressed results against rated opposition \[6\]; when it goes flat, the games usually show one or two stubborn patterns absorbing all the rating points the student earns elsewhere. Our piece on [breaking a chess rating plateau](https://chesscore.io/blog/chess-rating-plateau) goes deeper, but the short version is that plateaus are rarely mysterious once mistakes are tagged: the student is not stuck, they are leaking from one specific hole, and the engine has been pointing at it for months. Connecting the rating history to the recurring tags, on one screen, is what turns 'practise more tactics' into 'we fix your trading decisions this month'.

A student record in ChessCore: the rating line next to reviewed games, so a flat stretch can be read against the missed fork the reviews keep finding. The data is from Demo Chess Academy, a made-up academy.

## When does engine analysis hurt more than help?

Engine analysis hurts more than it helps whenever it runs before the human thinking does. A habit worth breaking is the post-game ritual of opening the analysis bar within seconds of resigning: the student scrolls to the red moves, winces, closes the tab, and calls it studying. No recall happened, no reasoning was examined, and the only thing reinforced is that evaluation is something a machine does to you.

There are quieter failure modes too. Centipawn anxiety is real: students who know their accuracy score from every game start optimising for the number, avoiding sharp positions where the engine might disapprove, and playing the board like an exam. Engine-line mimicry shows up in lessons as students proposing moves they cannot explain because 'the computer liked it' in some game they reviewed alone. And for the youngest students, the engine's bluntness has an emotional cost a coach would never inflict: a child who fought for two hours does not need to learn that they were 'lost by move 19'. The coach's framing, that the game was decided by one findable moment, is both kinder and more accurate as a description of what to do next.

> **House rule that fixes most of it** Nobody opens the engine until the student has stated their own verdict: where they think they stood, where they think it turned, and what they would play differently. The engine then confirms or corrects. Students who do this for a term start predicting the engine, which is the entire point of training.

None of this is an argument against engines; it is an argument about sequence. Engine first, student becomes a spectator of their own games. Student first, engine becomes the referee of their developing judgement. There is a related question that a coaching tool, rather than a coach, has to answer: whether an AI-written explanation can replace this human sequencing. It cannot, and the next section sets out why, because a language model and an engine are two different machines that fail in opposite ways.

## How does engine analysis differ from an AI explanation?

Engine analysis and AI explanation come from two different machines, and most of the confusion about AI in coaching software disappears once you keep them apart. A chess engine like Stockfish searches positions and outputs evaluations and lines. A large language model predicts text and outputs prose. The engine produces the chess truth; the model only phrases it. On its own a language model has no board and no search, so it cannot be the source of a chess claim, and the pipeline that works runs in one direction: the engine produces the evaluation, the model puts it into words, and a person checks the words before anyone shares them.

The engine's output is checkable within limits. Rerun the same position with the same settings on one thread and you get the same verdict, so a claim like this move dropped half a pawn can be re-derived by anyone; change the depth or the number of lines and the number can move, which is why a score is a measurement with stated settings and not a proof. Its weakness is the flip side of that precision: a parent reading plus 1.7 after 18...Qe7 has learned nothing. The model's failure mode is the mirror image. Its prose is readable and sometimes wrong, and wrong in the worst way, fluently and confidently, with no falling eval bar to warn you. Frameworks for deploying AI responsibly, such as the NIST AI Risk Management Framework, treat the validity of generated output as a risk to be managed rather than assumed \[10\], which is the formal version of the house rule that a person reads anything a model drafts for a family.

| Axis | Engine analysis (Stockfish) | AI explanation (language model) |
| --- | --- | --- |
| What it is | Search algorithm plus a neural evaluation function | Statistical text predictor trained on language |
| What it outputs | Centipawn scores, best lines, win estimates | Prose: summaries, reports, explanations |
| How it fails | Scores depend on depth and settings, and are hard for humans to read | Fluently and confidently, with no warning sign |
| What it costs | Free and open source \[1\] | Per-token API costs for hosted models |
| Trust it for | A measured evaluation of the position, with its settings | The communication of that evaluation |
| Do not use it for | Explaining to a parent in plain words | Evaluating positions on its own, or inventing facts |

Read the last two rows twice, because they are the core of the argument. Each machine has a domain where it is the best tool available and a domain where using it is a mistake, and the predictable failure in an AI chess product is sliding one machine into the other's column. A language model with no engine attached cannot reliably evaluate a position, because there is no search behind the sentence and no guaranteed board state: as a conversation grows it can reference a captured piece as if it were alive or announce a check that does not exist. Give it a legal board and an engine tool and it can report what the engine returned, which is a different and safer case, but the sentence still needs checking, because the engine can be right and the prose built on it can still draw the wrong conclusion.

> **The test we apply to every drafted explanation** For every chess claim in a draft, ask whether it traces to an engine line or a record you can see, and whether a person has read the sentence. A claim that fails either question does not go to a family. In practice that means five quick checks: replay every move for legality, confirm the evaluation's perspective, confirm the quoted line starts from this position, confirm each named piece stands on the square given, and cut any conclusion that is not backed by the engine output.

Take the same 5...Nxe4 position from earlier and follow it from engine output to a checked sentence. Stockfish scored it minus 0.24 for White before the move and plus 8.96 for White after it, with the line beginning 6.Bxd8. A draft that read Black's 5...Nxe4 was a bold central capture, and although White replied well, Black stayed only slightly behind is exactly the kind of error to catch: bold central capture is colour with no support, and slightly behind contradicts a score of plus 8.96 for White. The corrected sentence names the mechanism and quotes the settings: 5...Nxe4 moved a knight that was pinned against the queen on d8, so 6.Bxd8 won the queen, and Stockfish at depth 16 scored the position minus 0.24 for White before the move and plus 8.96 after it. The facts come from the engine; the model's job is only to say them in a way a parent can read.

The two machines side by side on an imported Chess.com game, in a made-up demo academy: Stockfish supplies the evaluation of the fork, and the plain-language explanation beside it stays a draft until the coach approves it.

This is also where buyers get burned, and the failures never announce themselves. A coach pastes moves into a general chatbot with no engine attached and gets a confident review that misidentifies the losing move, so the student studies the wrong lesson. A product shows polished explanations but cannot show the Stockfish line behind each claim, which means the model is doing the evaluating. A tool asks the model to pick the critical moment and then runs the engine to decorate it, which has the dependency backwards: the engine must select, and the model may only describe. When you choose coaching software, ask where every chess claim comes from, and expect the answer to be an engine line you can see or a record. In ChessCore, which we build, Stockfish produces every evaluation, the model phrases masked engine findings for game explanations, and AI-written explanations wait for staff review before they are shared; the separate topic of which AI actions need a human and which send on a schedule is covered in our guide to [AI guardrails in coaching software](https://chesscore.io/blog/ai-guardrails-in-coaching-software).

An AI-drafted report in ChessCore that phrases record-based numbers and waits for staff approval, while engine findings stay in the separate game review. The data is from Demo Chess Academy, a made-up academy.

## How do you scale game review across a whole batch?

You scale game review across a batch by industrialising everything except the judgement. Collection and engine runs are mechanical and should cost the coach little; selecting the teachable moment and having the conversation are the craft and should get the remaining time. As an illustration, an academy with forty students playing three games a week produces roughly five hundred games a month, and no coach reviews five hundred games by hand. The honest options are triage or burnout.

![Five step cards left to right showing scaling workflow from collect to teach overlap.](https://chesscore.io/images/blog/engine-analysis-for-chess-coaching-b2.webp)

*Industrialize everything except the judgement about what one moment to teach.*

Linking a student's public Chess.com username with the family's consent, in a made-up demo academy. Games are imported read-only, about every hour.

The plumbing is more standard than most coaches expect. Every platform speaks PGN, the plain-text game format that has been the lingua franca of chess software for decades \[3\], and Lichess exposes a free, documented API for exporting a player's games in bulk \[4\]. Where your students should be playing in the first place is its own decision, and our comparison of [Lichess vs Chess.com for academies](https://chesscore.io/blog/lichess-vs-chesscom-for-academies) walks through it; the integrations page lists what syncs automatically versus what arrives by PGN upload.

1. Collect on a fixed day: pull each student's recent games from the platform export, the Lichess API or a PGN file, with no retyping.
2. Run the engine on the games you have chosen to review, and on as many others as your hardware or tool allows; Stockfish is free, but every run costs computing time.
3. Triage by swing size: surface the games that contain a large swing or a repeated tagged pattern, and let quiet games go.
4. Review one game per student per week using the fifteen-minute method, ending with one written concept per student.
5. Teach the overlap: when four students share a tag, that mistake becomes the next group lesson, position on the demo board, names withheld.

That list is a suggested workflow, not a description of any tool. In ChessCore, which we build, importing games and analysing them are separate steps: importing a PGN file (up to 200 games) or syncing a linked account does not itself request engine analysis. A coach requests analysis game by game, and with the academy's practice loop switched on, which is the default, a nightly job also requests analysis for up to two recent unanalysed games per student per day. AI explanations of a game are a further step and arrive as drafts for the coach to edit.

The group lesson step is where batch scale becomes an advantage instead of a burden. One student's instructive collapse, presented anonymously from the actual position, teaches twelve students at once, and the student who played it learns it deepest. Coaches who run this loop stop thinking of engine analysis as a per-game chore and start treating the batch's games as a living question bank. Where AI assistance can help in this workflow, drafting summaries and pre-sorting the queue under human review, is covered in our pillar on [AI for chess coaches](https://chesscore.io/blog/ai-for-chess-coaches), and the same division of labour applies: machines move the paper, the coach makes the calls.

> **The number that matters** Track one operational metric: reviewed games per student per month with a written takeaway. Total engine analyses run is a vanity number; a student can have fifty analysed games and zero coaching. One reviewed game a week with one named concept beats both.

## Frequently asked questions

### Is Stockfish good for chess coaching?

Yes, with the right division of labour: Stockfish is a strong detection tool and it is free and open source. It flags the largest evaluation swings it finds at the depth you give it, ranks mistakes by size, and gives a second opinion. What it cannot do is choose which mistake is worth teaching, explain ideas at a child's level, or know a student's history. Coaches who use it as a detector and keep the explaining for themselves get the benefit without the dependence.

### Can a chatbot analyze my chess games as well as an engine?

A chatbot with no engine attached can produce something that reads like analysis, but the chess content is unreliable because it predicts text rather than calculating a position. Engine analysis and AI explanation are two different machines: run the game through an engine first, since Lichess offers free Stockfish analysis, and use language tools only to summarise or explain what the engine found. A language model also tracks the board as text, so as a move list grows it can describe an illegal move; an engine holds an exact internal board and does not. If a tool connects a model to an engine, still check legality, the evaluation perspective and the quoted line before you trust a sentence, because the engine can be right while the prose built on it is wrong.

### How do you use a chess engine to teach beginners?

Sparingly and second. Have the beginner state their own assessment of the game first, then use the engine to locate the biggest swing. Set up the position before the mistake, ask what they were thinking, and let them search for a better move themselves. Translate the evaluation into plain words such as clearly worse or equal, and skip the engine's top line if it depends on tactics beyond their level. One named concept per game is a good target.

### What is a centipawn in engine analysis?

A centipawn is one hundredth of the unit engines use for evaluation. Stockfish's displayed value is normalised, so +1.00 corresponds to about a 50% chance of winning in engine self-play at its test time control, not a literal pawn. Check the perspective: the raw UCI score follows the side to move, while many boards show White's perspective. For coaching, the change between moves and the starting evaluation matter more than the absolute number.

### Should students run engine analysis on their own games?

Older and stronger students, yes, with a protocol: annotate the game with their own thoughts first, then check with the engine and write down where it disagreed. Younger students often benefit more when the engine stays in the coach's hands, because unsupervised analysis can turn into scrolling to the red moves and closing the tab. The skill being trained is evaluation, and a student who always asks the engine first never builds it.

### How big does an eval swing need to be before it matters for a student?

There is no engine rule for this. As a coaching heuristic, a swing of about a pawn (100 centipawns) is worth a look, and swings of two pawns or more are often the story of a game between younger players. Read the swing against the starting evaluation: 150 centipawns lost near equality can cost more winning chances than 300 lost in a position that was already decided. Adjust the threshold to your students and say so when you teach it.

## Sources

1. [Stockfish: strong open-source chess engine](https://stockfishchess.org), stockfishchess.org, accessed 2026-10-16
2. [Stockfish (chess), Wikipedia](https://en.wikipedia.org/wiki/Stockfish_(chess)), en.wikipedia.org, accessed 2026-10-16
3. [Portable Game Notation, Wikipedia](https://en.wikipedia.org/wiki/Portable_Game_Notation), en.wikipedia.org, accessed 2026-06-10
4. [Lichess.org API documentation](https://lichess.org/api), lichess.org, accessed 2026-06-10
5. [Lichess puzzle training](https://lichess.org/training), lichess.org, accessed 2026-06-10
6. [Elo rating system, Wikipedia](https://en.wikipedia.org/wiki/Elo_rating_system), en.wikipedia.org, accessed 2026-06-10
7. [Stockfish docs: frequently asked questions (evaluation, depth)](https://official-stockfish.github.io/docs/stockfish-wiki/Stockfish-FAQ.html), official-stockfish.github.io, accessed 2026-10-16
8. [Lichess: accuracy metric, Win% and centipawns](https://lichess.org/page/accuracy), lichess.org, accessed 2026-10-16
9. [UCI protocol description (score, multipv, pv fields)](https://backscattering.de/chess/uci/), backscattering.de, accessed 2026-10-16
10. [NIST AI Risk Management Framework](https://www.nist.gov/itl/ai-risk-management-framework), nist.gov, accessed 2026-10-16