Build Your Own RPG Quest Generator Based on Tim Cain’s 9 Types

Stop recycling the same boring quest — build a simple, flexible quest generator based on Tim Cain’s nine types

Are you a GM, indie dev, modder, or writer tired of scrambling for believable quest ideas? Do procedural quests in your project feel repetitive or buggy? You’re not alone. Designers from AAA to indie struggle to balance variety, narrative weight, and technical reliability. Tim Cain’s long-running advice — that RPG quests can be grouped into nine core types, and that “more of one thing means less of another” — is a perfect springboard for a small, reliable quest generator you can actually use.

What you’ll get from this guide

• A practical mapping of Cain’s nine quest types into generator building blocks
• Ready-to-use prompt templates for GMs, writers, and procedural-content systems
• Implementation tactics for 2026: LLM integration, safety guardrails, telemetry-driven tuning
• Balancing advice and a simple JSON schema you can drop into a mod, Unity or Twine project

“More of one thing means less of another.” — Tim Cain (as summarized by PC Gamer)

Why Tim Cain’s nine-type frame still matters in 2026

Game narratives and PCG have exploded since 2023: LLMs and multimodal models now make it trivial to generate dialog, side-quests, and item text on the fly. But the core design problem is unchanged — variety is cheap, meaning is expensive. Cain’s nine quest types give you a low-cost taxonomy for diversity that’s easy to encode and control. By using types as primitives you get predictable distribution, modular rewards, and simpler QA for bugs that plague high-volume procedural systems.

Industry trends through late 2025 and early 2026 show two related shifts:

• AI-assisted content generation is mainstream — studios use LLMs to seed quests, but human editing keeps tone and lore consistent.
• Player-tailored micro-quests use telemetry to change stakes dynamically, so a simple type-based generator is easier to personalize without losing structure.

Cain’s nine quest types — a working list you can program

Different write-ups of Cain’s framework use slightly different labels. Use the list below as practical categories you can slot into a generator. Each entry includes a quick definition, why it exists, and the generator variables to control.

1. Fetch / Delivery

Definition: Bring Item A to NPC B (or fetch X from location Y). Simple, versatile, great for economy-driven loops.

• Generator variables: item-type, rarity, distance, guarded (yes/no), time-limit
• Prompt template (GM/Writer): “Deliver a [item-type] to [npc-name] at [location] — problem: route is blocked by [obstacle].”
• PCG notes: Attach randomized traits (item lore, delivery deadline) to change stakes without changing structure.

2. Kill / Destroy

Definition: Remove threat X or destroy object Y. Core combat loop anchor for many RPGs.

• Variables: target-type, number, environment modifiers, optional intel that reveals weakness
• Prompt template: “Hunt down the [target-type] in [biome]. The twist: it’s protected by [gimmick].”
• PCG notes: Use combat modifiers instead of raw HP to produce difficulty variety.

3. Escort / Protect

Definition: Keep an NPC, caravan, or object safe to a destination or for a duration.

• Variables: escort-speed, companion AI reliability, ambush probability, moral choices
• Prompt template: “Escort [companion] from [A] to [B]. Encounters include [encounter types]. Optional decision: [moral choice].”
• PCG notes: Implement simple companion states (panic, injured) to make the same escort feel different.

4. Find / Discover

Definition: Locate something hidden — a person, artifact, or secret location.

• Variables: clue chain length, false positives, environmental puzzle, reveal consequence
• Prompt template: “Find the [object/person] by following clues: [clue1], [clue2], [clue3]. Each clue needs [skill-check].”
• PCG notes: Use probabilistic clue placement to vary search length and difficulty.

5. Convince / Social

Definition: Use dialogue, reputation, or bribery to influence NPC outcome.

• Variables: interlocutor disposition, reputation thresholds, consequences for lying
• Prompt template: “Persuade [npc] to [act] — available approaches: [bribe], [logic], [threat]. Balance reward vs. fallout.”
• PCG notes: Keep a small state machine for NPC attitudes so social quests evolve during retries.

6. Defend / Hold

Definition: Stop waves, hold a point, or delay enemies until help arrives.

