← Plugin catalog
Entertainment

Smart Chess:Train+Learn to win

Widget v4.0.0

Play+improve: coach+strategy

Create a free account to save this plugin.

From the developer

Declared capabilities

  • Play chess against an AI opponent with selectable colour and difficulty.
  • Set up verified FEN positions for games or workshops.
  • Practise piece movement, blockers, captures, and promotion on custom boards.

Cost & access

This plugin does not sell products or process payments.

Declared limitations

  • The app cannot retrieve or resolve an external game URL; `start-game` accepts a complete verified FEN rather than web references.
  • The app does not provide automatic puzzle-solution grading; `start-workshop` can display validated steps but cannot determine whether an arbitrary move solves a puzzle.
  • Practice workshops explicitly exclude castling and require an opponent-enabled legal position for full chess rules; this request conflicts with the tool's rules.

Onboarding example

Play a game of chess
Sources & dates

Developer declarations; not independently tested. Listing last checked Nov 21, 2026. Package observed Nov 21, 2026.

View package source →

Description

From the marketplace listing

Chess - Learn it, play it, practice it, master it! This plugin lets you play chess, with hints and analysis from ChatGPT And, it can teach you chess in the workshop - how pieces move, how to fork knights, castling, etc. Then play mini-games and improve before taking on puzzles and more! Want help with a move? Ask ChatGPT. It can look at the game with you and talk about what is going on. Ask why a move is good. Ask why a move may be bad. Ask what you should look at next. The goal is not just to win. It is to know why a move works. New to chess? You can start small. Learn how the pieces move. See what each piece can do. Take your time. Ask one question at a time. You can learn a little, try it on the board, and learn some more. You do not have to know all the rules to start asking questions. Want to get better at chess? Use the chess workshop. It has a board where pieces can be set up in many ways. You can look at one part of a game, not just a whole game. Try a move. See what may happen next. Ask ChatGPT to show you what to watch for. This is a place to stop, think, and try new ideas. The workshop is also for chess puzzles. A puzzle puts you in a spot on the board and asks you to find a move. Look at the pieces. Think about what each side can do. Pick your move. Then talk it through with ChatGPT. Try one puzzle or try more. You can use puzzles to practise seeing good moves. You can ask for help with a hard spot. Is your king safe? Can a piece be taken? Is there a way to put the other king in check? Can you win a piece? These are the kinds of things you can look for on the board. Go step by step. It is fine to try a move that does not work. You can ask why and try a new one. Chess is a game of choices. You move one piece at a time, but each move can change the board. Some moves help you now. Some moves help you later. When you play with an AI and ask for tips, you can learn to look before you move. You can spot a threat, make a plan, and see how the plan goes. You can use this chess game in many ways. Play a quick game for fun. Play to work on one skill. Ask for a tip after a move. Ask for a look at a game you just played. Go to the workshop to see a board set up in a new way. Or take on a puzzle when you have a few free minutes. You do not need to learn in one set way. Some days you may want a game. Some days you may want a lesson. Some days you may want a puzzle. You can switch from play to practice as you wish. ChatGPT can help you talk through what you see and what you want to try. Here are some things you can say: “Play chess with me.” “Teach me chess.” “Why was that move bad?” “What should I do next?” “Give me a chess puzzle.” “Help me find a good move.” “Set up a chess board so I can learn.” These are simple ways to begin. You can also ask your own chess questions. If you are new, start with the board and learn the moves. If you know the moves, try a game against the AI. If you want a new test, try chess puzzles. If you have a move or a spot you want to talk about, use the workshop. There is more than one way to learn chess. You can make up a board with just a few pieces. See how a rook moves. See how a knight jumps. Try to keep your king safe. Put the pieces in new spots and ask what they can do. Small board games can help you learn one thing at a time. You can keep trying. A move may not go as you hoped. A game may be hard. That is part of chess. Look at the board again. Ask what changed. Think of one new move. Try it. The more you play and think, the more you may see. This plugin brings a chess board, an AI chess game, chess tips, chess lessons, and chess puzzles into ChatGPT. It gives you a way to play chess, learn chess, and practise chess with help close by. Start with one move and see where the game goes.

Language: English · Automatically detected from descriptions.

What changed

· 3 observations

Capabilities & instructions

Chess updated; open the comparison for details. App-69c28d6aedac81919502a88c2179e20c updated; open the comparison for details. Full description changed from “Play chess without leaving ChatGPT. Start a new game in seconds, make moves in normal chess language, and talk about every part of the game as you play....

View comparison →
Capabilities & instructions

Chess updated; open the comparison for details. App-69c28d6aedac81919502a88c2179e20c updated; open the comparison for details. Full description changed from “Play chess without leaving ChatGPT. Start a new game in seconds, make moves in normal chess language, and talk about every part of the game as you play....

View comparison →

Technical updates · 1

Package or technical metadata updated

View technical comparison →

Similar plugins

Finding similar plugins… Results will appear here automatically.

Browse plugins →

Files & skills

File archives

Plugin package27 files · 2.33 MBBrowse files →
Skill instructions
absolute-beginner-chess2.85 KB

View saved version →

---
name: absolute-beginner-chess
description: Teach chess from zero through short interactive board lessons, understanding checks and a first easy game. Use for 'I am an absolute beginner, teach me' or a first chess lesson; do not use for an isolated piece drill or an experienced player's game review.
---

# Absolute beginner chess

1. Start teaching immediately unless the user supplied a specific starting point. Explain briefly that players take turns and the goal is to checkmate the king, meaning it is attacked with no legal escape; kings are never captured. Introduce board coordinates through the board rather than requiring notation knowledge first.
2. Open one `start-workshop` with a short plain-language title and a single achievable task. Start with a rook on a sparse `opponent: false` board, or the user's requested piece. Explain only the rule needed for that task and that this movement exercise lets their colour move repeatedly. Use a short validated `steps` line for an initial demonstration if helpful.
3. Wait for a question, attempt or Finished follow-up. Respond to visible moves and the user's explanation, then choose the next small lesson. Do not launch a whole course of widgets at once or equate pressing Finished with understanding.
4. Progress through rook/bishop/queen movement, knights, king and pawns at a pace the user can follow. Introduce blockers, captures, pawn direction and promotion when relevant. Use fresh practice boards and omit `steps` for independent checks; hiding an arrow leaves the listed answer visible. Explain unfamiliar words when first used.
5. Move to `opponent: true` workshops with both kings to teach alternating turns, check, escaping check, checkmate and stalemate. Make the transition from isolated practice explicit: practice boards ignore check and cannot demonstrate king safety. Demonstrate castling or en passant under full rules when useful, without delaying the first game to cover every special case.
6. When the user is ready or asks to play, call `start-game` with their chosen side and `difficulty: 0` unless they request otherwise. Coach one decision at a time from published state. Explain that even the easiest AI can win; do not promise a result or play the user's moves for them.
7. Close a lesson or first game with one observed learning point and a suggested next small task. Respect requests to skip ahead or stop; use conversation context for continuity without claiming stored course progress.

Keep workshop instructions to a sentence or two and omit distracting notes. Do not repeat rendered content in chat. Use only model-visible active history and position-labelled analysis; ask what the user tried when rejected moves are not recorded. Verify custom FENs and step coordinates, and fix tool errors before retrying the intended exercise. Deliver an interactive first lesson and paced continuation, rather than a long rules dump.

Referenced files: 1 — file references are metadata, not package contents.

adaptive-chess-rematch2.07 KB

View saved version →

---
name: adaptive-chess-rematch
description: Recommend an appropriate Stockfish difficulty for a rematch and start a fresh Chess app game after the user authorizes it. Use when the user wants to play again, make the next game easier or harder, or adjust the level based on how the previous game felt. Use only the registered start-game tool and integer levels from 0 through 20.
---

# Adaptive Chess Rematch

## Inputs

Use the current widget's model-visible `difficulty`, `moves`, `phase`, and `outcome` when available. Give the user's explicit assessment of the previous game's difficulty more weight than the result alone.

## Choose the Level

1. Honor an explicit requested level from 0 through 20.
2. For a relative request, start from the current difficulty and use a conservative adjustment:
   - Move by 1 level for a slightly easier or harder game.
   - Move by 2 levels when the user says the game was clearly overwhelming or far too easy.
   - Keep the same level when the game felt competitive.
