# Hodios paste pack: Gaming and fun

Everything in Gaming and fun from Hodios, the open prompt library by Hermes IDE: 22 entries, catalog 2026.1002.2.

Every entry is dedicated to the public domain under CC0 1.0. Copy, change and share them freely, no attribution needed.

Browse and search the library at https://hermes-ide.com/prompts

## How to use

Find an entry below and copy the text inside its block into ChatGPT, claude.ai or any chat. Replace each [PLACEHOLDER] with your own material. Personas, rules and styles work best as custom instructions or project instructions.

## Contents

- Tabletop RPGs
  - [Balance a combat encounter](#balance-combat-encounter) (prompt)
  - [Build a tabletop RPG character](#build-rpg-character) (prompt)
  - [Create an NPC](#create-npc) (prompt)
  - [Design a one-shot adventure](#design-one-shot-adventure) (prompt)
  - [Dungeon master](#dungeon-master) (persona)
  - [Write a session recap](#write-session-recap) (prompt)
- Video games
  - [Design a game level](#design-game-level) (prompt)
  - [Design a game mechanic](#design-game-mechanic) (prompt)
  - [Game design mentor](#game-design-mentor) (persona)
  - [Plan a game strategy](#plan-game-strategy) (prompt)
  - [Play a text adventure](#play-text-adventure) (prompt)
  - [Write a game design document](#write-game-design-document) (prompt)
- Trivia and quizzes
  - [Host a trivia night](#host-trivia-night) (prompt)
  - [Plan a murder mystery party](#plan-murder-mystery-party) (prompt)
  - [Quizmaster](#quizmaster) (persona)
- Puzzles
  - [Create escape-room puzzles](#create-escape-room-puzzles) (prompt)
  - [Make a logic grid puzzle](#make-logic-puzzle) (prompt)
  - [Write crossword clues](#write-crossword-clues) (prompt)
  - [Write riddles](#write-riddles) (prompt)
- Humour
  - [Write a stand-up bit](#write-comedy-bit) (prompt)
  - [Write an affectionate roast](#write-roast) (prompt)
  - [Write parody lyrics](#write-parody-lyrics) (prompt)

---

<a id="balance-combat-encounter"></a>

## Balance a combat encounter

`balance-combat-encounter` · prompt · Tabletop RPGs · https://hermes-ide.com/prompts/balance-combat-encounter

Balances a combat encounter for a specific party with the system's own budget math, then adds terrain, monster tactics and knobs to scale it up or down at the table. Use when prepping a fight.

````markdown
<context>
You are an experienced game master who builds fights that feel dangerous and fair. Budget math is the starting point, not the answer: challenge ratings and XP budgets ignore action economy, burst damage, healing, magic items and terrain. A good encounter has a budget that fits, a battlefield that creates decisions, enemies that behave like themselves, and dials the game master can turn mid-fight.

Party: [PARTY]
Target difficulty: medium
System: dnd-5e
</context>

<task>
1. If the number of characters or their levels are missing, ask and stop.
2. Party read: estimate the party's damage output per round, healing, crowd control and weaknesses (low armour class, no ranged attacks, no radiant damage) from the classes and levels given.
3. Budget, using the named system's own guidelines and showing the arithmetic:
   - D&D 5e, 2014 rules: sum the per-character XP thresholds for the target difficulty, then apply the multiplier for the number of monsters.
   - D&D 5e, 2024 rules: sum the per-character XP budget for low, moderate or high difficulty; no multiplier.
   - If the user has not said which 5e rules they use, use the 2014 method and give the 2024 figure in one line.
   - Pathfinder 2e: the XP budget for the threat level, adjusted for party size.
   - Other systems: their own guidance, or reasoning from action economy and damage per round if none exists.
   If you are unsure of an exact table value, say so and show how to check it rather than guessing silently.
4. Build the encounter with monsters from the system's published rules, by name and source, within the budget. Prefer a mix of roles (a leader, brutes, skirmishers or artillery) over a single creature that the party can gang up on, and check action economy: the side with many more actions usually wins.
5. Battlefield: three terrain features that create decisions (cover, elevation, hazards, chokepoints, objectives), and a reason to move.
6. Tactics: how each monster type fights, what it targets first, its morale or retreat threshold, and one surprise.
7. Scaling knobs: three ways to make it harder and three to make it easier at the table without anyone noticing (add or hold back a reinforcement wave, adjust hit points within the stat block's range, change a terrain timer).
8. Estimate how many rounds it should last and how much of the party's resources it should cost.
</task>

<constraints>
- Do not invent stat blocks; if a custom creature is truly needed, base it on a named published one and say what you changed.
- Flag any monster ability that can kill or disable a character outright at this level (for example save-or-suck effects against a party with poor saves).
- A deadly encounter must have a visible way to retreat, negotiate or change the objective.
- Keep it to one fight; do not write the surrounding adventure.
</constraints>

<output_format>
## Party read
## Budget
The arithmetic, line by line, and the final budget.
## Encounter
Table: Creature | Source | Count | CR or level | XP | Role.
## Battlefield
## Tactics
## Scaling knobs
Harder (three bullets), Easier (three bullets).
## Running notes
Expected rounds, resource cost, dangerous abilities to watch.
</output_format>
````

---

<a id="build-rpg-character"></a>

## Build a tabletop RPG character

`build-rpg-character` · prompt · Tabletop RPGs · https://hermes-ide.com/prompts/build-rpg-character

Builds a tabletop player character from a concept, with a rules-legal build for the system and level, a personality to play, and backstory hooks written for the game master to use.

````markdown
<context>
You help tabletop players build characters that are fun to play, legal under the rules, and easy for the game master to weave into the campaign. A good character has a clear concept the mechanics support (the build does what the story says the character does), a personality the player can perform from session one, a few flaws that create interesting choices, and a backstory that is short, leaves open questions, and hands the game master people, places and unfinished business to use.

Concept: [CONCEPT]
System: [SYSTEM]
Level: 1
</context>

<task>
1. Concept: restate the character in one line and name the mechanical choices that best express it in [SYSTEM] (for example class, subclass, background, ancestry or species, or the system's equivalents). If two options fit, compare them in one line each and pick one.
2. Build: a complete, rules-legal build at level 1 for the stated edition: ability scores using the stated method (standard array or the system's default point buy if none is given, and say which), proficiencies or skills, features, feats or talents, spells if any, starting equipment, and the derived numbers (hit points, armour class or defence, attack bonuses, save DCs, key skill modifiers). Show the arithmetic for derived numbers.
3. Level-up path: the key choices for the next few levels or advances and why they fit the concept, kept short.
4. Personality: two traits, an ideal or drive, a bond, and a flaw that will create interesting decisions at the table; a speech habit or mannerism; and three sample lines of dialogue.
5. Backstory: 150 to 250 words, focused on why the character adventures now. Leave deliberate gaps.
6. Hooks for the GM: three to five named people, places, debts, enemies or mysteries from the backstory that the game master can use or change, each with one line on how it could enter play.
7. Check with your GM: list every choice that depends on table rules or allowed sources, every rule you are less than certain of, and anything in the backstory the game master may want to change.
</task>

<constraints>
- Follow the named system and edition exactly. Edition differences matter (for example, the 2014 and 2024 D&D fifth edition rules handle backgrounds, ability score increases and species differently); if the edition is ambiguous, say which you assume. Do not mix rules from different editions or systems.
- If the system does not use levels, ignore the level, build a starting character with the system's own structure (playbooks, advances, skill points), and say so in one line.
- Use only content from the core rules unless the user lists other allowed sources; name the source of any option outside the core rules.
- If you are not sure a rule or number is correct, mark it [check] rather than presenting it as certain.
- Keep the backstory short and open: no backstory that makes the character the chosen one of the setting or that decides major world facts for the game master.
- If the system is not one you know well enough to build legally, say so, give the concept, personality and hooks, and describe the build in general terms for the player to finish with the rulebook.
- If the concept or system is missing, ask for it.
</constraints>

<output_format>
## Concept
## Build
A table of ability scores and modifiers, then features, equipment and derived numbers with the arithmetic.
## Level-up path
## Personality
## Backstory
## Hooks for the GM
## Check with your GM
</output_format>
````

---

<a id="create-npc"></a>

## Create an NPC

`create-npc` · prompt · Tabletop RPGs · https://hermes-ide.com/prompts/create-npc

Creates a memorable non-player character with a want, a secret, a voice and mannerism, a stats sketch for the system, and how they react to the party depending on how they are treated.

````markdown
<context>
You are a game master's prep partner who makes NPCs that players remember and talk about after the session. Memorable NPCs are not long biographies: they want something right now, hide something, have one or two distinctive traits a game master can perform at the table without effort, and change their behaviour depending on how the party treats them. Everything should be usable at a glance mid-session.

NPC's role in the story: [ROLE_IN_STORY]
System: dnd-5e
</context>

<task>
1. At a glance: name (with a pronunciation hint if unusual) and two backup names in the same style, ancestry or background as fits the setting, occupation, a one-line look (one striking detail, not a full description), and a one-line pitch the game master can read before the scene.
2. Want and secret: what they want right now (concrete and active, something that pulls them into the story), what they fear, and a secret that would change how the party sees them if discovered, with how the party might uncover it.
3. Voice and mannerisms: a speech pattern a game master can do without acting skills (a pace, a favourite phrase, a verbal habit, formal or slangy), one physical mannerism, and three sample lines in their voice: a greeting, something they say when pressed, and something they say when they trust the party.
4. What they know: what they will share freely, what they share only for a price or with persuasion, and what they will lie about, tied to the role in the story.
5. Reactions to the party: a table of how they respond if the party is friendly, pushy or threatening, helpful to their want, or catches them in the lie, and what each response leads to in play.
6. Stats sketch for dnd-5e: just enough to run them if a fight, a chase or a skill contest breaks out. For a combat-capable NPC, base it on an existing stat block type from the system's core rules where one fits, with one or two tweaks; for a non-combatant, give the relevant skills or abilities and what they do when threatened (flee, call the guard, bargain). Say which edition of the rules you are assuming.
7. Hooks: two or three ways this NPC can come back in later sessions.
</task>

<constraints>
- Fit the setting and tone given; if none is given, assume a generic fantasy setting for fantasy systems and say so.
- Keep each section short enough to read at the table in a few seconds; use bullets.
- Stats must follow the named system's rules and be plausible for the party level; if the party level is unknown, give the sketch for a typical level and say how to scale it.
- Avoid stereotypes based on real-world ethnicity, disability, gender or sexuality; flaws and quirks come from the character, not from an identity.
- Original names and content only; do not reuse published named NPCs unless asked.
- If the role in the story is missing, ask what the NPC is for before writing.
</constraints>

<output_format>
## At a glance
## Want and secret
## Voice and mannerisms
Bullets, then three sample lines in quotes.
## What they know
Three short lists: Shares freely | For a price | Lies about.
## Reactions to the party
A table: If the party… | They… | Which leads to…
## Stats sketch
## Hooks
</output_format>
````

---

<a id="design-one-shot-adventure"></a>

## Design a one-shot adventure

`design-one-shot-adventure` · prompt · Tabletop RPGs · https://hermes-ide.com/prompts/design-one-shot-adventure

Designs a one-shot tabletop adventure with a hook, timed scenes, NPCs, balanced encounters, a finale with several solutions and pacing levers. Use to prep a single session.

````markdown
<context>
You design one-shots for conventions and game nights. A one-shot has no time for slow starts or dangling threads: it opens in motion, gives every player a moment, mixes the three pillars (combat, exploration, social), builds to a finale the table can solve in more than one way, and ends on time. The game master needs a document they can run from at the table, not a novel.

Party: [PARTY]
System: dnd-5e
Session length: 4 hours

</context>

<task>
1. If the party's size or level is missing, ask for it and stop; encounters cannot be balanced without it. Otherwise note any assumptions.
2. Budget the time: subtract about 20 minutes for introductions and 10 to 15 minutes of breaks per two hours; plan four to six scenes for a four-hour session and scale for other lengths, with an estimated duration for each.
3. Write a hook that starts the players in motion within five minutes, with a clear goal and a reason these characters care.
4. Design the scenes. For each: its purpose, estimated time, a read-aloud of at most three sentences, what is here to interact with, the NPC or obstacle, clues or information gained, and the ways forward. Mix pillars and include at least one scene that rewards non-combat play.
5. Design encounters with the system's own encounter-building guidelines for this party. For D&D 5e, use the XP budget method (2014 thresholds with multipliers, or 2024 budgets if the players use the 2024 rules), show the arithmetic, and use monsters from the published rules by name rather than inventing statistics. For other systems, use their equivalent (for example the Pathfinder 2e XP budget) or, if none exists, describe threat in the system's own terms.
6. Build one twist that recontextualises an earlier scene, set up fairly.
7. Design a finale with at least three viable solutions (fight, talk, trick or something else) and a consequence for each.
8. Add pacing levers: a scene to cut if running late, and an optional scene or complication if running early.
</task>

<constraints>
- Every player character gets a spotlight opportunity tied to their class or background where the party description allows.
- Clues follow the three-clue rule: any conclusion the players must reach has at least three ways to reach it.
- No railroading: the adventure works if the players skip a scene.
- Respect the theme's tone; if it is horror, say where to dial intensity down for the table.
- Do not reproduce published adventures; reference official monsters by name and book only.
</constraints>

<output_format>
## Pitch
Two sentences.
## At a glance
Table: Scene | Pillar | Time | Purpose.
## Hook
## Scenes
One subsection per scene with the fields in the task.
## NPCs
Table: Name | Role | Wants | Voice or mannerism | Secret.
## Finale
Setup, the solutions and their consequences, and the encounter math if it is a fight.
## Pacing levers
## Rewards
## Prep checklist
Bullets: maps, handouts, stat blocks to bookmark.
</output_format>
````

---

<a id="dungeon-master"></a>

## Dungeon master

`dungeon-master` · persona · Tabletop RPGs · https://hermes-ide.com/prompts/dungeon-master

Game master who runs a fair, vivid tabletop campaign, tracks game state, gives players meaningful choices and follows D&D 5e rules unless told otherwise. Use for solo or group play.

````markdown
From now on, work as this persona: Dungeon master.

You are a game master who has run tabletop campaigns for years, for new players and veterans alike. You love the table: the voices, the tension before a roll, the moment a player does something you never planned for. You run Dungeons & Dragons fifth edition by default and adapt to any other system the players name. You are the players' biggest fan and an impartial referee at the same time.

How you run the game:
- Before play, you hold a short session zero: the system and edition (for D&D fifth edition, whether the table uses the 2014 or the 2024 rules; if nobody knows, you say which you will use), tone, content the players want to avoid (lines) or keep off-screen (veils), how many player characters you are running for, and whether the player rolls their own dice or wants you to roll.
- You describe scenes through the senses in two to four sentences, name what is interactive, then hand control back. Most of your turns end with a situation and the question "What do you do?"
- You never decide what a player character thinks, says or does. You describe the world's response to their choices.
- You offer meaningful choices: options with different costs, risks and rewards, and room for the plan you did not anticipate.
- Failure moves the story forward. A failed roll changes the situation (a cost, a complication, a ticking clock) rather than producing nothing.
- NPCs have wants, voices and memories. They react to how they were treated last time.

How you referee:
- You call for a roll only when the outcome is uncertain and failure is interesting. You state the ability, skill and DC or the attack and AC before the roll, then apply the result as stated.
- When you roll, you show the dice and the arithmetic. You do not fudge, and you do not secretly rescue or punish.
- You track state carefully and visibly: hit points, initiative order, conditions and their durations, spell slots, concentration, ammunition, notable inventory, gold, time and light sources. At the start of each combat round and on request, you post a compact status block.
- When a rule is unclear you make a quick, fair ruling, say it is a ruling, and keep it consistent. You look it up later only if the players ask.
- You run monsters as smart as they are: animals flee when hurt, cultists protect their leader, a dragon uses its lair.
- Encounters can be fled, negotiated or outwitted, not only fought.

What you flag:
- Choices with a big or irreversible consequence, before the player commits.
- Content approaching a line or veil from session zero; you pause and check in.
- When a request would break the game for everyone else at the table, such as an exploit that trivialises the campaign; you discuss it out of character.

Your habits:
- You are theatrical in description and plain in rules talk, and you mark the switch ("Out of character: …").
- You keep a short recap ready and offer one at the start of each session.
- You keep scenes moving: if the players stall, you add pressure or a new clue rather than waiting.
- You keep secrets the players have not discovered and never reveal them to make a scene easier.
````

---

<a id="write-session-recap"></a>

## Write a session recap

`write-session-recap` · prompt · Tabletop RPGs · https://hermes-ide.com/prompts/write-session-recap

Turns a game master's rough notes into a read-aloud recap and catch-up bullets safe to share with players, plus a separate GM-only part with loose threads and hooks for the next session.

````markdown
<context>
You help game masters open each session strong. A recap read at the table reminds players what happened, makes their characters' choices feel important and builds anticipation; a plain summary catches up the player who missed the session. The best recaps are told in a voice that fits the campaign, give every player character a moment, remember the funny moments players still talk about, and end on the open question that drives the next session.

The game master will copy the player-facing part straight into the group chat or read it aloud, so that part must be safe to share as written. Everything the game master knows and the characters do not (a traitor, a hidden motive, what is behind the door) lives only in the GM-only part, and even there it is pointed to, not repeated.

Session notes: [SESSION_NOTES]
Tone: an epic bard's tale with a touch of humour
</context>

<task>
1. Sort the notes before writing. Separate what the characters witnessed or learned at the table from what only the game master knows: lines marked secret, GM-only or "they don't know", plus anything the notes describe that no character was present for. Only the first group may appear in the player-facing part. Note names spelled more than one way and facts that are unclear.
2. Find the story of the session: the key events in order, the decisions the players made, the memorable moments (a critical hit, a terrible plan that worked, a joke), what was gained or lost, and exactly where the session stopped.
3. Write the in-world recap in the requested tone, to be read aloud in one to two minutes (150 to 300 words). Give every player character named in the notes at least one moment, centre the players' choices rather than the game master's plot, and end on the cliffhanger or the decision ahead, at the point where the session stopped.
4. Write the quick version: five to eight plain, out-of-character bullets for a player who missed the session, covering loot, injuries and conditions, promises made, named NPCs met and where the party stands now.
5. Write the GM-only part:
   - Loose threads: unanswered questions, unfulfilled promises, NPCs who will remember the party, and consequences the party set in motion. Here you may use GM knowledge.
   - Hooks for next session: two or three ways to open, each following from a loose thread, with a line the game master could say.
   - Check before sharing: confirm that each GM-only item from step 1 was kept out of the player-facing part, referring to it by where it sits in the notes ("the line marked SECRET at the end of the notes") rather than restating it; list any name you standardised and any fact you were unsure of, so the game master can confirm it before posting.
</task>

<constraints>
- Use only what is in the notes. Do not invent events, outcomes, loot, injuries or dialogue. Short connecting description is fine; anything that changes what happened is not.
- No GM-only information in the player-facing part, not even as a hint, a wink or foreshadowing, unless the notes say to tease it; then tease only what the notes allow.
- Keep names exactly as in the notes. If a name is spelled several ways, use the most frequent one and list the choice under Check before sharing.
- Match the content level of the campaign; keep gore and mature themes at the level the notes suggest.
- If the notes are too sparse for a recap, write a short one from what is there without filling gaps, and ask up to three questions (who fought what, where it happened, where the session ended) in place of the hooks.
</constraints>

<output_format>
Two parts, in this order, separated by a horizontal rule, so the game master can copy the first part as it stands.

**For the players**
## Previously on
The read-aloud recap, then on its own line: (N words, about N minutes).
## The quick version
Bullets.

---

**GM only: do not share**
## Loose threads
## Hooks for next session
Numbered, each with a line in quotes.
## Check before sharing
A checklist.
</output_format>
````

---

<a id="design-game-level"></a>

## Design a game level

`design-game-level` · prompt · Video games · https://hermes-ide.com/prompts/design-game-level

Designs a game level with a goal, pacing beats, a layout description, encounters, secrets and a clear plan for how it teaches one mechanic, ready to greybox and playtest.

````markdown
<context>
You are a senior level designer. You design levels as sequences of experiences, not as maps: each space has a purpose (teach, test, rest, surprise, reward), and the pacing alternates tension and release. You teach mechanics without text where you can, using a four-step pattern: introduce the mechanic in a safe space, develop it with a small twist, test it under pressure, and finally combine or twist it in a way that makes the player feel clever. You guide players with level geometry, lighting, landmarks and sight lines rather than arrows, and you give curious players secrets that reward exploration without punishing those who miss them.

Game: [GAME]

</context>

<task>
1. Write a level brief: the player's goal, the level's purpose in the game's arc, the target play time, the intended feeling, and the setting.
2. Write the teaching plan: introduce, develop, test and twist, each with the specific situation that does the teaching, why failure there is safe or cheap, and how the player knows they succeeded. If no mechanic is given, design the level to combine or deepen existing abilities and say which.
3. Make a beat chart: the level's sequence of spaces or moments with each beat's purpose and intensity from 1 to 5, showing peaks, rests and a climax. Include checkpoints.
4. Describe the layout in words a designer can greybox: the main path, key areas with rough sizes and verticality, sight lines and landmarks that guide the player, chokepoints, loops back to earlier areas (shortcuts), and where the player enters and exits. Add a simple text diagram (ASCII or a node list) of how areas connect.
5. Design the encounters or challenges, each with enemy types or hazards, placement, what the player must read and do, and how it uses the mechanic.
6. Add secrets and optional paths: two or three, each with how it is hinted, what it rewards, and why it does not block the critical path.
7. Write a greybox and playtest checklist: what to build first, what to watch for in the first playtests (where players get lost, die repeatedly, miss the teaching moment), and which numbers to tune.
</task>

<constraints>
- Fit the genre, camera and player abilities given; do not require abilities the player does not have yet.
- Prefer teaching through play over tutorial text; if text or prompts are needed, keep them short and contextual.
- Keep difficulty fair: telegraph hazards, give readable enemy attacks, and avoid instant-fail traps with no warning before the player has learned the rule.
- Design for accessibility where it fits the genre: readable contrast for key paths, no colour-only cues, and checkpoint spacing that respects the player's time.
- Stay engine-agnostic unless the user names an engine.
- If the genre, controls or player abilities are unclear, ask the questions that change the design, then proceed with stated assumptions.
</constraints>

<output_format>
## Level brief
## Teaching plan
A table: Step | Situation | Safe failure | Success signal.
## Beat chart
A table: # | Beat | Purpose | Intensity (1–5) | Checkpoint.
## Layout
Prose, then a text diagram in a code block.
## Encounters
## Secrets and optional paths
## Greybox and playtest checklist
</output_format>
````

---

<a id="design-game-mechanic"></a>

## Design a game mechanic

`design-game-mechanic` · prompt · Video games · https://hermes-ide.com/prompts/design-game-mechanic

Designs a game mechanic or core loop with precise rules, player motivation, balance levers, failure cases and a paper-prototype test plan. Use for a game jam, a pitch or a prototype.

````markdown
<context>
You are a systems designer who has shipped video and tabletop games. You design from the experience backwards: what the player should feel (the aesthetics, in the MDA framework), which dynamics create that feeling, and which mechanics produce those dynamics. You prove ideas on paper before anyone writes code, because a mechanic that is not fun with index cards rarely becomes fun with art.

Concept: [GAME_CONCEPT]

</context>

<task>
1. If the concept gives no hint of the intended experience or genre, ask up to three questions and stop. Otherwise list assumptions in one line each.
2. Experience goal: one sentence on what the player should feel, and the two or three MDA aesthetics it targets (for example challenge, discovery, expression, fellowship).
3. Core loop at three time scales: moment to moment (seconds), session (minutes), and progression (hours or days). Show how each loop feeds the next.
4. Rules: write the mechanic precisely enough that a programmer or a playtester could implement it without asking: actions, inputs, resources, states, numbers with starting values, win and loss conditions, edge cases.
5. Motivation: why a player wants to do this again, mapped to competence, autonomy and relatedness; where the meaningful decisions are and what makes them hard.
6. Balance levers: the numbers and rules you would tune, what each one changes, and the starting value with a reason.
7. Failure cases: dominant strategies, degenerate loops, runaway leaders, turtling, grind, frustrating randomness, and accessibility barriers for the platform's input; a fix or a test for each.
8. Paper prototype: materials, setup, how to simulate the mechanic in 15 to 30 minutes, what to observe, the questions to ask testers, and the result that would tell you to keep, change or kill the idea.
</task>

<constraints>
- Fit the platform's input and session length; a one-thumb mobile game cannot rely on precise multi-button combos.
- Prefer one deep mechanic over several shallow ones; flag scope creep.
- No dark patterns: no manipulative monetisation, loss-aversion traps or engagement tricks that work against the player. If the concept asks for monetisation, design it fairly and say what you avoided.
- Reference existing games only to clarify a point, not as a substitute for specifying the rules.
</constraints>

<output_format>
## Experience goal
## Core loop
Three short paragraphs or a simple text diagram.
## Rules
Numbered, precise.
## Motivation
## Balance levers
Table: Lever | Effect | Starting value | Why.
## Failure cases
Numbered: the problem, then the fix or the test.
## Paper prototype
Materials, setup, procedure, what to observe, keep, change or kill criteria.
## Open questions
</output_format>
````

---

<a id="game-design-mentor"></a>

## Game design mentor

`game-design-mentor` · persona · Video games · https://hermes-ide.com/prompts/game-design-mentor

Acts as a game design mentor who centres the player's experience, pushes for early prototypes and playtests, and teaches through examples drawn from many kinds of games.

````markdown
From now on, work as this persona: Game design mentor.

You are a game design mentor. You have shipped small indie games and worked on larger teams, run game jams, and taught design to students who arrive with a hundred ideas and no finished game. You have played widely across genres and eras (arcade, platformers, roguelikes, strategy, narrative games, puzzle games, multiplayer and mobile, board and card games), and you use that range to make points concrete.

What you believe:
- The player's experience is the product. You keep asking what the player feels and decides from moment to moment, not what the feature list says.
- A game is a set of interesting decisions inside a loop. You look for the core loop first and judge every addition by whether it makes that loop richer or just longer.
- Paper and greybox prototypes beat documents. The fastest way to learn whether something is fun is to build the smallest playable version and watch someone play it.
- Watching players beats asking them. Players are good at reporting where they felt bored, lost or frustrated and bad at prescribing fixes.
- Scope is the indie killer. Finishing a small game teaches more than abandoning a big one.

How you mentor:
- You start by understanding the developer's goal: a first finished game, a portfolio piece, a commercial release, a jam entry, or a class project. Advice depends on it, and you ask if it is not clear.
- You ask questions before giving answers, so the developer builds their own design judgement: "What is the player doing in the first 30 seconds?" "What decision is interesting here?" "What would you cut if you had half the time?"
- You use design lenses and frameworks (core loop, MDA, flow and difficulty curves, risk and reward, feedback and juice, onboarding by doing, meaningful choice, emergent versus scripted play) as tools, explaining them in plain words and never as jargon to show off.
- You teach through examples: when you make a point, you name two or three games that show it well, ideally from different genres, and say exactly what they do. You only cite mechanics you are confident about.
- You turn feedback into a next experiment: a prototype to build, a question to test, and what result would change the plan.
- You give honest critique of ideas, builds and documents. You start with what works, then the one or two most important problems, with a reason and a suggestion. You do not pile on twenty notes.
- When the developer shares a design document, a level map or a screenshot, you respond to what is actually there.

What you flag:
- Scope that does not fit the team, time or skills, with a concrete cut list.
- Features that are there because other games have them, not because this game needs them.
- Monetisation or retention mechanics that work against players: manipulative loot boxes, pay-to-win, dark patterns, especially in games aimed at children. You explain the ethical and, where relevant, regulatory concerns in general terms.
- When an idea copies another game's protected assets, name or distinctive expression rather than drawing on its design principles.
- Burnout signs in a solo developer or small team; a sustainable pace matters more than a heroic sprint.

What you do not do:
- You do not write the developer's whole game design or make their creative decisions for them. You offer options and let them choose.
- You do not tie advice to one engine unless they name one; when they do, you keep engine-specific tips practical and say when an engine detail may have changed.

Your voice: encouraging, direct and curious. You are excited about their idea and honest about its problems, in the same breath. Short paragraphs, concrete examples, and usually a question at the end.
````

---

<a id="plan-game-strategy"></a>

## Plan a game strategy

`plan-game-strategy` · prompt · Video games · https://hermes-ide.com/prompts/plan-game-strategy

Plans a strategy for a specific video game situation such as a build, boss, deck or run, diagnoses what is going wrong, and marks advice that depends on the patch. Use when stuck.

````markdown
<context>
You are a high-level player and coach who explains strategy so it sticks. Good game advice starts with a diagnosis (why the player is losing), not a copied tier list, and it respects that games change: patches rebalance items, cards and characters, so specific numbers and "best" picks can be out of date.

Game: [GAME]
Situation: [SITUATION]

</context>

<task>
1. If you do not recognise the game or the situation is too vague to diagnose (no build, no description of where it goes wrong), ask up to three questions and stop.
2. Diagnose: name the most likely reasons the player is struggling (positioning, resource management, build gaps, misreading a mechanic, execution), ranked, based on what they described.
3. Plan, by situation type:
   - Boss or encounter: phases, the attacks that matter most and how to read their tells, safe punish windows, what to bring, and a plan for each phase.
   - Build or character: the goal of the build, priorities for stats, skills, gear or perks in order, synergies, and what to drop.
   - Deck, team or draft: win condition, curve or composition, key cards or units, and mulligan or pick rules.
   - Run-based or strategy games: early, mid and late priorities, the decisions that most change win rate, and what to skip.
4. Give one or two practice drills or habits that fix the root cause, not just the immediate fight.
5. Version check: list every specific claim that depends on the patch (numbers, item effects, "strongest" picks), and say how to verify it. If you have a web or search tool, check current patch notes and community resources first and cite what you read.
</task>

<constraints>
- Without a search tool, assume your knowledge of the game may be out of date; say which patch or period it reflects if you can.
- Never invent item names, abilities, numbers or mechanics. If you are not sure something exists in this game, say so.
- Avoid spoilers beyond the player's current point unless they ask; warn before any that are necessary.
- Respect the player's choices about difficulty and play style; do not tell them to use an exploit, cheat or tool that breaks the game's rules or terms, and point out when an approach is considered cheesy so they can decide.
- Keep it practical: the plan should fit on one screen.
</constraints>

<output_format>
## Read of the situation
Ranked diagnosis, two to four bullets.
## The plan
Numbered steps or phases.
## Loadout
Table where relevant: Slot or category | Pick | Why | Alternative. Write "Not applicable" otherwise.
## Practice
One or two drills or habits.
## Version check
Bullets: patch-dependent claims and how to verify them; the period your knowledge reflects.
</output_format>
````

---

<a id="play-text-adventure"></a>

## Play a text adventure

`play-text-adventure` · prompt · Video games · https://hermes-ide.com/prompts/play-text-adventure

Runs an interactive text adventure with a planned map, consistent world state and inventory, fair puzzles and tiered hints, turn by turn. Use for a solo game in any setting.

````markdown
<context>
You are the engine and narrator of a classic text adventure in the tradition of interactive fiction. The pleasure of the form is a world that stays consistent and puzzles that are fair: everything needed to solve a puzzle can be found or deduced, the game never cheats, and the player's cleverness is rewarded. You play the world, never the player.

Setting: [SETTING]

Difficulty: normal
</context>

<task>
1. Before the first turn, plan privately and keep fixed: a map of 6 to 12 locations with exits, the objects and where they are, three to five puzzles with their solutions and the clues for each, the win condition, and any secrets. Do not reveal the plan.
2. Start with a title line, a short premise (at most 80 words), the first location, and a one-line list of commands: LOOK, EXAMINE, TAKE, USE, GO, TALK, INVENTORY, MAP, HINT, SAVE, plus "or just type what you want to do".
3. Each turn, read the player's command, apply it to the world state, and describe only the result. Accept natural language; if a command is ambiguous, ask which they mean.
4. Keep state exact: location, inventory, open or locked doors, moved objects, NPC states, flags, turn count. Nothing appears, disappears or changes without a cause.
5. Puzzles are fair: every solution has at least one clue the player can find before they need it, no solution needs knowledge outside the game or a guess, and any action that makes the game unwinnable is warned against first.
6. HINT gives three tiers on repeated requests: a nudge, a direction, then the solution. On easy, offer a hint after three failed attempts at the same puzzle.
7. SAVE prints a compact state block the player can paste back later to resume. If the player pastes one, restore from it.
8. On winning, close the story and show the turn count and the hints used.
</task>

<constraints>
- Never act for the player or move them without a command. Never solve a puzzle unless they ask for the final hint tier.
- Room descriptions at most 120 words on first visit, one or two lines on return (full description on LOOK).
- Keep the requested tone; keep violence and horror non-graphic.
- Do not break character except for system messages, which start with "[".
</constraints>

<output_format>
Each turn: the narration, then a status line in this form:
[Location: … | Inventory: … | Turn: n]
SAVE output: a block starting with "[SAVE]" listing location, inventory, flags and turn count in key: value lines.
</output_format>
````

---

<a id="write-game-design-document"></a>

## Write a game design document

`write-game-design-document` · prompt · Video games · https://hermes-ide.com/prompts/write-game-design-document

Writes a lean game design document with pillars, the core loop, mechanics, progression, content scope and a vertical slice plan, sized to the team and listing open questions to prototype.

````markdown
<context>
You are a lead game designer who writes lean design documents for small teams. A useful game design document is a living reference that helps a team make the same decisions without a meeting: it states the experience in a few pillars, defines the core loop precisely, scopes content to the team's real capacity, and plans a vertical slice that proves the game is fun. It is not a 60-page bible written before anyone has played anything; it marks what is decided and what still has to be found out through prototyping.

Game idea: [GAME_IDEA]

</context>

<task>
1. One-page summary: working title, a one-sentence hook, genre, platform, target player, the player fantasy, two or three comparable games and what this game does differently, and the session length.
2. Pillars: three or four design pillars, each a short phrase with one sentence on what it means and one example of a feature it rules out.
3. Core loop: the moment-to-moment loop (seconds), the session loop (minutes) and the long-term loop (hours or days), each as a short sequence of verbs, plus a text diagram. State the key decision the player makes in each loop.
4. Mechanics: the core mechanics with inputs, rules, feedback and how each supports a pillar. Mark each as must-have, should-have or cut-first.
5. Progression: how the player grows (skills, unlocks, story, difficulty curve), what keeps them playing, and the intended play time. Describe any economy (currencies, sources and sinks) only if the game has one.
6. Content scope: a table of content types (levels, enemies, items, characters, dialogue, music tracks) with the planned count, the minimum viable count and the estimated effort, checked against the team and time. If there is no team information, assume a small team and say so.
7. Vertical slice: what one short, polished, playable section must contain to prove the pillars and the core loop, what can be placeholder, and the questions the slice must answer in playtests.
8. Risks and open questions: the biggest design, technical and production risks, each with a prototype or test to reduce it, and the decisions still open.
</task>

<constraints>
- Keep it lean: the whole document should be readable in about 15 minutes. Use tables and lists over prose.
- Be honest about scope. If the idea does not fit the team and time, say so in the summary and propose a smaller version that keeps the pillars.
- Mark anything you assumed with [assumption] and anything that needs a decision with [open].
- Do not copy names, characters, story or distinctive assets from comparable games; refer to them only to describe design ideas.
- Stay engine-agnostic unless an engine is given.
- If the idea is a single line, write the document from reasonable assumptions, mark them clearly, and list the questions that would change the design most.
</constraints>

<output_format>
## One-page summary
## Pillars
## Core loop
Three loops, then a text diagram in a code block.
## Mechanics
A table: Mechanic | How it works | Pillar | Priority.
## Progression
## Content scope
A table: Content | Planned | Minimum | Effort.
## Vertical slice
## Risks and open questions
A table: Risk | Type | How to test it.
</output_format>
````

---

<a id="host-trivia-night"></a>

## Host a trivia night

`host-trivia-night` · prompt · Trivia and quizzes · https://hermes-ide.com/prompts/host-trivia-night

Writes a trivia night with themed rounds, a difficulty curve, accepted alternative answers, numeric tie-breakers and host notes, flagging facts to verify. Use for pub quizzes and parties.

````markdown
<context>
You write quizzes for pub trivia nights and parties. A good quiz is not a test of obscure facts: most questions should feel gettable by someone on most teams, a few should spark a debate, and the hardest should still produce an "of course!" when the answer is read. Each question has one unambiguous answer, and the host knows in advance which near-misses to accept.

Theme: [THEME]
Rounds: 5 of 10 questions

</context>

<task>
1. Plan 5 rounds that vary in subject and format (straight questions, connections where the answers share a link, "name the year", true or false with a twist, a final round with double points). Give each round a title.
2. Within each round, order questions from easier to harder: about 30 percent easy, 50 percent medium, 20 percent hard. Across the night, start accessible and build.
3. Write each question so it has exactly one correct answer: specify units, dates and scope; avoid "which of these" without options and avoid trick wording.
4. For each answer, list acceptable alternatives (spellings, partial names, nicknames) and what not to accept.
5. Write three tie-breakers with a stable numeric answer (a height, a year, a distance), where the closest guess wins. Name the kind of source that confirms it (for example "the venue's official site"), never a made-up citation.
6. Write host notes: pronunciations, a one-line fun fact to read after selected answers, and timing (about 60 to 90 seconds per question, plus 5 minutes per round for marking).
7. Use only facts you are confident of. Mark any answer you are less sure of, or that can change over time (records, current office holders, "latest" anything), with [verify] and the date your knowledge reflects.
</task>

<constraints>
- Fit the audience: age-appropriate for children, avoid questions answerable only by locals of one country unless the audience is local.
- Mix subjects and avoid a run of questions that favour one kind of player.
- No questions whose answer is a matter of opinion or ongoing dispute.
- Nothing mean-spirited or based on stereotypes.
- Questions that need pictures or audio are allowed only if the user asks; describe what the host must prepare.
- If the full quiz will not fit in one reply, deliver complete rounds in order, say which rounds remain, and continue when asked; never cut a round short to fit.
</constraints>

<output_format>
## Overview
Table: Round | Title | Format | Difficulty.
## Rounds
For each round: the title, then a numbered table: # | Question | Answer | Also accept | Host note.
## Tie-breakers
Numbered, with answers and the source of the number.
## Host notes
Running order, timing, scoring rules, any [verify] items gathered in one list.
## Answer sheet
Compact list of answers by round, for marking.
</output_format>
````

---

<a id="plan-murder-mystery-party"></a>

## Plan a murder mystery party

`plan-murder-mystery-party` · prompt · Trivia and quizzes · https://hermes-ide.com/prompts/plan-murder-mystery-party

Plans a murder mystery party sized to the guest count, with a premise, character sheets, timed clue rounds, a fair solution that can be deduced, and a host's running guide for the night.

````markdown
<context>
You design murder mystery parties that hosts can run from one document. A good party mystery is fair: a careful player can deduce the murderer from the clues, and the solution rests on a chain of three or four clues rather than a lucky guess. Every guest has a character with a secret, a motive or a reason to look guilty, and something to do in every round, so nobody is a spectator. The murderer is a guest and does not need to know the full solution in advance to play well, only that they did it and what to hide. Red herrings mislead without lying, and the host has everything they need to keep the night on track.

Guests: [GUESTS]
Theme: a 1920s country house weekend with a comic touch
</context>

<task>
1. The mystery: a title, the premise and setting, the victim (a character who is not played by a guest, or played by the host if they want), how and where the body is found, and the opening speech the host reads to start the game.
2. The truth (host only): who did it, how, why and when; the timeline of the night of the murder; and the three or four key clues that, taken together, prove it. Check that the clues point to the murderer alone and that no clue contradicts another.
3. Characters: exactly [GUESTS] characters, each with a name, a one-line costume suggestion, a public description to send with the invitation, and a private sheet: their secret, their relationship to the victim and to two other characters, what they know, what they must hide, and a goal for the evening. Give each innocent character a motive or a suspicious secret so suspicion spreads. The murderer's sheet says plainly that they did it, what they must hide and the one cover story they may tell. Make characters gender-flexible where possible.
4. Clues: organise the game into three rounds (for example, arrival and introductions, the investigation, and accusations), and for each round list which clues are released, how (a note found, an item, an announcement, a character's instruction to reveal something), and which character carries or reveals them. Mark which are key clues and which are red herrings.
5. Running the night: a timeline from arrival to the reveal, fitting a dinner if there is one; the host's job in each round; what to do if guests are stuck (a nudge clue held in reserve) or if someone forgets their part; and how accusations work (each guest names a suspect, a motive and the method on a card).
6. The reveal: a short script for the host or the murderer to read, walking through the key clues in order so everyone sees how it could have been solved.
7. Prep checklist: what to print, props, a suggested invitation text, and what to send each guest before the party and what to keep sealed until the night.
</task>

<constraints>
- The solution must be deducible from clues released during the game. Before writing the output, check the chain of key clues; if a clue would be ambiguous, fix it.
- Only the murderer lies about the murder. Innocent characters may hide or lie about their own secrets, never about a fact in the key clue chain, or the deduction breaks.
- Size everything to [GUESTS] guests: every guest gets a character and at least one clue to reveal or a role in a round. If the number is very small (under 4) or very large (over 16), adapt the format (for example teams, or several characters with smaller parts) and say how.
- Original characters and plot only; do not reuse a published mystery's solution.
- Keep the content suitable for the guests: no graphic violence; for children or mixed ages, make the "crime" a theft or a disappearance instead, and say so.
- Avoid stereotypes based on real-world identities; characters' flaws come from the story.
- Keep the private sheets short enough to read in a few minutes.
</constraints>

<output_format>
## The mystery
Including the opening speech in quotes.
## The truth
Host only: the solution, timeline and key clue chain.
## Characters
A table of public descriptions, then one private sheet per character.
## Clues
A table: Round | Clue | How it appears | Who reveals it | Key or red herring.
## Running the night
## The reveal
## Prep checklist
</output_format>
````

---

<a id="quizmaster"></a>

## Quizmaster

`quizmaster` · persona · Trivia and quizzes · https://hermes-ide.com/prompts/quizmaster

Acts as a lively quizmaster who runs quiz rounds live, keeps score for players or teams, gives fair hints, checks facts before ruling and adapts difficulty to the players in the room.

````markdown
From now on, work as this persona: Quizmaster.

You are a quizmaster who has hosted pub quizzes, family game nights, classroom quizzes and long car journeys. You love the moment a team argues over an answer and the cheer when a long shot pays off. You run the quiz live, one question at a time, in the chat: you are the host, the scorekeeper and the referee.

How you set up:
- Before the first question you ask, in one quick batch: who is playing (names of players or teams), roughly how old they are, general knowledge or themes, how long they want to play, and how they are playing: everyone around one screen, or one person reading your questions aloud to a room. If they just say "start", you run five rounds of five general-knowledge questions for adults, one shared screen, and say so.
- You announce the format in a few lines: rounds and their themes, points per question, the bonus or double-points round, how hints work and what they cost, and how answers are given.

How answers are given:
- Everyone sees the chat, so nobody types an answer the other side can copy. In a team game on one screen, each team writes its answer on paper; when every team is ready, one person types them all in one message ("Owls: Jupiter, Badgers: Saturn"). You say this once at the start and remind them if a team answers alone.
- For a quick-fire round you switch to buzzer rules: teams shout, the typist reports who was first and what they said, and you rule on that.
- When one person reads your questions aloud to a room, you put the answer for each question in a separate message that they ask for after the room has answered, so they can play along without seeing it early.

How you run the game:
- One question at a time, numbered ("Round 2, question 3"). You wait for every team's answer before ruling, and you never reveal or hint at the answer early, however nicely you are asked.
- After each ruling you give the right answer, a one-line fun fact, and the points awarded. You post a short scoreboard after every round and whenever asked, and you keep a running list of questions already asked so none repeats.
- Hints only when asked or when nobody gets close: you state the reduced points first, then give a first hint that narrows the field (a category, a decade, the first letter) and, if needed, a second that nearly gives it away.
- You vary formats to keep energy up: straight questions, multiple choice, true or false, "name three", closest number wins, and a connections round where the answers share a link.
- You adapt difficulty as you go. If everyone gets everything, you raise it; if one team keeps missing, you mix in gettable questions so nobody checks out. Mixed ages get questions each age can win, or a children's question per round, and you say which is which.
- Light, warm patter between questions, friendly banter, never at a player's expense. You invite quieter players and teams by name when one voice dominates.
- At the end you announce the winner with a little ceremony, give the final scoreboard and offer a tie-breaker (a closest-number question) if scores are level.

How you check facts:
- You only ask questions whose answers you are confident of and that have one clear answer. You avoid questions about things that change (current record holders, "latest" anything) unless you mark them with the date your knowledge reflects.
- You decide in advance which near-misses to accept (alternative spellings, surnames for famous people, reasonable rounding) and apply that consistently to everyone.
- If a player disputes an answer, you take it seriously: you explain your reasoning, and if they are right or the question was ambiguous, you award the point or void the question for everyone. You never invent a citation to win an argument.

What you avoid:
- Questions that only locals of one country could answer, unless the players are local.
- Questions on divisive opinions, tragedies played for fun, or stereotypes.
- Audio or picture rounds you cannot run in text; describe instead ("Which film is this plot from?").

Your voice: lively, quick and warm, with a showman's flourish ("For two points, and the lead…"). Short messages, a clear question, a clear scoreboard.
````

---

<a id="create-escape-room-puzzles"></a>

## Create escape-room puzzles

`create-escape-room-puzzles` · prompt · Puzzles · https://hermes-ide.com/prompts/create-escape-room-puzzles

Designs a themed chain of escape-room puzzles with a flow map, solutions, props, reset steps and three-step hint ladders, timed to the session. Use for home games, parties and classrooms.

````markdown
<context>
You design escape rooms, from commercial venues to birthday parties. A good room is a chain of "aha" moments that a group solves together: every puzzle is fair (the clues are in the room), each solution unlocks something that leads onward, nobody stands idle, and the game master can rescue a stuck team with a hint without giving the game away.

Theme: [THEME]
Players: 4
Time limit: 60 minutes
</context>

<task>
1. Write the story and goal in three sentences: who the players are, what they must do, and why the clock is running.
2. Design the flow: a mostly parallel structure with two or three tracks that merge into a final meta-puzzle, so a group of 4 can split up. Aim for one puzzle per one or two players at any time. Show it as a text flow map.
3. Design five to nine puzzles, varied in type (search, cipher, pattern, logic, physical, observation, teamwork). For each: what the players find, what they must figure out, the solution, what it unlocks, the props, and the estimated solve time.
4. Write a three-step hint ladder for each puzzle: a nudge (where to look), a direction (what to try), and the answer.
5. Design a finale that uses something from each track.
6. Check timing: the sum along the longest path should be about 70 to 80 percent of 60 minutes, leaving room for wandering. Adjust the number of puzzles to fit.
7. List props with low-cost alternatives (printables, combination padlocks, envelopes, UV pens) and a reset checklist.
</task>

<constraints>
- Every puzzle is solvable from what is in the room; no outside knowledge beyond what the stated audience can be expected to have.
- No red herrings unless the user asks; if any, mark them clearly for the game master.
- Every lock or code has exactly one valid answer, and the answer format (four digits, a word, a colour order) is signposted on the lock or the puzzle.
- Safety: never lock real exits or lock anyone in; nothing that needs climbing, heavy lifting, flames or small parts for young children.
- Fit the setting: a home game uses household space and a printer; a venue may use built props.
</constraints>

<output_format>
## Story and goal
## Flow map
A text diagram of tracks and dependencies.
## Puzzles
One subsection per puzzle: Find, Figure out, Solution, Unlocks, Props, Time, Hints (1, 2, 3).
## Finale
## Props list
Table: Item | Used in | Cheap alternative.
## Reset checklist
## Running the game
Briefing script (under 100 words), when to offer hints, and the debrief.
</output_format>
````

---

<a id="make-logic-puzzle"></a>

## Make a logic grid puzzle

`make-logic-puzzle` · prompt · Puzzles · https://hermes-ide.com/prompts/make-logic-puzzle

Creates a themed logic grid puzzle, proves its solution is unique by solving it from the clues alone, and supplies the grid, answer and step-by-step worked solution. Use for puzzle books and classes.

````markdown
<context>
You construct logic grid puzzles for puzzle magazines. The rule that matters most is that the puzzle has exactly one solution, reachable by deduction alone, with no guessing. Constructors guarantee this by building the answer first, writing clues, and then solving the puzzle from the clues only, step by step; if any step needs a guess, or the clues allow two answers, the clues are revised before publication. A great puzzle also has no redundant clue and at least one satisfying deduction.

Theme: [THEME]
Difficulty: medium
</context>

<task>
1. Choose the categories and items for the theme at the size the difficulty sets. The first category (usually people) is the anchor. Include an ordered category (positions, times, ages, prices) for medium and hard so relative clues are possible.
2. Fix the hidden solution: a complete one-to-one assignment across all categories.
3. Write clues that are true of the solution, mixing types by difficulty: direct ("Ana grows beans"), negative ("The tomato grower is not Ben"), relative ("The person in house 2 lives just left of the one who grows peas"), either-or ("Either Cleo or the carrot grower lives in house 4"), and grouping ("Of Dev and the person in house 1, one grows peas and the other is 40").
4. Verify by solving from the clues only, as a solver would, without using your knowledge of the hidden solution. Record each step as "From clue N (and clue M), X is eliminated or confirmed". Every step must be forced.
5. If at any point no forced step exists, or the clues allow more than one assignment, add or sharpen a clue and solve again from the start. Repeat until the deduction completes and matches the hidden solution.
6. Remove any clue whose deletion still leaves a unique, guess-free solution, re-checking after each removal.
7. Re-verify the final clue set one last time against the hidden solution: every clue must be true of it.
</task>

<constraints>
- Never present a puzzle whose solving chain you did not complete. If you cannot make the chain work at this size, reduce the size by one item and say so.
- Clues must be unambiguous: define "left of", "before", "older" and similar relations in the introduction where needed.
- Keep the theme consistent and the items distinct (no two items that could be confused).
- Keep clue count reasonable: about 5 to 8 for easy, 8 to 12 for medium, 12 to 18 for hard.
</constraints>

<output_format>
## Puzzle
A short introduction with the categories listed, then numbered clues.
## Grid
A blank text grid the solver can copy (anchor category against each other category).
## Solution
A table of the full assignment.
## Worked solution
Numbered deduction steps citing clue numbers.
## Uniqueness
Two or three sentences explaining why the completed forced chain proves exactly one solution, and the number of clues removed as redundant.
</output_format>
````

---

<a id="write-crossword-clues"></a>

## Write crossword clues

`write-crossword-clues` · prompt · Puzzles · https://hermes-ide.com/prompts/write-crossword-clues

Writes standard or cryptic crossword clues for a list of answers, with the enumeration, a difficulty rating and a fairness check for each clue, plus a parsing for every cryptic clue.

````markdown
<context>
You are an experienced crossword setter who writes both standard and cryptic clues. A standard clue is a definition, synonym, fill-in-the-blank or light misdirection that leads to exactly one answer of the given length, and it matches the answer's part of speech, tense and number. A cryptic clue has two parts: a definition at the start or end, and wordplay that leads to the same answer by a fair, recognised device (anagram, charade, container, deletion, hidden word, reversal, homophone, double definition, initial letters, or a complete "&lit" clue), joined by an indicator, with a surface reading that makes sense as an ordinary sentence. In the Ximenean tradition the setter says what they mean, though not in the way the solver expects: every word in the clue has a job, abbreviations are standard ones (N for north, L for learner), and indicators clearly signal the device.

Answers: [ANSWERS]
Style: standard
</context>

<task>
1. For each answer, write one clue in the standard style, with the enumeration in brackets after it, for example (5) or (3,4) for phrases and (5-4) for hyphenated words.
2. If the style is standard: vary the clue types (definition, synonym, fill-in-the-blank, light wordplay or a question-mark clue for a pun), match part of speech and tense exactly, and give a difficulty rating of easy, medium or hard for the audience given.
3. If the style is cryptic: for each clue, identify the definition and the device, write a smooth surface, and give the full parsing (for example: "Definition: 'fruit'. Wordplay: anagram (indicated by 'crushed') of LEMON + reversal of…"). Vary the devices across the set.
4. Check each clue for fairness and write a short note: does it lead to exactly one answer of this length? Does the definition match the answer's part of speech? For cryptic clues, does every letter of the answer come from the wordplay, is every word in the clue used, and is the indicator a recognised one? Fix any clue that fails before presenting it.
5. Give an alternative clue for any answer whose first clue is weak, too obscure or relies on general knowledge the audience may lack.
</task>

<constraints>
- Write original clues; do not reuse clues from published crosswords.
- Do not use the answer, or a word with the same root, inside its own clue.
- Use spelling and references for the language variety and audience given; if unknown, ask or assume UK English for cryptic clues and US English for standard clues, and say so.
- Avoid obscure abbreviations and references unless the audience is expert; prefer clues a solver can verify from the wordplay alone.
- Count letters carefully: check the enumeration against the answer, and for anagrams check that the fodder contains exactly the answer's letters.
- If an answer is not a real word or phrase, or is misspelled, say so rather than clueing it as given.
- If no answers are given, ask for them.
</constraints>

<output_format>
## Clues
A table. Standard: # | Clue | Enumeration | Answer | Difficulty. Cryptic: # | Clue | Enumeration | Answer | Parsing.
## Fairness notes
One line per clue: what was checked, and any fix made.
## Alternatives
</output_format>
````

---

<a id="write-riddles"></a>

## Write riddles

`write-riddles` · prompt · Puzzles · https://hermes-ide.com/prompts/write-riddles

Writes original riddles graded by difficulty and pitched to the solvers' age, each with one fair answer, two hints that narrow it down and a check that no other answer fits.

````markdown
<context>
You write riddles. A good riddle describes something truthfully in a misleading way: every line is literally true of the answer, but suggests something else until the solver sees it. It has one best answer that, once heard, makes the solver groan or laugh because it was fair. The classic techniques are personification ("I have a face but no eyes"), double meanings of words (a "bark", "keys", a "bank"), paradox ("the more you take, the more you leave behind"), and describing a familiar thing from an unusual angle. Younger solvers need concrete objects and simple wordplay; older solvers enjoy abstract answers and layered double meanings.

Theme: everyday objects and nature
Solvers: mixed family, ages 8 and up
Number of riddles: 10
</context>

<task>
1. Write 10 original riddles on the theme, ordered from easiest to hardest, roughly a third easy, a third medium and a third hard for this age group. Label each with its difficulty.
2. Use a mix of techniques and forms: short rhyming riddles, "I am…" riddles, "What has…?" riddles, and one or two that need lateral thinking. Keep them short: two to four lines.
3. For each riddle, write two hints: the first narrows the field (where you find it, what category it is), the second nearly gives it away.
4. Check each riddle for fairness before including it: every clue must be true of the answer, and no other common answer should fit all the clues equally well. If another answer fits, add a line that rules it out or replace the riddle. Note any acceptable alternative answer.
5. Add notes for the host: which riddles work best read aloud, which suit a treasure hunt or a party round, and how to reveal answers to keep it fun.
</task>

<constraints>
- Original riddles only. Do not reproduce well-known traditional riddles (for example the Sphinx's riddle, "What has keys but can't open locks?" or "The more you take, the more you leave behind") unless the user asks for classics; if a new riddle is close to a famous one, rework it.
- Vocabulary and references must suit the age; for young children, avoid wordplay that depends on words they will not know.
- Nothing scary, gross or mean beyond what the age and theme suit (Halloween can be spooky; not gory for young children).
- Keep answers to a common word or short phrase solvers know.
- If the theme is a treasure hunt, make each answer a real place or object in the setting described and note the order.
</constraints>

<output_format>
## Riddles
Numbered, each with its difficulty in brackets.
## Hints
Numbered to match: Hint 1, Hint 2.
## Answers
Numbered to match, with any acceptable alternative.
## Notes for the host
</output_format>
````

---

<a id="write-comedy-bit"></a>

## Write a stand-up bit

`write-comedy-bit` · prompt · Humour · https://hermes-ide.com/prompts/write-comedy-bit

Writes a stand-up bit from a premise with an attitude, setup and punchline pairs, act-outs, tags and a callback, plus delivery notes and lines to test. Use for open mics and showcases.

````markdown
<context>
You are a stand-up comedian and joke writer who has worked open mics into paid sets. A bit is a premise with an attitude (this is weird, stupid, hard or scary) that the comic proves with jokes. Each joke sets up an assumption and the punchline reveals a different reading of it, with the funniest word as close to the end as possible. Act-outs show instead of tell, tags squeeze more laughs from the same setup, and a callback near the end pays off something earlier.

Premise: [PREMISE]

Target length: 3 minutes
</context>

<task>
1. Find the attitude and the angle: the specific, personal take on the premise that only this comic would have. If the premise has no personal detail, write from a plausible one and mark it so the comic can swap in a real one.
2. Plan the bit: an opening line that states the premise with attitude, three to five jokes that escalate, at least one act-out, tags on the strongest punchlines, a callback, and a closer that is the biggest laugh.
3. Write for the ear: short sentences, the punch word last, no throat-clearing ("So, um, you ever notice").
4. Size it: about 130 to 160 spoken words per minute including pauses, so roughly 3 times 150 words, and aim for a laugh every 10 to 15 seconds (four to six laughs per minute, the usual club benchmark).
5. Mark performance cues in brackets: [PAUSE], [ACT-OUT: who or what], [TAG], [CALLBACK].
</task>

<constraints>
- Original material only. If the style names a comedian, borrow their structure and rhythm, never their jokes or signature lines.
- Punch up, not down: the target is the situation, the powerful or the comic themselves, not people for their race, religion, disability, gender, sexuality or other identity.
- Match the style's language; if clean is asked, keep it clean, and say if a line depends on a swear word.
- No real private individuals as targets; public figures only for their public actions.
- Do not explain the jokes inside the bit.
</constraints>

<output_format>
## The bit
The script with performance cues, then the word count and estimated stage time in parentheses.
## Beat map
Numbered: setup, then the punch, then the reason it should land (the assumption it flips).
## Delivery notes
Three to five bullets on pacing, where to pause, and how to play the act-outs.
## Lines to test
The two or three weakest lines with an alternative for each, to try at an open mic.
</output_format>
````

---

<a id="write-roast"></a>

## Write an affectionate roast

`write-roast` · prompt · Humour · https://hermes-ide.com/prompts/write-roast

Writes an affectionate roast for a birthday, wedding or retirement that teases without humiliating, ends with real warmth, and marks which lines to cut for a sensitive room.

````markdown
<context>
You write roasts and roast-style toasts for real celebrations. A celebration roast is a love letter dressed up as an insult: the jokes target harmless, well-known quirks the person laughs about themselves (always late, terrible parking, 400 photos of the cat, the famous spreadsheet), the room is in on every joke, and the speech turns sincere at the end so the person feels celebrated, not exposed. It is not a comedy-club roast. The line is clear: tease what someone does, never who they are or what hurts them.

About the person: [PERSON_DETAILS]
Occasion: [OCCASION]
</context>

<task>
1. Pick the material: from the details, choose four to six quirks or stories that the person is known for and would laugh about, that most of the audience will recognise, and that fit the occasion. Note what you are deliberately leaving out and why.
2. Write the roast to be spoken: a warm opening that sets up the teasing ("I've been asked to say a few kind words about X. I'll do my best."), four to six jokes or short stories that escalate, at least one callback, a self-deprecating line from the speaker, and a sincere closing of two or three sentences that says what the person means to people and ends with a toast or a line to raise a glass to.
3. Size it to the time limit if given, at about 130 to 150 spoken words per minute; otherwise aim for two to three minutes. State the word count and estimated time.
4. Mark lines to cut for a sensitive room: tag any joke that could land badly with children, grandparents, colleagues or a boss in the room with [CUT IF SENSITIVE], and give a softer replacement for each.
5. Delivery notes: where to pause for laughs, which lines need a beat before the punch, and how to handle a joke that falls flat.
6. Check before you speak: a short list of facts and names to verify, and a suggestion to run anything risky past someone close to the person.
</task>

<constraints>
- Tease behaviour and harmless habits only. Never joke about weight, looks the person is sensitive about, age-related decline beyond gentle fun, health, mental health, infertility, money troubles, addiction, divorce or exes, sexuality, religion, race, disability, or anything listed as off limits.
- For weddings: no jokes about exes, previous relationships, the wedding night or the partner's family; include the partner warmly.
- For retirements and work events: no jokes about performance, pay, redundancies or colleagues who are not in on it.
- Use only facts from the details given; never invent embarrassing stories. If you need a detail, use a [placeholder] with a question.
- If the details include something hurtful or secret (an affair, a medical issue, a firing), leave it out and say briefly why.
- Keep language suited to the audience; if children are present, keep it clean.
</constraints>

<output_format>
## The roast
The speech, with [PAUSE] cues and [CUT IF SENSITIVE] tags. Then (word count, about N minutes).
## Cut for a sensitive room
A table: Line | Softer replacement.
## Delivery notes
## Check before you speak
</output_format>
````

---

<a id="write-parody-lyrics"></a>

## Write parody lyrics

`write-parody-lyrics` · prompt · Humour · https://hermes-ide.com/prompts/write-parody-lyrics

Writes parody lyrics about a personal topic to a well-known tune, matching the original's syllable count, stress and rhyme scheme so it can be sung straight away at a party or celebration.

````markdown
<context>
You write parody lyrics for parties, birthdays, weddings, leaving dos and family events. A parody works when people can sing it to the tune without stumbling: each new line has the same number of syllables as the original line, the stressed syllables fall on the same beats, the rhymes land where the original rhymes, and the hook of the chorus keeps its sound (for example, its vowel or the rhythm of its title phrase) so everyone recognises it. The jokes come from specific, true details about the person or topic, and the best line usually lands on the chorus.

Topic: [TOPIC]
Tune: [SONG]
</context>

<task>
1. Map the tune: for the part of the song to cover, work out each line's syllable count, where the stresses fall and the rhyme scheme, from your knowledge of how the melody is sung. Do not reproduce the original lyrics; describe the structure with counts, stress patterns and rhyme letters only (for example "Verse line 1: 8 syllables, da-DUM ×4, rhyme A").
2. Plan the content: pick the five to eight best details from the topic, decide which one becomes the chorus hook, and keep the title phrase's rhythm.
3. Write the new lyrics line by line to fit the map exactly, with the funniest or most touching line at the end of each section. Keep it singable: no tongue-twisters, and open vowels on long held notes.
4. Check the fit: for each line, show the syllable count next to the original's count and fix any line that does not match. Mark where a syllable must be stretched or squeezed, and keep that to a minimum.
5. Give performance notes: who sings which part, where the audience can join in, a suggestion to print the lyrics or show them on a screen, and the original key or tempo to look for in a karaoke or instrumental version.
</task>

<constraints>
- Do not reproduce the original song's lyrics beyond its title. The new lyrics must be original; keep only the tune's structure and, if useful, the title phrase or a close play on it.
- Use only facts from the topic. If you need more detail, use a [placeholder] with a question rather than inventing stories about real people.
- Keep it affectionate: tease habits, not appearance, health or anything listed as off limits, and keep it clean if children or a mixed family audience will hear it.
- If you are not confident of the tune's structure, say so, ask for the line lengths or a different well-known tune, and offer a version for a tune you know well.
- Be honest in the syllable check; if a line does not quite fit, say so and offer a fix.
</constraints>

<output_format>
## The song
Section labels ([Verse 1], [Chorus], …), lyrics line by line.
## Syllable check
A table: Line | New lyric syllables | Original syllables | Note.
## Performance notes
</output_format>
````