• Variables: waves, respawn mechanics, defendable chokepoints, helper NPCs
• Prompt template: “Defend [location] for [duration]. Add [environmental hazards] and [reinforcements].”
• PCG notes: Small layout variations (barrels, chokepoints) create emergent strategies without new assets.

7. Puzzle / Mechanic

Definition: Use a mechanical challenge or environment-based riddle to progress.

• Variables: puzzle type, solution steps, red herrings, hint budget
• Prompt template: “Solve a [puzzle-type] at [site]. Clues: [clue set]. Optional shortcut if player uses [skill].”
• PCG notes: Parametric puzzles (rotations, pattern matching, timed presses) can be auto-generated and parameter-checked for solvability.

8. Trade / Economy

Definition: Buy low, sell high, broker a deal, or manipulate supply chains.

• Variables: market volatility, time window, counterpart risk, political consequences
• Prompt template: “Broker a deal to get [resource]. Decide: [trade route], [safe escort], [cut price].”
• PCG notes: Use simple supply/demand models to make trading quests meaningful without full economic simulation.

9. Activity / Special (Minigame)

Definition: A self-contained activity: race, craft challenge, tournament, or training that tests a skill.

• Variables: activity ruleset, opponents, environmental modifiers, reward scaling
• Prompt template: “Enter the [contest] at [venue]. Conditions: [rule set]. Prize: [reward].”
• PCG notes: Minigames are a great place to use parameterized AI opponents for dynamic difficulty.

From taxonomy to generator — a simple JSON schema

Here’s a compact schema you can copy into a mod or indie tool. Keep it tiny so QA and balance remain tractable.

{
  "quest": {
    "id": "q_001",
    "type": "fetch",          // one of: fetch, kill, escort, find, social, defend, puzzle, trade, activity
    "seed": 42,               // deterministic seed for repeatability
    "core": {
      "subject": "Ancient Tome",
      "target": "Archivist Cel",
      "location": "Half-Flood Library"
    },
    "parameters": {
      "difficulty": 2,         // 1-5
      "timeLimit": 0,          // minutes; 0 = none
      "guards": true,
      "moralChoice": "burnOrSave" // optional
    },
    "reward": {
      "xp": 250,
      "items": ["rusty_key"]
    }
  }
}

Why seed matters: determinism makes testing and community debugging easier for mods. Store seeds alongside telemetry so you can reproduce player-reported edge-cases.

Prompt templates: Quick copy-paste prompts for LLMs and GMs

Use these templates to feed an LLM, or to give instant cues to a GM. Replace bracketed tokens programmatically or by hand.

General LLM prompt (modders)

“Write a concise (3-4 sentences) quest description using type: [type]. Subject: [subject]. Location: [location]. Twist: [twist]. Include 2 optional complications and 2 possible rewards. Keep tone: [tone].”

GM-friendly micro-prompt

“You’re a city GM running a quick session. Give me: 1 one-liner quest hook, 2 NPC names, 1 complication, and 1 surprising reward — for a [type] quest in [location].”

Example (Fetch): “Deliver the Archivist’s Tome to the Half-Flood Library before the tide — guard the path or bargain with smugglers; reward: lore & rare key.” That single line already gives a GM everything to riff on.

Implementation tips — from prototype to reliable in-game system

1. Start small, then parametrize: Implement two or three types first (Fetch, Find, Kill). Add defensive checks to ensure solvability.
2. Use seeds and deterministic randomness: Fixing seeds helps reproduce bugs and community reports—critical for mod support.
3. Telemetry-driven distributions: Track successful completion rates and time-to-complete. Use that to tune spawn distances and clue counts.
4. LLM guardrails and lore aligners: If you generate dialog or quest text via LLMs, run a second pass that enforces canonical names, banned words, and lore facts.
5. Human-in-the-loop for high-impact quests: Reserve story-critical or reputation-altering quests for designer review — an increasingly common hybrid workflow in 2025–26.
6. Testing matrix: For each quest type test edge cases: missing items, dead NPCs, timeouts, soft-locks. The simpler your types, the easier QA becomes.

Balancing and variety — Cain’s warning applied

Cain’s point — “more of one thing means less of another” — is an operational rule: if your generator floods players with fetches, other types will feel rare and special content loses impact. Use a simple weighting system:

weights = {fetch: 30, kill: 20, find: 15, social: 10, defend: 8, puzzle: 7, trade: 5, escort: 3, activity: 2}