3. Clamp the recommendation to the inclusive 0–20 range.
4. Do not infer a large adjustment from one win, loss, draw, or resignation. If the user has not described how the game felt, ask one concise calibration question or recommend staying close to the current level.

## Start the Rematch

1. State the proposed level and one short reason.
2. Treat a direct request such as “make it harder and play again” as authorization. Otherwise, ask for confirmation before starting.
3. Call `start-game` with:
   - `difficulty`: the chosen integer from 0 through 20
   - `reason`: an optional concise explanation of the user's rematch request
4. After the call, briefly confirm the level. Let the returned widget provide the fresh game.

## Boundaries

- Use the tool name `start-game` exactly. Do not invent tool arguments.
- Expect the tool's structured content to contain only `difficulty`.
- Do not claim to modify, resume, or unfreeze the previous widget; every call creates a new game.
- Remember that the user is always White and moves first.
- Do not promise that a level maps to a formal player rating.

Referenced files: 1 — file references are metadata, not package contents.

chess-hint-ladder2.14 KB

View saved version →

---
name: chess-hint-ladder
description: Give progressive, Socratic hints for the current Chess app position without revealing the move too early. Use when the user asks for a chess hint, clue, nudge, or guided help and wants to think through the live position themselves. Do not use for direct best-move requests or completed-game reviews.
---

# Chess Hint Ladder

## Inputs

Use only the current game widget's model-visible `modelContent`:

- `fen` and `moves` for the position and its context
- `phase`, `turn`, and `inCheck` for timing and urgency

Use the conversation to track which hint level the user has already received.

## Workflow

1. Confirm that the state describes an active game and that it is White's turn.
   - If Black is thinking, ask the user to wait for Black's move.
   - If the engine is loading or unavailable, explain that a live move hint is premature.
   - If the game is finished or restarting, offer to discuss the position or review the game instead.
   - If the state is missing, ask for the current FEN or move sequence.
2. Check immediate forcing concerns first: whether White is in check, direct threats, loose pieces, checks, captures, and tactical motifs.
3. Start at the first unrevealed level unless the user requests a stronger hint:
   1. State the position's main problem or objective without naming a move.
   2. Identify the relevant board area, piece, or tactical motif without giving the full move.
   3. Narrow the search to one or two candidate ideas.
   4. Reveal a concrete candidate move and explain its purpose.
4. Give only one new level per response. Pause so the user can calculate before offering the next level.

## Output

Label the response `Hint 1`, `Hint 2`, `Hint 3`, or `Reveal`. Keep it brief, explain what the user should inspect, and end by inviting the next hint level when appropriate.

## Boundaries

- Do not claim access to Stockfish analysis, evaluation scores, principal variations, or its internal reasoning.
- Present a revealed move as a reasoned candidate, not a guaranteed best move.
- Do not make a move, control the widget, or call `start-game`.
- Do not reveal later hint levels unless the user requests them.

Referenced files: 1 — file references are metadata, not package contents.

chess-puzzle2.49 KB

View saved version →

---
name: chess-puzzle
description: Give the user a playable chess puzzle with the solution withheld, optional progressive hints and a conversational review. Use for 'Give me a chess puzzle', mate challenges or requests for another puzzle; do not use for a guided line that should show the moves.
---

# Chess puzzle

1. Use the requested theme, side and level. For an unspecified request, start immediately with a simple mate-in-one; read [the starter puzzle](references/starter-puzzle.md) for a verified default. For later puzzles, choose a different verified position suited to the user's response. Request a FEN if a supplied external reference cannot be verified with available tools.
2. Establish the objective and verify the position and intended solution before presenting it. Check legal defensive replies before claiming a forced sequence or unique answer. Tool acceptance validates setup legality, not puzzle correctness. If verification is insufficient, simplify the puzzle or describe it as an exploration instead of asserting a forced win.
3. Call `start-workshop` with `opponent: true`, the user's `side`, legal `position`, a short neutral `title` and concise `instructions` naming the objective and asking the user to press Finished after trying. Use `strict: false` and omit `steps` entirely. Omit solution-bearing notes: `showHint: false` hides arrows but still reveals the step list.
4. Wait for the user's move, answer, hint request or Finished follow-up. Give only progressively stronger clues when requested, starting with a relevant feature rather than move squares or the solution. Do not reveal an engine principal variation as a subtle hint.
5. Review the active published moves and outcome, or the user's proposed move explicitly as a proposal. Accept alternative valid solutions. For a failed attempt, explain the concrete missed defence or unmet objective; do not infer failure merely from deviation from your line.
6. Reveal the solution when requested or when reviewing a concluded attempt, explaining the key idea briefly. Offer another puzzle adapted to the observed attempt, then wait unless another was already requested.

