I Replaced My Entire Design Team With AI — And Built a Fantasy Card Game In The Process

Arcana Bloom is a fantasy card game I designed as a solo creative project, with the help of ChatGPT 4o. It blends game mechanics, narrative design, and visuals into a complete, playable prototype.

I used Figma for prototyping and layout, Photoshop for asset editing and illustration tweaks, and wrapped the whole thing for print in Illustrator.

This project started with a long-time dream to make my own card game. Normally, this kind of project would require a team. But AI let me take on everything: artwork, rules, lore, even basic playtesting.

By the end, I had a real, physical prototype on the table.

The main goal of this project was to challenge myself: How far can I go as a one-person studio?

With a love for fantasy and interactive storytelling, Arcana Bloom became a way to flex my creative muscles across disciplines and experiment with AI-assisted design.

How I came up with the idea?

Arcana Bloom was inspired by my long-time love for Magic: The Gathering. I’ve always admired its depth, rich lore, and complex mechanics. But in my group of friends, Magic never really took off. Too many rules, too much text, and a steep learning curve made it hard to enjoy without serious commitment.

So I set out to build something different.

I wanted a game that captures the feeling of casting spells and battling in a fantasy world - but without the heavy rules or long sessions. Something lightweight and intuitive, but still layered with strategic choices.

The goal was to design a game that’s easy to learn, quick to play, but still full of depth. The kind of game where every match feels different and you come away thinking about different choices you could’ve made.

That mindset reminds me of the card games I grew up with (Belot, Sedma, Durak, Kemps) - quick, social, and competitive in a fun way.

Arcana Bloom is built for anyone who enjoys fantasy, magic, and a bit of creative rivalry. Whether you’re new to card games or looking for something fresh to master, there’s plenty here to explore.

If you like discovering combos, adapting on the fly, or just want to throw fireballs at your friends, you’ll probably enjoy it.

Here’s how the game works

Arcana Bloom is a fast-paced spell-slinging card game for 2 to 4 players. Each player takes the role of a mage, casting spells to reduce opponents' life points to zero. The last one standing wins.

The core mechanics are simple to learn, but there's plenty of depth in how you play. Especially in a 4-player match, where strategy, timing, and a bit of table talk all come into play.

Four spell types, four playstyles

The game revolves around four color-coded spell types, each representing a distinct playstyle:

• 🔥 Fire – Aggressive and destructive
• 🌿 Nature – Healing and supportive
• 💀 Shadow – Disruptive and tricky
• 🌙 Lunar – Defensive and manipulative

Essence & runes

To cast spells, you spend Essence - the game’s main resource. You generate Essence through Runes, which you place and upgrade as you play. Each Rune provides one Essence per turn, in its matching color.

Managing your Runes is key. You’ll need to make choices like:

• Do I upgrade now or wait?
• Can I afford to play this turn, or should I build for the next?
• Should I hold back a Rune to stay flexible?

It’s a tight loop of trade-offs and short-term vs. long-term thinking.

Strategic layers

Beyond casting spells, the game includes several overlapping systems:

• Hand management – What to keep, what to cycle
• Essence economy – Spend now or save up?
• Rune upgrades – Invest in stronger future turns
• Player interaction – Bluff, ally, backstab (especially in 3–4 player games)

The rules are simple, but the game supports different approaches. You can go full aggro, play it safe and reactive, try to control the board, or lean into social play and timing.

There’s no single winning strategy. Arcana Bloom adapts to the players around the table.

Designing and iterating with AI (and balancing everything)

Arcana Bloom went through five major design phases - each shaped by fast iteration, AI input, and hands-on testing.

I used ChatGPT 4o not just as a brainstorming tool, but as a full creative and analytical partner to help me generate card ideas, balance effects, write and refine the rulebook, and simulate actual gameplay.

Here’s a breakdown of how the design evolved.

Phase 1: Setting the foundation

It started with a single prompt:

“Design a 40-card fantasy card game that feels like Magic: The Gathering meets Belot, but is easy to learn.”

From there, I set five non-negotiables:

• Shared deck
• 2–4 players
• 30-minute sessions
• Simple, teachable rules
• Skill should matter more than luck

Phase 2: Prototyping core systems

I worked with ChatGPT to refine the basics: spell colors, Essence as a resource, and how Runes fuel spells. I built the first 40-card prototype and grouped cards by color and function.

Then I added the Rune + Essence economy.

Spells now had costs, and Runes became the main resource engine. Early tests showed that 40 cards weren’t enough for 4 players. So I expanded.