Adjust weights based on telemetry and player feedback. For example, if player completion rate for defend quests is low, reduce difficulty or increase reward rather than increasing their frequency.

Examples — three generator outputs and how to run them at the table

Example A — Short GM hook (social + find)

“A famed forger asks you to find the apprentice who ran off with a fake city seal. Track three clues through the docks; decide whether to quietly return the apprentice or expose the racket — reward: bribe + reputation with the Guild.”

Example B — Modder procedural output (defend)

Type: defend. Location: Windwall Outpost. Waves: 4. Special modifier: sandstorm reduces ranged accuracy. Reward: supplies + seasonal favor. Seeded modifier: friendly archer NPC has 60% reliability.

Example C — LLM-generated puzzle

Type: puzzle. Site: Sunken Observatory. Puzzle: three levers with astronomy glyphs. Hint chain: star map fragment + riddled journal. Reward: map to hidden vault.

Advanced strategies for 2026 and beyond

• Multimodal quests: Use images or short audio cues as clues. By 2026, many indie toolchains support short TTS or image assets that make fetch/find quests richer without extra writing.
• Adaptive narrative scaffolds: Combine Cain’s types into layered quests. Example: a Find quest that branches into a Social or Kill climax based on player choices.
• Player-profiled rewards: Telemetry can tune reward type (gear vs. story) to keep players engaged — great for long-running live service mods or tabletop campaigns with persistent characters.
• Community-sourced libraries: Encourage players to submit hooks and vote; use weighted selection to promote high-rated community content into the automated pool.

Common pitfalls and how to avoid them

• Too many variables: A generator with dozens of knobs becomes impossible to QA; keep 6–8 core parameters per type.
• Broken chains: Always include fallback content (hint tokens, NPC reroutes) to prevent soft-locks when assets aren’t present.
• Lore drift from LLMs: Run a second canonicalizer pass to correct names, dates, and proper nouns before shipping text to players.
• Overreliance on combat: If telemetry shows too many kill quests, lower their spawn weight and raise social or find weights to preserve variety.

Quick integration recipes

Unity mod / indie game

1. Create a QuestManager that reads the JSON schema and seeds RNG.
2. Hook spawn points to quest parameters (distance, guards).
3. Call an LLM API to generate flavor text; run canonicalizer middleware to enforce lore.

Tabletop / GM workflow

1. Use the generator to output 6 hooks at session start. Pick two to run; stash the rest as quick sidelines.
2. Assign a difficulty index and a one-line complication for improvisation.

Actionable next steps — build this weekend

• Clone a simple JSON schema (use the example above) and wire a small script that randomly selects a type by weight.
• Create 3 prompt templates and try them with an LLM or your favorite text tool; iterate until the outputs need minimal editing.
• Run a 1-hour QA pass: test 20 generated quests and log failures (unsolvable, soft-lock, lore conflict).

Parting thoughts — make variety meaningful

Cain gave designers a simple lens to think about quests. In 2026 that lens is more useful than ever: use the nine types as your generator’s bones, not its soul. Let the types give structure and predictability while LLMs, multimedia, and telemetry fill in the muscle. Keep human review where it matters, and lean on seeds and guardrails for reliable modding and QA.

If you follow the steps above you’ll have a generator that’s quick to iterate, friendly to players, and safe for mod communities — and it’ll spare you dozens of tired fetch quests that do nothing but clutter your world.

Try this now

Copy the JSON schema above, pick three types to start, and generate 20 quests. Post your favorite output in a dev forum or the comments below — tag it with #Cain9Gen and I’ll critique one fan submission each week.

Ready to build? Start with a small prototype, gather telemetry, and iterate. Your players (and your QA team) will thank you.

Related Reading

• When a Monitor Deal Looks Too Good to Be True: How to Verify the Samsung 32" Odyssey G5 Discount
• Replacing Workrooms: 7 Collaboration Tools Pro Coaches Are Using Now
• From Kitchen to Global: Lessons for Small Pet-Product Brands from a DIY Beverage Success
• Gift Guide: Trading-Card Bundles and Custom Accessories for European Fans
• Cleaning and Storing Vintage Textiles and Hot-Water Bottle Covers Safely