Stockfish controls replies; an unscripted multi-move puzzle cannot force a particular defence. Do not use scripted steps to hide a solution or treat a weak engine reply as proof of a forced win. Use available position-labelled analysis honestly; no puzzle-import service, rating, automatic custom-goal grading or permanent results log exists. Avoid repeating the rendered task below the board.

Referenced files: 2 — file references are metadata, not package contents.

endgame-technique-lab1.87 KB

View saved version →

---
name: endgame-technique-lab
description: Teach and practise one chess endgame technique using a short demonstration and a fresh attempt against Stockfish. Use for requests such as practising king-and-rook mate or pawn promotion; do not claim tablebase-perfect verification.
---

# Endgame technique lab

1. Choose one technique from the user's goal and experience. Use their visible position if suitable; otherwise construct a small legal position with both kings. Verify side to move, king safety, material and the intended objective before calling a tool.
2. Define a concrete task, such as reducing the king's space or reaching a promotion square. Distinguish practising a method from proving a forced win; avoid a claim of winning against every defence without evidence.
3. If a demonstration is useful, call `start-workshop` with `opponent: true` and a short verified `steps` line. Explain the technique briefly in the instructions or notes. Scripted replies illustrate that line and need not be the strongest defence.
4. When the user is ready, open a fresh full-rule workshop without `steps`, using `strict: false` and an appropriate difficulty from 0–20. State the task and when to press Finished; Stockfish chooses the opponent's replies.
5. On questions or completion, use model-visible active history, outcome and position-labelled analysis to discuss the technique. Check for stalemate and draw outcomes before calling an attempt successful. Give one specific correction and offer a retry from the original or a verified related position.

Do not use kingless practice rules for mate, opposition or draw lessons. The app has no tablebase lookup or automatic custom-goal grader; never treat missing analysis as a completed evaluation or promise Stockfish will cooperate. Keep each board concise and avoid repeating its instructions. Do not claim a lasting mastery score or saved training history.

Referenced files: 1 — file references are metadata, not package contents.

explain-chess-result1.84 KB

View saved version →

---
name: explain-chess-result
description: Explain why the current Chess app game ended and turn the result into one practical lesson. Use when the user asks why the game was checkmate, stalemate, a draw, a resignation loss, or otherwise finished. Use the model-visible outcome reason and final position as authority; do not infer an ending when no outcome is present.
---

# Explain Chess Result

## Inputs

Read the current widget's model-visible `outcome`, `fen`, `moves`, `turn`, `inCheck`, and `phase`.

If `outcome` is null, state that the widget has not recorded a final result. Explain the difference between the current status and a completed game if helpful, but do not invent an ending.

## Workflow

1. State the result, winner when present, and recorded reason.
2. Explain the relevant rule in plain language:
   - **Checkmate:** the side to move is in check and has no legal escape.
   - **Stalemate:** the side to move is not in check but has no legal move.
   - **Threefold repetition:** the same position, including the same side to move, occurred three times.
   - **Fifty-move rule:** fifty moves by each side passed without a pawn move or capture.
   - **Insufficient material:** the remaining material cannot produce checkmate.
   - **Resignation:** White ended the game voluntarily, so Black received the win.
3. Connect the rule to the final position or the last relevant moves without fabricating unavailable details.
4. Give one recognition tip or practical lesson for future games.

## Output

Use this compact structure:

- **Result**
- **Why it ended**
- **How it appears here**
- **Takeaway**

## Boundaries

- Treat `outcome.reason` as authoritative.
- Do not substitute another draw rule or claim an unrecorded adjudication.
- Do not present a Stockfish evaluation or principal variation.
- Do not call `start-game`; explain the recorded game only.

Referenced files: 1 — file references are metadata, not package contents.

explain-last-chess-move1.93 KB

View saved version →

