If you are the person who teaches a new board game, AI is most useful before game night—not as a rules authority at the table, but as a fast way to turn a dense rulebook into material you can actually teach from.
The safest workflow is source-grounded: give the tool the publisher's rulebook, add any official FAQ or errata, require a page or section reference for every ruling, and leave disagreements unresolved until you check the source yourself.
In about 45 minutes, you can build four useful assets: a first-turn rules map, a short teaching script, an edge-case lookup table, and a set of practice scenarios.
Capability check — August 8, 2026: Google currently documents that NotebookLM can accept PDFs, DOCX files, pasted text, web URLs and other supported source types, and its chat can answer from selected sources with inline citations. Google lists a free-user source limit of up to 50 sources per notebook. OpenAI documents ChatGPT Projects as available across free and paid subscriptions, with files, chats and project instructions kept together; file-upload availability and limits vary by plan and account. You do not need a paid tool for this workflow: a publisher-provided rulebook plus a free source-grounded notebook or pasted-text chat is enough for a small game.
1. Build the “before turn one” rules map
Outcome: A one-page map of the rules players must understand before anybody makes the first meaningful decision.
Best fit: The person hosting or teaching a medium-to-heavy game for players who have not read the rulebook.
Inputs and tools: The official rulebook PDF or text, plus the publisher's official FAQ or errata if one exists. NotebookLM is convenient because answers can point back to source locations; a general AI assistant also works if you paste only the relevant sections and verify them manually.
Do not begin by asking for a complete summary. A complete summary often gives equal weight to setup trivia, rare exceptions, core actions and end-game scoring.
Instead, ask the AI to sort the rules by when a new player needs them:
- objective and how the game ends;
- what a turn or round looks like;
- actions a player can choose;
- resources, limits or costs that constrain those actions;
- what must be understood before the first decision;
- rules that can wait until they first become relevant;
- scoring details that can safely be explained later.
Useful interaction pattern:
Use only the selected rulebook and official FAQ/errata. Build a “before turn one” rules map with: objective, game-end trigger, turn/round sequence, player actions, important limits, resources/costs, and scoring concepts. For every rule, cite the page, section, or source location. Put optional or rare exceptions in a separate “teach later” section. If the sources do not answer something, write NOT FOUND. Do not fill gaps from general board-game knowledge.
Then open every cited section for the core turn structure and compare it with the original rulebook.
Time and cost: About 10 minutes. NotebookLM has a free route within its current usage limits; pasted text in a free general-purpose AI account is another option where account limits permit.
Limits: A citation tells you where the model found support; it does not guarantee the model interpreted the rule correctly. Rulebooks that rely heavily on diagrams, iconography, player boards or visual examples need extra manual checking. If the PDF contains a rule only inside an image or diagram, do not assume the AI extracted it.
2. Turn the map into a seven-minute teaching script and first-round card
Outcome: A conversational teaching order plus a tiny reference card players can use during the first round.
Best fit: Hosts who understand the game but tend to over-explain every exception before play begins.
Inputs and tools: The verified rules map from step one. No additional paid feature is required.
Ask the AI to create a teaching sequence, not another summary. The script should tell players what they are trying to do, what happens on a normal turn, what choices they can make, and what information they need before choosing.
Keep rare exceptions out of the opening explanation unless a player could make an irreversible bad decision without knowing them.
For the first-round card, restrict the content to things players may genuinely need to look up immediately:
| First-round reference | Example shape |
|---|---|
| Turn order | Phase A → Phase B → Phase C |
| Available actions | Action name + one-line effect |
| Main limits | Hand limit, action cap, placement restriction |
| Common cost | Resource or payment reminder |
| End of round | What resets, scores, or passes |
| Source | Page/section for checking |
The exact entries must come from your game's sources—not from this generic table.
Useful interaction pattern:
Using only the VERIFIED rules map, write a teaching script designed to be spoken in about seven minutes. Order it by what players need before their first decision. After the script, create a first-round reference card with only turn order, available actions, common limits/costs, and end-of-round steps. Add the source page/section beside every rule. Do not add strategy advice, house rules, or uncited exceptions.
Read the script aloud once. Any sentence that sounds like rulebook prose should be simplified, but the meaning must remain unchanged.
Time and cost: About 12 minutes, including a spoken run-through. A text-only free route is sufficient.
Limits: AI can make a rule easier to read by accidentally making it less precise. Pay special attention to words such as may, must, up to, exactly, before, after, and once per round. Also avoid publishing or sharing large copied passages from a copyrighted rulebook; use the output as your own short teaching aid and paraphrase where possible.
3. Build an edge-case lookup that separates official rules from table rulings
Outcome: A fast reference for the questions most likely to stop play, without pretending an AI guess is an official ruling.
Best fit: Games with timing windows, exceptions, card interactions, simultaneous effects, unusual scoring cases, or updated errata.
Inputs and tools: The rulebook plus any current official FAQ/errata. If the publisher has an official rules page, add or check it separately before the session.
Create a lookup table like this:
| Question | Rulebook answer | Rulebook source | FAQ/errata answer | Status |
|---|---|---|---|---|
| Can X happen after Y? | ... | p./section | ... | Confirmed / conflict / not found |
The important column is Status.
If two official sources appear to disagree, the AI should not quietly choose the answer that sounds more plausible. It should surface the conflict. If no official source answers the question and your group decides to keep playing, record the decision as a house ruling, not an official rule.
Useful interaction pattern:
From these sources, identify 10 rules interactions or timing questions that are likely to require lookup during play. For each, show the exact question, a concise answer, the supporting page/section, and whether the answer comes from the base rulebook or official FAQ/errata. If sources conflict, show both and mark CONFLICT. If neither source answers it, write NOT FOUND. Never turn an inference into an official ruling.
Before game night, skim the publisher's current support/FAQ page again if the game receives ongoing errata.
Time and cost: About 10 minutes. A source-grounded free notebook is enough for one rulebook and a small FAQ.
Limits: Community answers can be useful clues, but they should not silently outrank the publisher's rules or official errata. If you add forum discussions, label them separately as community interpretations. The publication date of an FAQ matters when it changes an older rulebook.
4. Generate practice scenarios that test the host, not the players
Outcome: A quick rehearsal that exposes the rules you still cannot explain confidently before everyone arrives.
Best fit: The host who has read the rules once but has not yet played, or anybody teaching a game with many conditional interactions.
Inputs and tools: The verified map and edge-case table.
Ask the AI to create short game-state questions that force you to retrieve the rule rather than simply recognise its wording.
For example, each practice card can contain:
- a short hypothetical game state;
- one rules question;
- your answer first;
- the expected ruling;
- the source page or section;
- a note explaining the common confusion.
The AI should not test trivia. Prioritise turn order, action legality, costs, limits, scoring triggers, timing, and the edge cases you marked as likely to interrupt play.
Useful interaction pattern:
Create eight short practice scenarios using only rules supported by the selected sources. Focus on turn order, legal actions, costs, limits, scoring triggers, and the edge cases in my lookup table. Ask me one scenario at a time and wait for my ruling before revealing the answer. After I answer, show the official source location and explain only the rule I missed. If a scenario depends on an unsupported or ambiguous assumption, discard it instead of inventing a ruling.
If the scenario itself seems impossible under the game rules, check it before learning from the answer. Models can create illegal game states even when the final explanation sounds convincing.
Time and cost: About 10 minutes. This works in ordinary text chat; voice is optional and unnecessary.
Limits: Synthetic scenarios are rehearsal, not evidence that every interaction has been covered. The rulebook and official updates still win when the real table produces a situation your practice set did not anticipate.
A 45-minute pre-game workflow
| Activity | Time |
|---|---|
| Build and verify the before-turn-one map | 10 min |
| Create the teach script and reference card | 12 min |
| Build the edge-case lookup | 10 min |
| Rehearse eight practice scenarios | 10 min |
| Final source check | 3 min |
At the end, you should have something much more usable than a 40-page AI summary: a short sequence to teach, a reference players can glance at, a lookup for awkward cases, and a list of the rules you personally need to review.
Keep the source hierarchy visible
A simple hierarchy prevents most AI-created rules arguments:
- Current official errata/FAQ, when it explicitly updates the rulebook.
- The official rulebook for the edition you are playing.
- Official publisher/designer clarification, when clearly attributable and applicable.
- Community interpretation, labelled as such.
- Your group's house ruling, useful for keeping the session moving but never presented as official.
Do not ask the model to blur those categories into one confident answer.
For privacy, board-game rulebooks usually contain little personal information, but the same basic upload discipline still applies: use publisher-provided or otherwise lawfully obtained files, do not upload leaked material, and do not include private group chats or personal details unless they are necessary. Review the AI service's current data controls before uploading anything sensitive.
For copyright, source grounding does not create redistribution rights. A private quick-reference sheet in your group is different from posting a near-complete rewritten rulebook online. Keep quotations short, prefer your own concise paraphrases, and follow the publisher's licence and permissions if you plan to distribute the material publicly.
Conclusion
AI does not need to become the rules judge to be useful on game night.
Use it earlier: make it index the rulebook, force it to cite the source, separate core rules from teach-later exceptions, expose contradictions, and quiz you on the parts most likely to stop play.
The host still verifies the rules. The players just get a faster start and fewer “give me five minutes while I search the PDF” interruptions.
Sources
Checked August 8, 2026: