agent sidequestsIdeas worth trying

Check that your AI-built board game follows your rules

Before asking your agent to rebalance your board game, check one turn against the rule you wrote. Fix the starting position, choose the action and work out the next position and score yourself. Compare that answer with the prototype. A disagreement needs diagnosis; a legal move that feels dull needs a design conversation. This guide gives you a small turn sheet and a way to keep those decisions separate.

Bring one rules version and a playable copy

Use this when an agent has built a digital version of your own tabletop game and something feels wrong: a score changes unexpectedly, a player moves twice, or the game ends too early. Bring the written rules, the exact playable revision, one puzzling turn and the device where you saw it. Preserve that revision while investigating.

In an October 11 Defold forum post, schlista describes an AI-built browser playtest for a physical game, with feedback tied to the moment of play. The author calls it unfinished and notes readability trouble on mobile. This is a creator self-report, not our test of the game. It motivates keeping a report tied to a specific turn; it does not establish that the game has a rules bug.

Our turn sheet below is an original, untested review method. The fictional game and all reported outcomes are illustrative. You are checking a particular rule in your prototype, not evaluating the general quality of an AI model.

Write the expected turn before asking the code

For each check, record the rules version, starting positions, scores, player to move, chosen action and expected result. Include every fact the rule needs. If the game uses a deck or dice, fix the relevant draw or roll for this check instead of letting chance change the case.

Derive the expected answer from the written rule. Work it out on paper, or ask the agent to explain it and then confirm the reasoning yourself. Do not let the current game code supply both its actual result and the answer it is being checked against. If the rule permits two interpretations, record a question for the designer before declaring either result wrong.

A worked turn sheet: Parcel Loop

Parcel Loop is invented solely for this example. Two players move around spaces numbered 0, 1, 2, 3 and 4, wrapping from 4 to 0. On your turn, choose a move of 1, 2 or 3 spaces. Each crossing from 4 to 0 earns one point. Turns alternate after a valid move. Reaching three points ends the game immediately; no further move is allowed. An out-of-turn action changes nothing. Players may share a space.

Check these cases independently, resetting to the listed start each time. B begins on space 2 with zero points in every case; the game is unfinished at the start. These are expected answers derived from the fictional rules, not observed test passes.

An illustrative turn sheet with independently worked expected answers
Check and starting stateChosen actionExpected result
Ordinary move: A on 1, zero points; A to moveA moves 2A on 3, zero points; B to move. B unchanged.
Crossing: A on 4, zero points; A to moveA moves 2Path 4 → 0 → 1. A on 1 with one point; B to move. B unchanged.
Wrong player: A on 1, one point; B to moveA attempts to move 3Reject the action. All positions and scores stay the same; B still to move.
Winning move: A on 3, two points; A to moveA moves 2Path 3 → 4 → 0. A on 0 with three points; A wins immediately. B unchanged; no next turn.

Compare the stored result and the visible board

Run the same starting case in the exact prototype. If it supports a saved position or a test setup, ask the agent to use that. Otherwise, record a reproducible sequence of legal moves to reach the position. If neither is available, keep the runtime check pending; a paper walkthrough alone does not establish how the app behaves.

For the crossing case, imagine the screen puts A on space 1 but still shows zero points. Save the before-and-after view and the action. If the prototype exposes a game log or saved state, compare it too. A recorded score of one with a visible zero points toward a display mismatch. A recorded zero also disagrees with the expected result. Without that evidence, report the visible mismatch and leave the cause unresolved.

In an October 18 Qiita account, mitsuoL describes AI-assisted game design and implementation, specific rules tests, automated bot matches and personal play with revisions. Those are the creator’s reported practices, not our execution or validation. We do not adopt the reported performance figures or treat bot matches as human enjoyment evidence.

Choose the right kind of change

Keep four kinds of finding separate. This prevents an agent from changing a point value merely to hide a scoring bug, or rewriting the rules to match an accidental implementation.

  • A single passing turn does not clear the whole game. Include the scoring boundary, an illegal move, the end condition and any special interaction relevant to the reported problem.
  • If you cannot see the stored state, do not invent a root cause. The visible behavior and exact steps are still a useful report.
  • If two written rules conflict, preserve both quotations in your private working notes and ask which takes precedence. Do not silently choose the interpretation that makes the current app pass.
Different findings need different next decisions
FindingExampleNext step
Implementation mismatchThe agreed crossing earns one point; the stored result earns none.Preserve the rules. Reproduce the turn and repair the implementation.
Display mismatchThe stored result earns one point; the board still displays zero.Preserve scoring. Repair the visible update and check the actual screen again.
Unclear ruleYour own rulebook says first to three wins, but never says whether the other player finishes the round.Ask the designer to choose. Revise the written rule and expected cases before coding.
Legal but disappointing playMoves match the agreed rules, but a person reports that their choices feel repetitive.Record the particular session and reaction. Propose one design change as a separate experiment.

Repair once, then repeat the same cases

Give the agent a bounded request: In build 7 under Parcel Loop rules v1, A starts on 4 with zero points and moves 2. Expected: A on 1 with one point, B to move. The screen shows A on 1 with zero points. Inspect the recorded state before choosing a fix. Preserve the rules and unrelated behavior, return a new build, and repeat this case plus the ordinary move, wrong-player and winning-move checks. This request is illustrative, not a record of an actual defect.

Keep the original revision and the repaired copy labeled. Report each case as passed, failed or not run, with what was actually inspected. If the agent can edit code but cannot operate the game, have it leave the screen checks for you. Check the device where the problem occurred; a desktop code test does not establish a readable, working phone interface.

Only then ask whether the game is fun

Once the relevant rule checks agree, play a short session and record where a real player hesitated, what they tried and what they said. Separate that reaction from your proposed remedy. For example: the player repeatedly chose the longest move and reported that choosing felt pointless. That can motivate a new choice or tradeoff; it does not prove which redesign will help.

Keep bot-only sessions labeled, including their decision policy or difficulty if known. They can generate situations to inspect, but they cannot supply a human preference. Compare design versions with the same rules checks and record any changed expectations; do not mix results from different rule versions as though they were one game.

Finish with a small handoff: current rules and build, the turn sheet, actual observations, unresolved questions, and one next decision. For Muse, Instinct, Dots or Grok Bot, verify that your account can read your files, edit the prototype and operate its interface before delegating those steps. With text-only access, use a paper board and have the agent organize your notes; label app checks not run. No public launch or multiplayer account setup is needed for this review.

Copy a prompt and try it

Each idea has a complete starter prompt, the inputs to bring, and the tools it needs.

Common questions

Can an AI agent tell me whether my board game is balanced?

It can help inspect rules, organize observations and run supported simulations. First check that the implementation follows the intended rules. Bot results depend on the agents and settings used; they do not establish how real players will experience the game. Keep human feedback separate.

What if the rulebook and the prototype disagree?

Record the exact rule, starting state, action and result. Ask the designer to resolve ambiguous or conflicting wording. Once the intended rule is clear, repair the prototype or explicitly approve a rule change; do not silently rewrite the expected answer to make the code pass.

Do I need to know how to code to check a turn?

No. You can work out the expected move and score with paper pieces and compare the visible result yourself. A coding-capable agent can investigate the mismatch. If the underlying game state is unavailable, report the visible problem without claiming to know its cause.

Sources and further reading

These are practical editorial examples. The prompts have not been independently run-tested across every assistant.

Keep exploring

For platform setup, read the Muse, Instinct, Dots and Grok Bot guides.