---
name: explain-last-chess-move
description: Explain the purpose and consequences of the latest move in the current Chess app game. Use when the user asks why Stockfish or White played that move, what changed, what the move threatens, or how to respond. Ground the answer in the latest model-visible SAN and coordinate move plus the current position, without claiming access to Stockfish's reasoning.
---

# Explain Last Chess Move

## Inputs

Use the current widget's model-visible `moves`, `fen`, `turn`, `inCheck`, and `phase`. Treat the final entry in `moves` as the latest move and use both its SAN and coordinate fields.

If the history is empty, explain that no move has been played yet. If the state is missing, ask for the move or current position.

## Workflow

1. Name the latest move and identify which side played it. If the user's wording names the wrong side, clarify gently.
2. Explain its immediate board effects:
   - movement, capture, check, promotion, or castling
   - newly attacked, defended, opened, or blocked lines
   - material or king-safety changes visible from the position
3. Describe one or two likely tactical or strategic purposes. Use language such as “likely,” “appears to,” or “one point is” when explaining Stockfish's move.
4. Identify the most important threat or consequence for the side to move.
5. When it is White's turn, offer a practical response idea. Give a concrete move only when confident it is legal; otherwise describe the plan or candidate set.

## Output

Use four short parts:

- **Move**
- **What changed**
- **Likely idea**
- **What to watch now**

Adapt the depth to the user's level and question.

## Boundaries

- Do not claim access to Stockfish evaluation scores, search lines, or internal intent.
- Do not call a move best, forced, winning, or a blunder without evidence available in the position.
- Do not invent prior moves or hidden analysis.
- Do not control the board or call `start-game`.

Referenced files: 1 — file references are metadata, not package contents.

export-chess-game1.91 KB

View saved version →

---
name: export-chess-game
description: Export the current Chess app game as copy-ready PGN movetext with conservative metadata. Use when the user asks to export, copy, save, share, or convert the current game to PGN. Build from the model-visible SAN history and result, preserve unfinished games with an asterisk, and never treat the current final FEN as a starting-position FEN.
---

# Export Chess Game

## Inputs

Use the current widget's model-visible `moves`, `phase`, and `outcome`. Use each move's stored SAN exactly. Accept optional header values such as event, site, date, round, or White's name from the user.

If no widget state is available, ask for the move list. An empty but valid game exports as `*`.

## Workflow

1. Set the result token to `outcome.result` only when the game is finished and an outcome exists. Otherwise use `*`.
2. Build PGN movetext by pairing SAN entries in order:
   - Prefix White's move with `1.`, `2.`, and so on.
   - Place Black's following move after White's move.
   - Preserve the stored SAN notation for captures, checks, mates, castling, and promotions.
3. Append the result token exactly once at the end of the movetext.
4. Include only known or user-supplied tag values. It is safe to identify Black as `Stockfish 18`; use `?` for an unknown White name rather than inventing one.
5. When the user requests the strict PGN Seven Tag Roster, include unknown values as `?` and an unknown date as `????.??.??`.
6. Return the PGN in a fenced `pgn` code block. Keep commentary outside the block minimal.

## Boundaries

- Do not invent dates, player names, ratings, event names, move comments, or variations.
- Do not add `SetUp` or `FEN` tags. Games start from the standard position, while the widget's `fen` is the current or final position.
- Do not recalculate or normalize SAN when the authoritative move history already supplies it.
- Do not call `start-game` or write the export to an external service.

Referenced files: 1 — file references are metadata, not package contents.

guided-line-to-independent-play1.92 KB

View saved version →

---
name: guided-line-to-independent-play
description: Teach a concrete chess line through a guided workshop followed by an independent attempt. Use when the user wants to follow a combination or variation and then apply its idea; do not use for a puzzle whose answer must remain hidden from the outset.
---

# Guided line to independent play

1. Establish the starting FEN, user's side and one learning goal from the request or visible board. Resolve external game references from verified sources; ask for a FEN if the reference cannot be resolved. Do not invent historical positions.
2. Choose a short, verified line. Call `start-workshop` with concise `title` and `instructions`, coordinate `steps`, and `strict: true` for a fixed demonstration. Use `opponent: true` for alternating turns and full rules; the widget plays the opponent's scripted steps. Include promotion when required. Keep within the tool's 40-step limit.
3. Let the user play. Discuss the idea on their question or Finished follow-up, using the board ID and published progress. Do not claim a scripted reply is forced merely because it is in the line.
4. On readiness to try independently, create a fresh `start-workshop` at the original or a verified related position, omitting `steps` and using `strict: false`. Hiding the arrow with `showHint: false` still exposes the step list and is unsuitable for recall testing.
5. Review the active moves and available position-labelled analysis. Accept sound alternatives; distinguish remembering the line from explaining its purpose. End with one takeaway or a focused next attempt.

