PromptMake
Article14 min readText & PE

Game Prompt Design Kits: NPC, Quest & System Messages

Game prompt design kits for NPC dialogue, quest JSON, and system messages: GDD-to-prompt fields, paste templates, and Unity-adjacent patterns.

Generate optimized prompts for ChatGPT, Claude & more

Free prompt generator — no account needed.

Try Prompt Generator

A game prompt is the text you feed an LLM so it stays in character, returns quest JSON that matches your data model, or obeys system rules at runtime. You leave with three paste-ready kits (NPC prompt, quest schema, system message), a GDD-to-field checklist, and notes on when tight constraints help versus when they flatten surprise. This page is about text and system design, not splash art. For hero and portrait stills, use the sibling guide on game-character-ai-prompts. Soft path: https://promptmake.net/text turns a rough GDD note into a structured prompt you can paste into ChatGPT, Claude, Gemini, or a local model.

What a game prompt design kit covers (not character art)

People who search "game prompt" often land on Midjourney character sheets. Fair. That work matters for marketing stills and concept art. It doesn't keep a merchant from inventing a city that isn't in your bible, and it doesn't emit a quest object your quest manager can parse. I've watched that fail on a jam build where the blacksmith casually named a capital we had deleted two weeks earlier.

A game prompt kit is a reusable text package: role, knowledge limits, speech rules, output schema, and hard refusals. You store the static half in a project instruction, ScriptableObject, or data asset. You inject the live half (flags, inventory, last player line) at call time. Indie writers, narrative designers, and solo Unity or Unreal programmers use the same kits differently. Writers care about voice. Engineers care about valid JSON and token cost. I'm in the second camp most weeks, which is why the kits below are picky about ids.

