Introduction
A roguelike deckbuilder asks the player to make a chain of decisions across a run: which card to play, how to handle an encounter, whether to add a reward and which route to take next. A prompt that only requests “strategic cards” can produce attractive card art without a usable turn loop. Define the smallest playable sequence first, then make card effects and run progression visible.
This guide uses The Lantern Below, an invented expedition through a branching ruin. Its character, cards, encounters, rewards and values are fictional and untested. No playable prototype or balance test was run for this article; this is game-design guidance, not a claim about an implemented deckbuilder.
Define the run and combat loop
State how a run begins, what advances it and how the player reaches a result. Describe a compact encounter turn: draw a small hand, inspect available resources, play a card or pass, resolve the fictional opponent’s intent, then start another turn or finish the encounter. Specify what persists between encounters and what resets at the end of a run.
Prompt 1 — first-run brief
Design an original roguelike deckbuilder called The Lantern Below. A single expedition contains one starting encounter, two route choices, one reward and a final guardian encounter. Define the player objective, combat turn sequence, starting deck, hand size, abstract energy rule, enemy intent feedback, reward choice, run end and reset. Use original names and placeholder values. List assumptions and untested mechanics; do not claim this has been built or balanced.
The first brief should decide whether a player can undo a card before ending a turn, how unused resources behave and what happens to discarded cards. If those rules are unspecified, card descriptions cannot tell the player what an action will do.
Design cards with readable effects

Each card needs a cost, timing, effect, target and any condition that changes the result. Use concise terms and keep a card’s effect consistent throughout the encounter. Mark whether an effect changes the player state, opponent state or the run. Avoid adding many keywords before a small set of cards can express the core choices.
Prompt 2 — starter deck and card text
Create eight original starter cards for The Lantern Below across attack, guard, focus and utility roles. For each, define a fictional cost, target, timing, effect, limit and one-line player-facing text. Use consistent game terms, avoid copying existing game names or card text, and label all values provisional. Add one example showing how a card changes encounter state without claiming balance.
| Card role | Player decision | State to show |
|---|---|---|
| Attack | Spend a resource to affect a target | Target and expected game-state change |
| Guard | Prepare for a visible incoming intent | Guard state and when it expires |
| Focus | Improve a later fictional action | Amount and duration, marked provisional |
| Utility | Draw, reorder or transform a card | Which cards or zones change |
These are role categories, not final card statistics. A card should explain its effect before the player commits it and report the result after resolution.
Make enemy intent and turns legible
The player needs time to understand the next encounter state. Show an opponent’s intent with consistent icons and a short label, then resolve it at a clearly defined point in the turn. If a card interrupts or changes an intent, tell the player before they spend it. Keep the first encounter small enough to compare a few different responses.
Prompt 3 — encounter rules and intent
Design one non-graphic Lantern Below encounter with an original opponent, a small intent cycle and three player turns. State what the intent icon means, when it resolves, how guard or utility cards respond and what changes after each action. Include victory, defeat and retry states. All numbers are provisional; do not assert the encounter has been playtested or balanced.
A good intent indicator is consistent with the resolution rule. If an enemy action can vary, explain what signals the variation and what options remain. Do not hide whether a card is valid for the selected target.
Connect rewards to the route

Run-based progression works best when a reward and a route choice have a visible consequence. Keep the first map to a few nodes: encounter, rest, reward and guardian. Show which routes are available, which node is selected and whether a reward adds a card, changes a resource or offers a non-card choice. Let the player inspect a reward before accepting it.
Prompt 4 — branching route and reward
Create a small branching Lantern Below run map with an opening encounter, two route options, one reward node, one rest node and a final guardian. For each node, specify the displayed risk or resource tradeoff and how the route state updates. Offer a skip or decline option for a card reward. Keep values provisional and show the player what persists between encounters.
A route map can be a simple planning diagram. Generated art can illustrate branches, but it cannot demonstrate that route selection or run persistence works in a game.
Define deck changes and run persistence
A deckbuilder should tell players where new cards go and how they can review the current deck. Specify whether a reward enters immediately, whether a card can be removed and what happens to temporary cards. Keep the first build’s deck small enough to inspect after a reward and after a run reset.
Prompt 5 — deck and reward rules
Define The Lantern Below’s fictional card zones: draw, hand, discard and removed for this encounter. Explain how a new reward enters the deck, how a declined reward behaves, what state persists at a route node and what resets after defeat. Provide an in-game deck review view that shows the current card list and changes. Use original rules and placeholder values only.
Request a bounded playable slice
One combat encounter, a small starter deck, visible opponent intent, one route reward, a deck review and reset can demonstrate the core loop. Specify the interactions that must work: play a card, resolve the turn, inspect or accept a reward, move to a route node and restart. Ask for a handoff that distinguishes working actions from visual mockups.
Prompt 6 — first playable build
Build a small The Lantern Below prototype with one playable encounter, eight original starter cards, visible card costs and targets, clear enemy intent, turn resolution, victory and defeat states, one route choice, one card reward that can be declined, a deck review and reset. Use placeholder art and clearly provisional values. At handoff, list tested interactions, mockups, known gaps and unverified items. Do not describe static screens as a playable deckbuilder.
A playable claim needs interaction with the actual output. Check card targets and costs, the turn boundary, intent resolution, route selection, reward persistence, deck review and reset. No such build or balance test was run for this article.
Fictional run snapshot
| Field | Lantern Below planning example |
|---|---|
| Run | One starting encounter, route choice, reward and guardian |
| Starter deck | Eight original cards across four roles |
| Turn | Play eligible cards, then resolve visible intent |
| Reward | Add or decline one fictional card |
| Persistent state | Route progress and selected deck changes |
| First milestone | Complete an encounter and inspect the reward path |
| Evidence | Fictional plan only; mechanics are untested |
The snapshot is a scope example, not proof of a balanced run or functional card system.
Review the output and refine one gap

Record what you observed for each interaction. If a reward card appears in the deck screen but not in the next encounter, the persistence rule is unclear or broken. If a card’s target is visible only after play, mark that feedback gap. Fix the smallest mismatch before adding more card types or route nodes.
Prompt 7 — implementation review
Review the running Lantern Below prototype for card selection, cost display, target feedback, effect resolution, discard/draw behavior, enemy intent, turn end, victory/defeat, route choice, reward accept/decline, deck persistence and reset. Mark each present, missing or unclear based on observed interactions. Provide concise evidence and one smallest next change. Label static mockups and untested values; do not claim playtesting or balance unless actually done.
Conclusion
Roguelike deckbuilder prompts should connect card text, encounter turns, visible intent, route choices and run persistence. The Lantern Below is fictional and its values are untested; no build or balance test is claimed. Keep the first run small and verify each state transition before describing the result as playable.
You can take a scoped concept into the Free AI game maker, then compare the result with the review checklist.
FAQ
What should AI prompts for a roguelike deckbuilder include?
Define the run structure, card costs and effects, turn sequence, enemy intent, reward choices, deck zones, persistence and first-build scope.
How do I write clear card effects?
Specify cost, timing, target, effect and limit in consistent terms, and show the expected game-state change before the player commits.
What makes an enemy intent system readable?
Use consistent signals, explain when the intent resolves and show how available cards can respond before the turn ends.
Should a first deckbuilder prototype include a large card pool?
No. A small original starter set is enough to inspect card roles, turn flow, rewards and persistence before expanding the pool.
Does generated card art show that the deckbuilder works?
No. Verify card costs, targets, effects, turn resolution, reward persistence and reset in the running output.