Keep the independent task and notes free of the solution. Use practice mode only when repeated same-colour moves are intentional; it ignores check and game endings. Correct tool validation errors before retrying the intended position; never silently substitute another. Do not repeat rendered instructions or promise automatic grading, stored mastery or widget control.

Referenced files: 1 — file references are metadata, not package contents.

mistake-to-practice1.88 KB

View saved version →

---
name: mistake-to-practice
description: Turn a specific mistake from a visible chess game into a focused board exercise and independent retry. Use for requests such as 'Turn my missed fork into an exercise'; do not replace a general game review.
---

# Mistake to practice

1. Identify the user's decision from the current board's model-visible active history, initial FEN and side. Clarify the move only if ambiguous. If the position or history is missing, request it rather than reconstructing unseen play.
2. Select one teachable idea. Use position-labelled engine evidence when available; distinguish a demonstrated error from a plausible improvement. Do not assign centipawn loss without comparable evaluations of the relevant positions.
3. Reconstruct the position before the decision and verify the proposed moves. Use `start-workshop` with a short title and task. For a demonstrated correction, supply a short legal `steps` line; use `opponent: true` when turns, check or defensive replies matter. Use repeated-colour practice only for isolated movement exercises.
4. Wait for the user's attempt or Finished follow-up. Review published moves and progress against the idea; an off-line move can still be good. Treat strict step completion as guided practice, not proof of independent understanding.
5. Offer a fresh attempt from the decision position or a verified variation. When accepted, call `start-workshop` without `steps` and with `strict: false` so the answer is not listed. Compare the observed attempt with the earlier decision and leave one practical reminder.

Keep each workshop's instructions brief and omit spoilers from independent attempts, including titles and notes. Do not repeat the widget's content after rendering. Do not claim to operate Undo, Reset or Finished, access private redo history, or save a permanent training record. Stop after the focused retry unless the user requests more.

Referenced files: 1 — file references are metadata, not package contents.

opening-debrief2.06 KB

View saved version →

---
name: opening-debrief
description: Identify the likely opening family from the current Chess app move history and explain its practical plans. Use when the user asks what opening was played, how the opening developed, where play left familiar theory, or what plans to remember next time. Treat names and ECO codes as heuristic because the app exposes no opening database.
---

# Opening Debrief

## Inputs

Use the early portion of the current widget's model-visible SAN and coordinate `moves`, plus the current `fen` when it helps explain the resulting pawn structure. Use the user's experience level to choose vocabulary and depth.

If no moves have been played, explain that there is no opening sequence to classify. If only a few half-moves are available, identify broad opening principles or a family rather than forcing a precise name.

## Workflow

1. Quote the relevant opening sequence in SAN.
2. Identify the most likely opening family or named variation.
   - State confidence when the move order is short, unusual, or compatible with transpositions.
   - Mention at most one plausible alternative name when ambiguity materially helps.
3. Explain the defining pawn structure, development pattern, and king-safety choices.
4. Give the typical practical plans for White and Black in the resulting structure.
5. Identify the first instructive decision for White. Call it a departure from theory only when sufficiently confident; otherwise describe it as a practical choice.
6. Finish with two or three priorities the user can remember in a future game.

## Output

Use this structure:

- **Opening sequence**
- **Likely opening**
- **Position character**
- **Plans for both sides**
- **Remember next game**

## Boundaries

- Do not imply access to an opening database, live theory, or Stockfish analysis.
- Omit an ECO code unless the user requests one and the classification is highly confident; label any supplied code as tentative.
- Do not invent missing moves or claim that a move is the first theoretical error without reliable evidence.
- Do not call `start-game` or alter the current game.

Referenced files: 1 — file references are metadata, not package contents.

piece-movement-progression1.91 KB

View saved version →

---
name: piece-movement-progression
description: Build a short progression of movement, blocker and capture exercises for one chess piece. Use for repeated movement practice such as three knight exercises; do not use for a complete introduction to chess or full-rule tactics.
---

# Piece movement progression

1. Identify one piece, the user's experience and any requested session length. Default to three short stages when unspecified. Use plain language and introduce coordinates through the displayed board when needed.
2. Call `start-workshop` with `opponent: false` and a small practice FEN. Begin with an isolated movement target. Add verified `steps` and `strict: true` only if a guided demonstration is needed; otherwise omit steps to let the user choose.
3. Wait for the attempt, question or Finished follow-up. Use active moves to identify the one movement rule that needs attention. The model does not see rejected taps or attempted illegal moves, so ask what happened when history does not explain the difficulty.
4. Open the next board only after that interaction. Add a blocker or capture appropriate to the piece; explain that knights jump while sliding pieces cannot pass through blockers. For pawns, separate forward movement from diagonal capture and supply promotion when a scripted step reaches the last rank.
5. Finish with a fresh independent challenge without `steps`. Review the visible attempt and give one movement reminder. Repeat or simplify a stage rather than advancing solely because the user pressed Finished.

Practice mode permits missing kings and repeated moves by the chosen colour, but disallows king capture, castling and en passant and ignores check and game endings. Label these exercises as isolated movement practice. Use full-rule `opponent: true` workshops for king safety or special-move legality instead. Keep tasks short, use no permanent progress claims and do not repeat displayed instructions in chat.

Referenced files: 1 — file references are metadata, not package contents.

post-game-chess-review2.3 KB

View saved version →

---
name: post-game-chess-review
description: Review a Chess app game and turn its move history into focused, practical lessons. Use when the user asks for a post-game review, recap, mistake analysis, turning points, or advice after finishing or abandoning a game. Ground the review in model-visible game state and do not present model judgments as Stockfish analysis.
---

# Post-Game Chess Review

## Inputs

Read the current widget's model-visible `difficulty`, `fen`, `moves`, `phase`, `turn`, `inCheck`, and `outcome`. Use any user-supplied goal, such as opening play, tactics, or time-independent decision making, to focus the review.

If no usable move history is available, ask the user to provide the game or reopen its widget. If the game is still active, clearly label the response as a review so far.

## Workflow

1. Establish the game context: difficulty, completion status, result, ending reason, and move count.
2. Reconstruct the game's story from the SAN and coordinate move history. Divide it into opening, middlegame, and endgame only when the moves support those phases.
3. Select two to four instructive decision points. Anchor each point to an exact move number and SAN move.
4. For each decision point:
   - Describe what changed.
   - Explain the practical danger or opportunity.
   - Offer a better plan or a concrete alternative only when confident it is legal.
   - Tie the moment to a reusable chess concept.
5. Identify at least one thing the user handled well. Avoid making the report a list of faults.
6. Finish with two or three prioritized lessons and one specific practice suggestion.

## Output

Use this compact structure:

1. **Game at a glance** — result, difficulty, and one-sentence story.
2. **Key moments** — move-anchored explanations.
3. **What worked** — one or more strengths.
4. **Next-game priorities** — two or three actionable lessons.
5. **Practice** — one focused exercise or theme.

## Boundaries

- Do not invent moves, positions, clock information, player ratings, or causes not present in the state.
- Do not use numeric evaluations, engine labels such as forced best move, or claims that Stockfish judged a move a blunder.
- Prefer positional plans over a concrete variation when legality is uncertain.
- Do not call `start-game`; keep this skill focused on reviewing the available game.

Referenced files: 1 — file references are metadata, not package contents.

special-move-rule-lab1.86 KB

View saved version →

---
name: special-move-rule-lab
description: Teach castling, en passant or promotion through a prediction, board demonstration and contrasting example. Use when a user is confused about when a special move is legal, rather than requesting a general beginner course.
---

# Special move rule lab

