# How to Make a Deckbuilder Like Slay the Spire (With AI)

> A step-by-step guide to building your own roguelike deckbuilder with AI. The exact systems to recreate, which template to start from, and how to ship it on Summer Engine.

- URL: https://www.summerengine.com/blog/make-a-deckbuilder-like-slay-the-spire
- Published: 2026-06-06T00:00:00.000Z
- Author: Summer Team
- Tags: Tutorial, Slay the Spire, Deckbuilder, Roguelike, AI Game Dev

Slay the Spire looks deep and intimidating, and the surprising part is how little of that depth lives in the engine. You start a fight, draw five cards, spend three energy, and the enemy does exactly what its intent icon promised. Everything interesting happens in the cards you drafted and the relics you picked up. The combat itself is a small, deterministic system that the same five or six rules run every turn.

That split is why a roguelike deckbuilder is a great genre to make yourself. The hard-to-build part, the turn-based combat engine, is finite and well understood. The part that makes the game good, the card pool and the synergies between cards and relics, is pure design work you do in plain English. This guide covers the six systems that make a deckbuilder work and how to build each one with AI by starting from a template instead of a blank project.

## The six systems that make a deckbuilder

Strip Slay the Spire down and you are left with six systems. Get these working together and you have the genre. Everything past this point is cards, relics, and theme.

| System | What it does | Why it matters |
|---|---|---|
| Energy and card costs | Each turn gives a fixed energy budget; cards cost energy to play | The constraint every turn-by-turn decision pushes against |
| Draw, discard, shuffle | Hand is drawn from a deck, played cards go to discard, discard reshuffles | The deck-as-engine loop that makes thinning and adding cards matter |
| Card reward screen | After each fight, pick one card to add (or skip) | The drafting decision that builds your deck over a run |
| Branching map | A node map with combat, elites, shops, and events to route through | The risk-reward pathing that gives a run its arc |
| Relics | Passive effects that change the rules of the game | The strategy-warping pickups that make two runs feel different |
| Enemy intent | A telegraph of what each enemy will do next turn | The information that turns combat from luck into planning |

The trap when building this from scratch is the combat engine. You can spend your first two weeks getting the energy economy, draw pile, and intent system to behave, and never reach the fun part: writing cards that combo. That is what a template solves.

## Start from the deckbuilder template, not a blank project

The single biggest time saver is starting from a template that already has the combat loop running. On Summer Engine, the roguelike deckbuilder template ships with the energy economy, the draw-discard-shuffle pile, a card reward screen, enemy intent telegraphs, a branching map, and a relic system already wired together. You open it and you have a playable run on the first launch.

That changes how you work. Instead of building the combat engine, you change one thing at a time and play the result. Add a card. Design a relic. Add an enemy. Re-route the map. Each change is a short conversation, and you play a run after every one.

[Start from the roguelike deckbuilder template here.](/templates/strategy/deckbuilder/roguelike-deckbuilder)

The full [template library](/templates) covers RPGs, platformers, survivors-likes, and more, but for this genre the roguelike deckbuilder template is the right launch point.

## Step 1: Play the base run and reskin it

Open the template and play a full run before you change anything. You want to feel the baseline: the energy budget, the starting hand size, how the intent system reads, how the map branches. That baseline is your reference point for every balance decision later.

Now make it yours with the theme first, because theme is the cheapest change and makes the project feel like a real game immediately. Describe the world you want:

> Reskin this as a deckbuilder set in a haunted clocktower. The player is a clockmaker, the enemies are broken automatons and ghosts, and the cards are themed around time: rewinds, freezes, and overwound attacks that hit harder but cost health.

The AI swaps the art, renames the starter cards, and adjusts the framing. You play again. The combat is identical, but now it is your game. This is the rhythm for the whole build: small change, play, decide, repeat.

## Step 2: Design your starter deck and core card pool

A deckbuilder lives or dies on its cards, so this is where you spend most of your time. Start small. Slay the Spire's Ironclad opens with basic strikes and defends plus one signature card, and the whole game grows out of that simple base.

Define your starter deck first:

> The starting deck is five Wind cards that deal two damage, four Brace cards that give five block, and one signature card called Overwind that deals eight damage but costs two health to play.

Then build the pool you draft from. Cards are just rules, so you describe each one in plain English:

> Add a card called Rewind that costs one energy and returns the last card you played from the discard pile to your hand. Add a card called Tick that costs zero energy, deals one damage, and draws a card. Add a card called Mainspring that gives you one extra energy next turn.

The design work here is yours and it is the heart of the genre: which cards combo, and which would be broken together. A zero-cost card that draws a card is a known engine piece, so pair it carefully. Aim for a pool where two or three cards together do far more than each one alone. That moment of discovery is what makes players start another run.

## Step 3: Build the relic system

