What the source published
The author, brumar, published chess-postmortem-skills on GitHub: four Claude Code skills that turn a chess game into a post-mortem worth reading. The motivation is plain: engine analysis gives you numbers and lines — say, -1.8 after your move plus a twelve-move variation you would never find at the board — which is neither fun to read nor an answer to why. His approach is to let Claude drive Stockfish itself, asking the engine the questions a human would ask ("why not the move I played?", "what if Black simply takes?"), keep asking until the answer makes sense, and write it down in plain language.
Each skill has a job. chess-analysis is the workhorse: a Stockfish sweep of every move (depth 22 in the example), then parallel investigator subagents that interrogate the engine with deliberately naive questions until every mistake is explained. The output is a layered annotated PGN, a standalone HTML analysis board, and one plan pause per game in which both sides' plans are derived from the engine. It also handles your think-aloud recording: whisper.cpp transcribes it locally, and the PGN clock times align each sentence to the move you were deciding at that moment.
chess-video turns the post-mortem into a video: board, move arrows, an eval gauge, piper-synthesized narration and burned-in subtitles, all generated from a storyboard, plus an interactive HTML viewer. The repo ships a complete example: a 15+10 rapid the author played on lichess (White, Open Sicilian against the Najdorf, around 1700), recorded in French on a plain voice recorder while thinking aloud. After the game he handed Claude the game link and the mp3, and out came a 6:49 narrated video in English — transcript, engine sweep, annotated PGN and storyboard all published under examples/game-010/.
The other two skills are lighter. chess-position studies a single position from a FEN or a screenshot: it first asks whether you want a positional or a tactical analysis, then explains plans or tactics in human terms with every claim checked against Stockfish, and can produce a narrated video on request. chess-play plays a game against Claude over PGN files, rendering the board to PNG for the vision model with adversarial blunder-check subagents watching — no engine involved, the model plays on its own.
Try it: from one rapid game to a narrated video
- Pick a game worth the effort: the author recommends games where you had time to think, such as 15+10 rapid or correspondence. Blitz is a bad fit — lichess analysis does that in seconds.
- Record yourself thinking during the game: any phone or web voice recorder works, say whatever crosses your mind; for correspondence games, write a few notes per move. This is what makes the result special: with your real thoughts, the review refutes you instead of a strawman.
- After the game, open Claude Code and say something like "analyze this game: <your PGN file>, here is my think-aloud recording: <mp3>", then go do something else.
- Wait about an hour: a full run (sweep, investigations, annotations, video) takes that long. You come back to an annotated PGN and a standalone HTML analysis board that opens in any browser.
- Ask for the video with "make a video of this game" and Claude builds an mp4 with narration and subtitles from the storyboard, plus subtitle files and an annotation viewer.
- Do not stop at watching: keep asking about the positions you still do not understand — every answer gets engine-checked first — and tell Claude your level once in CLAUDE.md (for example, "write chess analysis for a 1800 player") so the commentary is pitched right.
Sources: [1]
The full picture: how it differs from built-in engine analysis
The difference is the direction of questioning. Ordinary engine analysis is one-way output: an eval number and a best line for you to figure out. Here Claude uses the engine as a tool and interrogates it in reverse: a full-board sweep flags everything suspicious, then one subagent per mistake digs in, each question more naive than the last — "was the threat I feared even real?", "where exactly does this plan fall apart?" — until the engine's answers assemble into plain language. Each investigator's findings merge into annotation fragments, which are finally assembled into a layered PGN.
The think-aloud recording is the masterstroke. For the example game the author muttered in French; Claude transcribed it locally with whisper.cpp and pinned each sentence to a ply using the PGN clocks. So the video narrates things like "at move eight you asked yourself whether the bishop belongs on c4 or e2" — a question he genuinely asked himself mid-game, answered with the engine. A review built on your own questions hits harder and sticks longer than any generic lesson.
The author does not dodge the hallucination question: the model can still get things wrong. Two safeguards are built in — every claim is checked against Stockfish before it is written down, and a verifier pass re-reads the whole result. In his experience errors are rare, and when something looks off you can simply ask Claude to re-check that position with the engine.
Setup is easier than it looks. A skill is just a SKILL.md file written for Claude to read; installing means cloning the repo and copying the skills folder into ~/.claude/skills/. The dependencies (Python's python-chess, cairosvg, pillow and piper-tts, a Stockfish binary, ffmpeg, a voice pack, whisper.cpp) do not need manual setup — ask Claude Code to "install the dependencies for the chess skills" and it reads the list itself. The repo even ships get_stockfish.sh, which downloads the official Linux binary when none is found.
How to read this
What makes this project delightful is the division of labor it demonstrates: the engine is responsible for being right, the model for making it understood. Chess AI headlines used to be about playing strength; this goes the other way — strength stays with Stockfish while Claude translates and interrogates. The result is an experience that used to require hiring a coach: someone takes every thought you had during the game, verifies each against the engine, and tells you which fears were justified and which plans were doomed from the start.
For subscribers, the real lesson is not chess but the skill format. The four SKILL.md files are essentially an expert workflow written as instructions Claude can follow: sweep first, investigate, then assemble, with each step's inputs and outputs pinned down. You can copy the pattern into your own domain — write down how you review your work, let Claude run it, and swap Stockfish for your field's source of truth: a test suite, a spec document, or a senior colleague's checklist.
Know the limits too: a full run takes about an hour, which suits someone who plays one or two serious slow games a week; for daily blitz the workflow is overkill next to instant lichess analysis. The narration in the example is English, though the recording can be in any language — transcription and alignment do not care, as long as you are willing to talk while you play.
Sources: [1]
Key takeaways
- Four Claude Code skills: chess-analysis (engine sweep plus interrogating subagents plus annotated PGN), chess-video (narrated video), chess-position (single-position study), chess-play (play against Claude, no engine).
- The core trick is Claude driving Stockfish: asking human-like why questions, with every claim engine-verified before it is written and a final verifier pass — hallucinations stay rare.
- Your think-aloud recording is the soul of it: whisper.cpp transcribes it, PGN clocks align it per move, and the review refutes your actual reasoning instead of generic advice.
- Getting started is three moves: clone the repo into ~/.claude/skills/, let Claude install the dependencies itself, note your level in CLAUDE.md; then "analyze this game" and "make a video" do the rest.
- A full run takes about an hour and suits slow or rapid games; blitz players are better served by instant lichess analysis. Open source under MIT, with every intermediate file of the example game in the repo.
Sources: [1]