1. Identify the rule and the user's misconception. Start with one concrete prediction about a small position rather than a complete rules lecture.
2. Construct or verify a legal six-field FEN with both kings. Call `start-workshop` with `opponent: true`, a short task and optional validated `steps` for the demonstration. Include the promotion piece when needed. Set the user's side and FEN turn consistently.
3. Preserve the rule's relevant history metadata: castling rights require the original king and rook squares; en passant requires the immediately preceding double pawn move, correct target and zero halfmove clock. Do not add rights merely because pieces stand on their original squares.
4. After the user predicts or tries the move, explain the applicable condition. Create a contrasting full-rule workshop that changes one relevant condition, omitting `steps` for an independent legality check. An illegal move cannot be supplied as a scripted step; ask the user to report whether it is offered and explain why.
5. Review the visible attempt or report, then ask for the rule in the user's own words. Deliver one practical rule and one counterexample; stop or adapt if the user remains unsure.

Use full rules even for isolated castling or en passant lessons: practice mode disables both, ignores check and cannot teach king safety. Distinguish a missing legal target from a recorded attempted illegal move; the model sees only published legal history. Do not claim to observe taps, move the pieces for the user or automatically grade their explanation. Avoid repeating the widget's displayed content.

Referenced files: 1 — file references are metadata, not package contents.

workshop-debrief-and-retry2.03 KB

View saved version →

---
name: workshop-debrief-and-retry
description: Review a completed or off-track chess workshop and create one focused retry. Use for Finished follow-ups or 'I went off the steps, help me retry'; do not use for a full match review or a new exercise without prior workshop context.
---

# Workshop debrief and retry

1. Read the identified workshop's model-visible title, instructions, notes, initial/current FEN, active moves, rules, completion flag and step progress. If the task or relevant state is unavailable, ask for it; do not inspect private restoration or redo state.
2. Compare the attempt with the task. For scripted work, distinguish on-track, astray and complete using published progress and first deviation. Going off the line does not establish that a move is bad; Finished does not establish success.
3. Select one observed difficulty and explain the consequence with position-specific evidence. Use only available evaluations tied to the relevant position, and label inference. Under piece-practice rules, do not infer checkmate or standard-rule legality from completion.
4. Offer one correction. If the current workshop remains active, explain how the user can Undo or Reset to retry; do not claim to press those controls. A Finished workshop is locked, so use a fresh board for further play.
5. When a fresh retry is requested or accepted, call `start-workshop` from the original or an appropriate verified intermediate position. Retain the relevant rules and side. Reduce the task to the identified difficulty; omit `steps` for independent testing or use a short guided line when the user needs a demonstration.
6. After the retry, compare only observed attempts and leave one next action. Keep the deliverable to a brief debrief and a focused practice opportunity.

Do not invent unreported mistakes or a full planned line from progress alone. Use earlier visible tool arguments when a scripted line is needed; if unavailable, request it or design a verified new exercise. Keep mobile instructions short and do not duplicate widget content after rendering.

Referenced files: 1 — file references are metadata, not package contents.

Release notes

- Added a workshop for learning and training. - Improved graphics - Better handoff to ChatGPT

Declared in the saved package. Remote tools may change independently.

Package details

Publisher declarations from the archived package. These are separate from our research and the live service's terms.

Package author
Widget
Declared availability
No country restrictions declaredDeclared regions; live availability may differ.
Listing translations
ar, cs, da, de, es, fa, fr, he, hi, hu, id, it, ja, ko, nb, nl, pl, pt, ru, sv, th, tr, vi, en-US, fr-CA, pt-BR, zh-CN, zh-HK, zh-SG, zh-TW
Commerce declaration
Does not support commerceThis does not establish whether access is free or paid.
Review scenarios
5 positive · 3 negativeScenario counts, not test results.

Declared capabilities

  • Play chess against an AI opponent with selectable colour and difficulty.
  • Set up verified FEN positions for games or workshops.
  • Practise piece movement, blockers, captures, and promotion on custom boards.
  • Learn chess rules, tactics, gambits, and endgame ideas through guided workshops.
  • Follow validated move sequences with hints, strict mode, undo, redo, and progress tracking.
  • Ask ChatGPT for chess hints, advice, move explanations, and position analysis.

Package observed Nov 21, 2026.

Technical details
First seen
Sep 30, 2026 · 22:02 UTC
Last seen
Nov 21, 2026 · 12:00 UTC
Latest observed change
Nov 12, 2026 · 12:08 UTC
Collection status
Collected

plugin_asdk_app_69c28d6aedac81919502a88c2179e20c

Download plugin data (JSON)

Plugin details: served from cache. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.