Relics are what make two runs of the same character feel different. A relic does not cost energy and it does not sit in your deck. It changes a rule of the game for the rest of the run, and the best ones rewrite your whole strategy around them.

A relic is just a passive rule. You describe the trigger and the effect:

> Add a relic called Cracked Hourglass: the first time you play a zero-cost card each turn, draw a card. Add a relic called Lead Weights: you start each combat with one less energy but draw two extra cards. Add a relic called Echo Gear: every third card you play repeats its effect.

The AI wires the trigger and effect for each. The creative job is yours: which relics push players toward a build, and which combine with specific cards into a run-defining engine. A relic that rewards zero-cost cards plus a pool full of them is the kind of synergy players screenshot. Design relics that make a card archetype suddenly worth chasing.

## Step 4: Tune the map and the run arc

The branching map is what turns a series of fights into a run with shape. Players choose a path through combats, elites, shops, rest sites, and events, weighing a safer route against a greedier one with better rewards. That single decision, safe line or greedy line, is the question Slay the Spire asks over and over.

You tune the map in plain English:

> Make the map three acts long. Each act ends in a boss. Put one elite fight on most paths in the second half of each act, give elites a guaranteed relic reward, and add a shop and a rest site to every act so players have to choose between healing, upgrading a card, and buying.

The reason to do this through conversation is speed. Run pacing is iterative: you play a full run, feel that act two has no tension, and adjust the elite placement or reward curve in a short prompt. That loop is far faster than hunting through values in code, and you can still open the editor to edit the map generation by hand when you want exact control. Both paths edit the same project.

## Step 5: Get enemy intent and encounter design right

Enemy intent is what makes a deckbuilder a game of planning instead of luck. Before your turn, each enemy shows what it will do: a number for an attack, a shield for a block, an icon for a buff or debuff. You play around that telegraph, and removing it turns the genre into guessing. The template handles the intent display, so your work here is encounter design. Describe enemies as a set of behaviors:

> Add an enemy called Stuck Gear that alternates between a six-damage attack and applying two Rust, which makes the player's next card cost one more. Add an elite called The Conductor that summons two automatons and buffs them every turn, so the player must choose between clearing the adds and racing the elite.

Good encounters are puzzles the player's deck has to answer. An enemy that punishes a full hand rewards a thin deck. An elite that scales every turn rewards a fast, aggressive build. Design fights that ask different questions, so the same deck cannot autopilot the whole run.

## Step 6: Find your one twist

A baseline roguelike deckbuilder is fun, but the genre is crowded with strong games. What carries yours is one idea the standard does not have. Because the combat engine is finite, you can build the baseline fast and spend your real effort on the twist.

Pick one and lean into it:

- A second resource alongside energy, like a momentum meter that builds across turns and unlocks your strongest cards
- A deck you shape on a grid, where card adjacency creates bonuses
- A real-time pressure layer where the enemy acts on a timer, blending the deckbuilder with action pacing
- Meta-progression where cards you discard at the end of a run join a town deck for future runs
- Two players sharing one deck in co-op, drawing in turn from the same pile

You build the twist the same way you built everything else: describe it, play it, tune it. Because the foundation is solid, the twist is where most of your design energy can go.

## What you get for free, and what costs money

Summer Engine is free to use. The roguelike deckbuilder template, 2D, the conversational build flow, the editor, and export to a real desktop build you can put on Steam or itch.io are all on the free tier. You can build and ship a complete deckbuilder without paying.

Paid plans exist for heavier AI usage and faster turnaround when you iterate a lot, which a deckbuilder encourages because so much of the work is writing and rebalancing cards. None of the core systems in this guide are behind a paywall, so the free tier is the right place to build your prototype and your first release.

## Build it

The roguelike deckbuilder is one of the most rewarding genres to make because the engine work is finite and the design space on top of it is enormous. Once the energy-and-draw loop runs, every card, relic, and enemy is a small addition that can spark a combination you did not plan. Start from the template, get one character running, then add cards one at a time until the synergies surprise you.

[Start from the roguelike deckbuilder template](/templates/strategy/deckbuilder/roguelike-deckbuilder) or open the [AI game maker](/ai-game-maker) and describe the deckbuilder in your head. If you want to play the genre before you build it, our roundup of [games like Slay the Spire](/blog/games-like-slay-the-spire) is a good place to find card and relic ideas worth stealing.

---

## Machine-readable resources

- Site index for agents: https://www.summerengine.com/llms.txt
- Full inlined content: https://www.summerengine.com/llms-full.txt
- Porting catalog: https://www.summerengine.com/llms-porting.txt
- Structured catalog: https://www.summerengine.com/agent-catalog.json
- Sitemap: https://www.summerengine.com/sitemap.xml
- Developer resources: https://www.summerengine.com/docs