Chess with me

Stockfish finds the move. Chess with Me explains why.

Comment

Chess with Me

Inspiration

Chess engines are extraordinarily strong, but strength is not the same thing as teaching.

When I review a game, Stockfish can tell me that a move is -2.3, show me a better move, and give me a principal variation. But that still leaves the questions I actually care about:

Why was my move a problem? What changed on the board? What should I have noticed? Can you show me instead of just giving me another engine line?

I wanted something closer to sitting beside a chess coach: an application where I could play, ask questions, explore variations, and receive explanations in ordinary language that I could verify directly on the board.

That became Chess with Me.

What it does

Chess with Me is an interactive AI chess coach built around Stockfish analysis, structured chess evidence, and a conversational coach called Mira.

A user can play a game, review positions, ask for a hint, ask why a move was good or bad, and inspect the continuation directly on the board.

The goal is not simply to tell the user the best move. Chess with Me tries to turn engine analysis into a useful lesson.

For example, an explanation may identify that a piece moved out of danger, resolved a check, captured an undefended piece, created a new attack, changed control of the centre, or produced a tactical difference between the move that was played and the engine's preferred alternative.

Where supporting evidence exists, the user can inspect the relevant continuation rather than having to trust a paragraph.

Chess with Me also includes Online VS. Players can play each other with a shared chat and shared AI coach context. The longer-term idea is similar to learning in a chess room: two players can agree to enable coaching and analysis transparently rather than one side secretly receiving assistance.

How I built it

I built Chess with Me as a solo developer using AI-assisted development extensively.

I make the product decisions, define what the chess system is allowed to claim, design the architecture and acceptance criteria, and review whether a capability is ready to ship.

AI coding tools including Codex, ChatGPT, Claude, and Grok have helped with implementation, testing, debugging, refactoring, UI work, architecture analysis, and documentation.

The production system separates chess reasoning from conversational language.

Stockfish performs chess search. Deterministic chess code replays positions and establishes board facts. Different analysis modules generate candidate teaching material. Those candidates are checked against their evidence and passed through a shared selection layer before anything is published.

The current teaching flow is approximately:

candidate generation → evidence → admission → priority / selection → publication

Gemini 3.5 Flash-Lite powers the open-ended conversational chess-coach functionality. It is not asked to invent chess truth that the underlying system has not established.

This separation is also important for cost. If the chess algorithm can answer a question directly, the product does not need an LLM call.

My long-term direction is to make the chess-analysis system increasingly capable as an internal chess API, while using lightweight language models where conversation actually adds value.

The biggest challenge

The hardest problem turned out not to be generating more chess explanations.

It was deciding which explanation should reach the player when several analytical systems all have something valid to say.

Earlier versions of Chess with Me grew several capabilities independently: static board analysis, Played-vs-Best comparison, opening knowledge, hint-oriented analysis, tactical detectors, and a number of fallback explanation paths.

Individually, many of them worked.

Together, the architecture began to fail.

Different systems were competing for the same response. An early return in one path could silently hide useful evidence from another. The Played-vs-Best layer had gradually become a broad black box containing many tactical explanations, and adding another detector or another fallback rule often increased coupling instead of increasing useful teaching coverage.

At that point, the problem was no longer:

"How do I teach one more chess idea?"

It had become:

"How can independent chess capabilities coexist without stealing, contradicting, or bypassing one another?"

Continuing to patch the existing cascade would have made the system increasingly difficult to reason about, so I stopped feature work and rebuilt the explanation architecture around a common pipeline:

candidate generation
       ↓
evidence
       ↓
admission
       ↓
priority / selection
       ↓
publication

Each teaching family now produces evidence-backed candidates rather than directly owning the final answer.

A shared selector decides what deserves the player's attention, while publication is separately validated.

This allows static observations, Played-vs-Best comparisons, opening teaching, hint-oriented analysis, and future modules to grow without silently overriding one another.

The migration was painful because it touched code that already appeared to work. Fixing one layer repeatedly exposed assumptions in another: activation, selection, composition, publication, UI delivery, deployment configuration, and regression behaviour all had to agree on the same contracts.

But that architectural collision changed how I think about the product.

A chess coach does not become useful by detecting the largest possible number of facts.

The difficult part is deciding:

What is true? What is relevant? What matters now? And which one of those truths is actually worth teaching?

That became the architectural centre of Chess with Me.

What I learned

The biggest lesson was that a correct answer is not automatically a useful answer.

A system can be extremely cautious and technically correct while still being a bad coach if it rarely teaches anything useful.

On the other hand, a fluent explanation that is unsupported can be worse than silence because it damages trust.

I therefore started treating product quality as a combination of correctness and teaching utility.

My internal evaluation tracks things such as useful-answer coverage, teaching utility, abstention, severe errors, and misleadingly precise claims. An unanswered position remains part of the denominator rather than disappearing from the statistics.

I also learned a great deal about AI-native software development.

I am not approaching the project as a traditional programmer writing every line manually. My role is closer to a technical product owner: defining the problem, creating system boundaries, deciding what evidence is sufficient, decomposing work, reviewing outputs, and using coding agents for execution.

That process has taught me far more about architecture, testing, deployment, contracts, rollback, feedback loops, and engineering decision-making than I expected when I started.

Early users

Four independently recruited online users tested earlier versions of Chess with Me, and two provided direct feedback.

One immediately exposed basic usability friction: moving pieces was harder than it should have been.

Another initially asked what made Chess with Me different from existing chess AI products. The idea became interesting to them only after I explained that the goal was not simply another engine interface, but a coach that tries to explain the game in human language.

Those were useful reminders that architectural sophistication means nothing if the user cannot immediately feel why the product is different.

What's next

Chess with Me is currently running as a free Public Alpha at:

https://chess-with-me.com/

The immediate priority is improving the breadth and quality of the coaching experience before pushing large-scale marketing.

Future work includes broader tactical and strategic coverage, richer interactive variation analysis, longer-term player memory, and longitudinal decision tracking.

Eventually, I want the system to remember recurring mistakes and decision patterns rather than treating every game as an isolated session.

Chess has a particularly useful advantage for measuring whether that works: rating already exists.

The long-term hypothesis is simple:

better explanations → better decisions → fewer repeated mistakes → stronger chess

The goal is to turn the strength already available from modern chess engines into something that feels less like reading a machine report and more like learning with a coach.

Built With

Share this project:

Updates