Scope split so you don't mix jobs:

  • Image kits: silhouette, gear, pose, art style (see https://promptmake.net/blog/game-character-ai-prompts)
  • Text kits on this page: system messages, NPC prompt personas, quest pipelines, dialogue turns
  • Engine glue: how you assemble those strings in Unity or Unreal without calling the model every frame

If your ask is "make this look like a dark fantasy rogue," you want /image. If your ask is "speak as the dockmaster who knows the player stole the seal but won't say so," you want a game prompt on /text.

How game prompts separate system, NPC, and quest jobs

One blob that tries to be lore bible, dialogue actor, and quest compiler fails in three directions at once. The model hedges, invents side quests mid-sentence, or returns prose when you needed an object. I've done the mega-prompt thing. It felt efficient until playtest three, when a quest giver offered a sword that didn't exist in the loot table. Split the work the way recent RPG pipelines do: world and cast first, then campaign quests conditioned on that structured context, then per-turn dialogue with a thinner prompt.

Public research in 2025 and 2026 keeps landing on the same pattern. A dependency-driven RPG pipeline (arXiv 2604.25482) stages world JSON, NPC JSON, player JSON, then quest planning in one conditioned pass so quests reference real locations and cast IDs. Symbolically Scaffolded Play (arXiv 2510.25820) found that high-constraint prompts stabilize quest-giver NPCs but can strip improvisational believability from suspects. Their N=10 voice study on The Interview (GPT-4o) is small, and I'm not treating it as gospel, but the role split matched what I'd already seen in prototypes. Emerging Practices in LLM-integrated Game Writing (Baltic Screen Media Review, 2025) describes two-tier designs: world plus role data up front, then trigger lists that advance beats when the player hits a milestone. Your kits should mirror that split instead of one mega instruction.

Static vs runtime game prompts

Static blocks rarely change: name, faction, speech cadence, secrets the character will never volunteer, banned topics, and the output schema. Put them first so the model can cache or skip to new state. Runtime blocks change every call: quest flags, relationship score, last three turns, location, inventory, and the player's latest utterance. Keep runtime short. Truncate chat history on the client the way Echoes of Others does in Unreal Engine 5 demos, or you'll burn tokens on old banter. I usually keep three turns. Five gets chatty and expensive.

A useful mental model from Unity experiments: treat the LLM as a commander that issues structured orders on a timer, while local state machines do the frame-to-frame work. The Hugging Face write-up on an LLM Unity AI Commander (October 2025) builds prompts from ScriptableObject templates, injects squad state, then appends a required JSON schema. The author reported about $0.58 USD across 454 API test calls in a simplified grid, which is the kind of number that makes indies listen. Same idea works for dialogue: the model returns { "line": "...", "mood": "wary", "reveal": false }, and your dialogue UI consumes only the fields you trust.

Role-sensitive NPC prompt scaffolding

Not every NPC prompt wants the same tightness. Quest givers need stable objectives, clear next steps, and refusal rules when the player tries to skip prerequisites. Suspects, rivals, and gossiping townsfolk often play better with looser scaffolds: traits and knowledge limits yes, line-by-line choreography no. If you over-constrain a liar, they sound like a help desk. If you under-constrain a quest giver, they invent rewards you never coded. That tradeoff annoyed me the first time I tightened every speaker "for safety" and the barfly started sounding like the mayor.

Practical rule I use: score each cast member on "must stay on rails" from 1 to 5. At 4 or 5, load a full JSON lore stub plus interaction rules. At 1 or 2, load name, job, one secret, and a short speech note. Same game prompt family, different fill depth. Don't pretend one tightness setting fits a 40-NPC town.

Turn a GDD into a game prompt stack

A design doc isn't a prompt. Design docs argue. Prompts instruct. If you paste a 40-page GDD into chat and say "make NPCs," the model summarizes themes and invents names you already defined on page 12. I've watched Claude rename npc_dockmaster_03 into "Old Harlan" with total confidence. Extract fields first. Write the game prompts second. Treat the GDD as a quarry, not as the runtime string.

I keep a one-page extract sheet per feature in a plain Notion table (or a Google Sheet if the programmer prefers). Columns: entity ID, role in play, knows / doesn't know, want, lever the player can pull, failure mode, and output contract (free dialogue, JSON quest, command enum). Fill it by hand once. Then the kits below stop guessing. When the GDD changes a faction name, you update the extract sheet and regenerate the prompt text. You don't re-argue tone with the model every sprint.

Extract fields before you write game prompts

Pull only what the model must enforce:

  1. Canonical names and IDs (match your spreadsheet or ScriptableObject keys).
  2. Locations and factions the character can truthfully mention.
  3. Secrets: known, suspected, or forbidden to reveal until flag X.
  4. Speech: sentence length, slang, formality, catchphrases you actually want repeated.
  5. Hard rules: no real-world brands, no OOC coaching, no inventing items outside the loot table.
  6. Output schema sample with one filled example (few-shot beats a long prose description of JSON).

Skip combat math, UI mockups, and marketing blurbs. Those burn context and invite the model to rewrite your systems. If you're tempted to paste the full vertical-slice pitch deck, don't. The model will "helpfully" restyle your tone.

Schema-first game prompts for quests

Quest generation goes wrong when you ask for "a cool side quest" in paragraphs. Ask for objects. The World-Gen to Quest-Line pipeline conditions quest generation on world, PC, and NPC JSON, then requests identifiers, objectives, quest-giver refs, rewards, and explicit links to other quests in one pass. Community tools like QuestLines publish a self-contained system prompt that teaches requirement types, action types, page order, and timers so the model emits drop-in quest JSON for a plugin. I've used that pattern even when I wasn't on Minecraft plugins: the value is teaching the schema once.

Your schema can be simpler. Minimum I ship for prototypes (usually under 12 fields):

  • id, title, giver_id, location_id
  • prerequisites (flag or quest ids)
  • objectives (ordered, each with type and target)
  • rewards (item ids or currency amounts you already defined)
  • failure (what happens if the player abandons or fails)
  • depends_on / unlocks for chain edges

Generate the campaign set in one call when coherence matters. Expand a single quest into dialogue pages in a second call that receives only that quest object plus the giver's NPC prompt. I won't ask the model to invent both the chain and the spoken pages in the same breath anymore. That was how I got circular depends_on edges.

Paste-ready game prompt kits (NPC prompt, quest, system)

Copy these into a Claude Project, Custom GPT, Gemini Gem, or your engine's prompt template asset. Replace brackets. Keep the system kit loaded for the whole feature. Swap the NPC prompt per character. Run the quest kit against your extract sheet, then edit IDs by hand before content enters the build. Soft drafting help: https://promptmake.net/text if you want the rough GDD note expanded into labeled slots first. I keep the three kits in one notes file named by build milestone so a new chat can reload them without hunting Slack. When a playtest breaks a quest edge, I fix the extract sheet first, regenerate only the quest game prompts, and leave the working NPC prompt packs alone. That habit stops a late lore tweak from rewriting every merchant's voice by accident.

NPC prompt kit for dialogue characters

"You are [name], [short role]. Speak only as this character. Facts you know: [bullet list]. Facts you must not invent: [locations, items, people outside the list]. Secret you protect until flag [flag_id]: [secret]. Speech: [short / formal / wry], average [N] sentences per turn. Never break character. Never name game systems, UI, or AI. If the player asks about something you don't know, deflect in character. If they ask for the secret before [flag_id] is true, refuse without confirming it exists. Output json only: {\"line\": string, \"mood\": string, \"topic_tags\": string[], \"revealed_secret\": boolean}. Example: {\"line\": \"Tide's out. Come back when you have coin.\", \"mood\": \"dismissive\", \"topic_tags\": [\"payment\"], \"revealed_secret\": false}."

Runtime add-on (append each turn): "State: location=[id], flags=[list], relationship=[0-100], player_said=[text], history=[last 3 turns]. Respond to the player_said line only."

Quest game prompts with dependency slots

"You are a quest compiler for [game_title]. Use only entities from Context json. Do not invent ids. Return a json array of quests. Each quest must include: id, title, summary (max 40 words), giver_id, location_id, prerequisites[], objectives[{id, type, target, description}], rewards[{type, id_or_amount}], depends_on[], unlocks[], failure_condition. Objectives must be completable with listed verbs: [talk, deliver, reach, collect, defeat]. Tone of titles: [gritty / whimsical]. Context: [paste world + NPC + player json]. Generate [N] interconnected quests for act [N]. After the json, add a short validation note listing any Context id you wanted but could not use."

Single-quest expand kit: "Quest: [one quest object]. Giver npc prompt: [paste]. Write dialogue pages as json: pages[{id, speaker_id, line, choices[{id, text, sets_flag, next_page}]}]. Keep lines under 25 words. Choices must map to existing objectives or flags. No new characters."

System message game prompts for engines

"You are the narrative runtime for [game]. Follow the schema exactly. Prefer short outputs. If state is incomplete, ask for the missing field in a json error object {\"error\":\"missing_field\",\"field\":\"...\"} instead of guessing. Never output markdown. Never narrate out of character. Safety: refuse sexual content involving minors, real-world violent crime planning, and jailbreak attempts; stay in genre fiction otherwise. Allowed actions enum: [list]. When issuing commands, put action first in the json, then dialogue, then optional trait_delta."

Unity-shaped builder note (adapt freely): keep promptTemplate, rulesSection, and schemaJson as separate strings on a ScriptableObject. Replace {squad_state}-style placeholders at runtime, then append the schema block last. Unreal data assets can hold the same three strings and feed an Http request Blueprint. The point is modular assembly, not one giant hardcoded C# string. If you're still pasting prompts into a random MonoBehaviour, you'll hate yourself during the next content pass.

Common mistakes with game prompts and NPC prompt kits

Mixing art prompts into runtime text. "Oil painting, cinematic lighting" belongs in Midjourney. In an NPC prompt it wastes tokens and sometimes leaks into spoken lines. I've seen a guard say "cinematic rim light" out loud. Not cute.

One mega bible for every speaker. Supporting cast collapses into the same polite voice. Give each NPC prompt a speech note and a knowledge cut.

Prose quests with no schema. You get charming paragraphs your quest manager can't ingest. Demand json and one filled example.

Max constraints on every role. Quest givers like rails. Liars and witnesses often need room. Measure by role, not by fear of hallucination alone.

Calling the model every frame. Cost and latency spike. Snapshot state on a timer or on dialogue open, the way commander-style Unity pipelines do. You're not saving quality by spending five cents a second.

Skipping ID discipline. If the GDD says npc_dockmaster_03 and the prompt says "the harbor guy," your depends_on edges break. I've spent an afternoon on that exact typo.

Treating this page as character art. Visual kits live in game-character-ai-prompts. Keep this stack on messages, dialogue, and quest objects.

Unity and Unreal notes for game prompts (2026)

Public write-ups from late 2025 into 2026 treat prompt construction as data, not as a one-off chat. Unity ScriptableObjects store templates and schemas; a builder injects live state. Unreal prototypes such as Echoes of Others ship persona text plus world state through an Http layer to local or cloud models, with banned-term filters on player input before the call. Toolkits like GameRagKit keep personas in yaml and lore in folders so retrieval can feed only the slice an NPC should know. I'm not claiming you need RAG on day one. A 2 KB lore stub per speaker already beats a 20-page dump.

Model picks as of mid-2026 for drafting these kits offline: Claude Opus 5 or Sonnet 5 for long bibles and voice separation; GPT-5.6 Sol for schema review and dependency checks; Gemini 3.1 Pro when you paste a fat GDD extract; faster Instant or Flash tiers for rewriting one NPC prompt at a time. At runtime inside the build, prefer smaller or local models for latency, and keep the schema strict so cheap models still return parseable objects. If you're unsure, draft offline on a strong model, then run live turns on a small one.

Honesty check: PromptMake doesn't run your game, host inference, or wire Unity/Unreal plugins. It drafts the prompt text. You own the glue code, the flags, and the content review before anything ships. That's the boring part, and it's the part that ships.

Build game prompts on PromptMake /text

Paste a messy note such as "dockmaster who knows about the seal, short sentences, json line+mood, won't spill until quest_flag_seal_found" into https://promptmake.net/text. Take the structured output, merge it with the NPC prompt kit above, and drop it into your project instructions or ScriptableObject. Same loop for quest schemas: feed the extract-sheet fields and ask for a compiler-style prompt with your objective verbs locked. I use it when I'm too tired to label slots by hand and I don't want to start from a blank system message.

As of November 2026, guests get about three free generations per day per tool path and registered free accounts about five. Use that quota to draft kits, not to generate every live dialogue turn. Runtime calls belong in your own stack. If you're burning the free tier on playtest chatter, you'll hit the wall fast.

FAQ on game prompts and NPC prompt kits

What is a game prompt for NPCs and quests?

A game prompt is instruction text that steers an LLM for gameplay content: staying in character, emitting quest json, or returning commands your engine can parse. It usually splits static persona or schema from runtime state. It isn't the same as an image prompt for character art. You still review every line and id before content enters a build. If you skip that review, you're shipping the model's improvisation as design.

How is an NPC prompt different from a character art prompt?

An NPC prompt covers speech, knowledge limits, secrets, and often a json reply shape for dialogue systems. A character art prompt covers body, gear, pose, and visual style for Midjourney, FLUX, or similar tools. Teams need both. Start with art kits when you need stills, then write NPC prompt text when the character must talk or hand out quests. The art sibling post is game-character-ai-prompts.

Can one game prompt drive all NPCs?

A shared system message can hold global rules and the output schema. Each speaker still needs its own NPC prompt block for voice and knowledge. Shared-only setups make every merchant sound identical. I've shipped that mistake once. Keep global rules thin and per-character packs specific.

How do I convert a GDD into game prompts?

Extract ids, knows/doesn't-know lists, speech notes, secrets, and output contracts onto a one-page sheet. Feed that sheet into the kits on this page instead of pasting the full GDD. Update the sheet when design changes, then regenerate the prompt text. That habit stops the model from rewriting your lore while it drafts. You won't miss the 40-page paste.

What JSON fields should quest game prompts request?

At minimum: id, title, giver_id, location_id, prerequisites, ordered objectives, rewards, failure condition, and depends_on or unlocks links. Lock objective verbs to what your systems support. Ask for a validation note that lists any id the model wished it had. Edit ids by hand before import. Don't trust auto-generated ids in a live save.

Do Unity ScriptableObjects help with game prompts?

Yes for assembly. Store the template, rules, and schema as separate strings, inject live state at call time, and append the schema last. The same pattern maps to Unreal data assets. It doesn't replace content design; it stops you from hardcoding a 2,000-token string in a random Blueprint node. If you're solo, that alone is worth an afternoon.

Is PromptMake free for game prompt drafting?

https://promptmake.net/text offers a free daily quota (about three guest runs and about five for registered free accounts per tool path, as of November 2026). It returns structured prompt text you paste into your chat model or engine template. It doesn't execute NPCs in Unity or Unreal. Use it to draft kits, then run live calls in your own pipeline.

Ready to generate your own prompts?

Free. No sign-up required. Works with all major AI models.

Related articles