Phase 3: Simulations & refinement

To stress-test the design, I ran AI-powered simulations and tracked:

• Damage and healing output
• Combo frequency
• Resource flow
• Deck reshuffle pacing

What changed:

• Deck grew to 60 cards
• Cards simplified into two types: Spells (your turn) and Tricks (any time)
• Removed all “if” and “when” logic from cards for faster, smoother play
• Each spell color was rebalanced to support a clear playstyle

Phase 4: Resource system rework

I redesigned the Rune system to include enchantments and upgrades, adding midgame decisions and better scaling.

At the same time, I rebuilt the full deck:

• 15 cards per color
• Clear color identity and combo logic
• No “dead” cards, every hand should be playable

Phase 5: Flow & fail-safes

To improve pacing and avoid stalemates:

• Starting hand increased from 5 to 6 cards
• Reshuffling the deck now causes HP loss to all players (adds late-game pressure)
• Introduced a soft HP cap to prevent infinite healing loops

Final phase: Rulebook + simulation ready

Once the game stabilized, I built a complete Markdown rulebook and exported the full decklist. This version now runs through a simulation engine and serves as the base for future playtests and physical builds.

Visual & UX design

Even though the game’s visuals were made with AI, it didn’t mean hitting “generate” and calling it a day. It was a bit far from automatic.

Getting 60 unique cards to look like they belong in the same world took a lot of back-and-forth, visual rules, and style planning. Each card has its own vibe, effect, and tone, so making everything feel consistent was a real design challenge.

Lore & worldbuilding

Before I started working on the game’s visual identity, I needed to define its world. Working with ChatGPT, I shaped the lore and the setting by sharing the kinds of universes I love - Game of Thrones, Lord of the Rings, World of Warcraft, and others.

From there, I prompted the AI to ask me detailed questions about tone, factions, ideas, and conflicts.

Together, we built a narrative foundation that supports both the gameplay and the visual mood.

This short story become a central element of the game’s identity:

“The Crown of Realms has shattered. Elemental dragons rise once more to reign, flooding the world with wild, corrupting magic. Mages—driven mad by the magical power flowing through them—clash in chaotic duels that tear reality apart.”

This became the anchor for the game’s visual direction, guiding everything - from elemental symbolism to the spell effect intensity and the moody, fractured environments depicted on the cards.

Structuring the card layout

My first move was to define a standardized card layout to support both functionality and aesthetics:

• Card titles at the top
• Casting cost and effect text near the bottom
• White text over a dark vignette for clarity
• Central art zone left unobstructed to let visuals shine

To keep things consistent across all cards, I designed a 6x6 grid system. I used it to guide the AI, placing key elements in specific rows (usually 2 to 4) and keeping the top and bottom clear of distractions (like lighting effects or contrast spikes).

This grid system was the single most important fix for visual consistency. It turned messy outputs into a clean, unified set of illustrations that let the art feel magical and alive.

Colors, icons, and art direction

To keep things readable and visually consistent, each of the four spell types (Fire, Nature, Shadow, and Lunar) was built around a clear identity system:

• A dedicated symbol
• A distinct color palette
• A recurring visual motif in the artwork

The spell type symbols appear in all four corners of each card. That way, even when cards are fanned in hand, players can quickly identify what they’re holding. This also makes the game more accessible for colorblind players, adding a second layer of clarity beyond color alone.

Defining the illustration style

From the start, I knew I wanted a visual style that felt fantasy-driven, painterly, and easy to read. Each spell needed its own personality, but the entire set still had to feel like it belonged together.

I created moodboards for each category, then refined each card through several iterations until the look and tone lined up. This helped me lock in the overall art direction - mystical, moody, but always functional.

Eventually, I discovered that the most effective way to standardize the visual language was through YAML-formatted prompts. This gave me precise control over how the AI generated images.

Each prompt specified:

• Composition rules - where to place the subject (usually cented in rows 2-4)
• Lighting behavior - avoid bright spots near text zones
• Thematic details - elements that matched the spell’s tone
• Scene setup - mood, background, camera angle, and focal length

This made it much easier to batch-generate cards while maintaining creative control.

For example, here’s an excerpt from the prompt I used to generate the Fire spell Ignite:

