STA 561 Final Project
Zixuan Lin, Steven Chen, Xilong Li, Sicheng Zhang
Modern chess software is extremely strong, but it is not built for people who are still learning how to think through a position. If a beginner asks a traditional engine for help, the answer is usually a number, a variation, and a level of confidence that can feel more intimidating than useful. That kind of output may be technically correct, but it often does not tell a student what to do next, what idea matters in the position, or why a move feels natural for one player and unnatural for another.
Our project starts from a different question: what would a chess tutor look like if it were designed for improvement rather than perfect play? We wanted a system that could meet a learner at a chosen skill level, explain positions in plain language, and make trying ideas feel more like guided practice than being judged by a superhuman engine.
The final system is an interactive chess tutor launched from Jupyter
but powered by a reusable Python app module. The user sees a
drag-and-drop board, a target Elo slider, a side selector for starting a
new game as White or Black, a FEN loader for custom positions, a visible
practice-pool panel, a sample middlegame button, an
Evaluate Position button, and a Regret button
for rewinding the last full turn and trying another idea. The board also
supports colored tactical arrows, and the coach panel explains those
arrows directly in the interface.
Under the hood, the project combines three main pieces:
python-chess, which handles legal move generation,
board logic, notation, and tactical structureThis design lets the tutor do more than say whether a move was good or bad. It can ask whether the move was typical for the selected rating, whether the position improved, what tactical theme was present, and what kind of plan the student should think about next. The current version also switches cleanly between move-by-move coaching and position-level review, which matters because studying a position and playing through it are different learning tasks.
The sample middlegame feature is part of that teaching design too. Instead of throwing the student into random legal positions, the app chooses from a curated practice pool matched to the selected Elo band. Lower bands emphasize cleaner classical structures; higher bands include sharper, more theory-heavy middlegames. As a result, the difficulty of the position, the recommendation style, and the bot behavior all move together.
The final version behaves like a real tutoring tool rather than a
model demo. The user can begin from move one, paste in a custom FEN, or
load a sample middlegame from the appropriate practice pool. They can
ask for a static position evaluation before moving, make a move and
receive move-level coaching, undo the last turn with
Regret, and compare multiple candidate ideas from the same
position. They can also switch sides and start a new game as Black, so
the tutor is not limited to White-side opening practice.
In our testing, those features worked together in a way that made the notebook feel genuinely usable:
Evaluate Position worked both from sample middlegames
and from an ordinary new gameRegret button made it practical to compare one
plausible move against another without rebuilding the board state by
handThis last point is more important than it may first appear. Many classroom-style chess tools quietly assume the user is always White. Our final interface does not. It can open with the tutor playing White while the student practices Black and still explain the position in a readable way.
The key difference is that the tutor does not treat strength as the only goal. A normal engine can tell the user the strongest move, but that does not mean it is giving the most educational response. Our tutor is designed to be legible. It describes whether a move is common or unusual for the chosen rating, names the general idea behind the move, offers a few alternatives, and closes with a next priority. In tactical positions it can also mark the board with arrows so the student can connect the words to the geometry of the position.
That creates a different kind of learning experience. A student is not just being told that they lost half a pawn. They are being told something like: develop another piece, watch for hanging material, keep king safety in mind, or compare candidate moves before choosing the first active-looking idea. That is the kind of language a learner can actually carry into the next position.
Our testing also showed an important nuance: the tutor is often strongest at the level of plan rather than at the level of one exact forced move. That is not a weakness in the project framing. If anything, it makes the tutor feel more like a real coach. It helps the user understand what kind of move belongs in the position, then lets them test whether a specific follow-up really works.
The finished project meets its main goal well. It lets a user set up a position and evaluate it at a chosen Elo, and it also lets a user play against a bot with running commentary. More importantly, it does those two things as one coherent system. The interface, the language, the sample pools, the undo behavior, and the tactical overlays all support the same teaching idea: chess feedback should be understandable, level-aware, and useful for improvement.
There are still natural next steps. A longer user study would be needed to measure rating improvement directly. The tactical vocabulary could be expanded further, and session memory could eventually let the tutor adapt over time to a specific student. Even in its current form, though, the system already goes beyond a proof of concept. It is a complete interactive tutor with a clear educational point of view, a polished front end, and a concrete answer to the problem that motivated the project.
This document is the executive summary for the project. The
companion faq.md addresses skeptical-reader questions about
how the tutor behaves in practice, and appendix.md gives
the full technical description, reproduction steps, screenshots, and
design rationale.