card_type: Spell
element: Fire
name: "Ignite"
effect: "Put a target opponent on fire."
prompt: >
  A fantasy spell card illustration in 1:1 format depicting a mage whose robes are starting to burn.
  The mage is small, horizontal, and contained entirely within the center third of the canvas (rows 2–4 of a 6×6 grid). It does not touch or extend into the top row (row 1) or bottom rows (5–6).
  The mage is viewed from a slightly elevated angle to keep it compact. Smoke rises gently, but fades before reaching the top.
  The area above and below the flame is left visually quiet—only soft shadows, stone, or faint ash. There is faint glowing around the fire. There is an axe burning in the fire. The blade of the axe is put into the ground, with its hilt sticking out to the right. 
  The flame glows in ember orange and molten gold, set against a dark, rocky background in the Dragonfire style.
  No text elements. --ar 1:1 --style raw --q 2 --size 2000x2000

identity_motif:
  primary_symbol: glowing fire
  background: dark clearing, glowing ash, faint ember sparks
  visual_mood: quiet ignition, warmth, destruction

My core rule when prompting was:

Always tell the AI what to do, not only what to avoid.

Prototyping in Figma

All layout and print preparation for Arcana Bloom was handled in Figma. I built reusable components for each card type and sorted everything by color and spell category.

This setup became a single source of truth for balancing the deck, tracking changes, and preparing files for print.

Figma’s speed and flexibility make it ideal for managing a large system like this. I could quickly test layout changes, swap in updated assets, and keep the entire card set organized without breaking the flow.

Challenges of using AI in a real workflow

Working with AI as a design partner was powerful, but not without its challenges. While the tools did accelerate ideation and simulation, they introduced new types of friction that required careful workarounds and creative thinking.

Managing card data was a headache

Keeping track of all 60 cards inside a chat thread turned out to be a mess. I initially handled it as a table inside the thread, but prompting for specific changes proved unreliable.

What went wrong:

• Cards I didn’t touch got unintentionally edited
• Others were randomly deleted or duplicated
• Instructions like “change just the effect, keep the rest” often got ignored

Oftentimes I had to update the list manually and carefully, tracking edits outside the AI to prevent these destructive mistakes.

Lesson learned: ChatGPT is great for ideas, but terrible for version control.

Version drift & cognitive overload

As the sessions grew longer, I encountered the context drift. The AI would forget previous design decisions or reintroduce cut mechanics (e.g. re-adding if-conditionals in card effects after removal).

To keep things stable:

• I began writing session summaries and phase recaps
• I tagged rule changes explicitly to maintain structure
• I saved clean snapshots of the rulebook and deck list externally

This helped keep the logic clean during simulations and avoided errors from outdated memory.

Lost work & backups

In a few cases, ChatGPT-generated documents (rulebooks or full card lists) became inaccessible or vanished from history.

This was a painful lesson, but an important one. Always download a backup as soon you make some progress. Never rely on the chat to remember.

Prompting AI for visuals took real work

Creating illustrations came with another steep learning curve. In early versions, AI-generated artwork clashed with the layout. It would generate glowing or high-contrast elements in text zones.

Simply telling the AI what not to do (e.g. “don’t touch the top area”) didn’t work well.

Things improved dramatically when I introduced a 6x6 grid system and wrote prompts that explained where elements should appear instead.

“Place the glowing object entirely within rows 2–4. Leave the top and bottom rows visually quiet.”

That shift from avoiding mistakes to clearly specifying the desired output made all the difference. That’s when the visuals finally started to come together and feel consistent.

What was the outcome and what did I learn

Arcana Bloom started as a passion project. I wanted to challenge myself and see how far can I go as a one-person creative team. And could I use AI as a partner, rather than a shortcut? (The answer is: YES!)

In time it evolved into a fully playable fantasy card game with original mechanics, its own world and story, a unique visual style, and a working physical prototype.

Throughout the entire process, I was able to:

• Design a 60-card shared-deck game that mixes the strategy of Magic: The Gathering with the fast, accessible feel of old-school European card games
• Build a simple but deep resource and combo system based on elemental synergy, table politics, and timing
• Develop a consistent visual style using YAML prompts and a structured grid layout to guide AI illustrations
• Learn how to actually work with AI. It became easier to steer it, decide when to trust it, and to stay in control of the creative process
• Use Figma to prototype and organize everything from layout to card sets, and prep it all for print

More than anything, this project gave me creative confidence. It pushed me to bring together everything I know about game design, storytelling, UX thinking, visual design, and apply it in a new way.

It showed me that with a clear goal and enough iteration, a single person can build something really cool.

I’m now entering the playtesting phase. It is time to start fine-tuning the balance and improve the physical experience. Whether it stays a personal project or one day something bigger, Arcana Bloom has already done what it was meant to do: spark creativity, push my skills, and remind me why I love creating stuff.