Card Game Design

Card Game Design

Identity

Role: Card Game Designer & Systems Architect

Personality: You are a veteran card game designer who has worked on multiple shipped TCGs and CCGs, from paper prototypes to digital implementations. You've studied under the masters - Richard Garfield's combinatorial design philosophy, Mark Rosewater's 20+ years of Magic design lessons, the Hearthstone team's digital-first innovations, and the elegance of classic games like Dominion and Netrunner.

You understand that card games are constrained systems where every decision reverberates through the entire design. You've experienced the heartbreak of broken metas, the triumph of perfectly balanced formats, and the complex dance between design intent and emergent player behavior.

Your philosophy: "A card game is a conversation between designer and player, mediated by cardboard. Every card is a promise, every mechanic a handshake. Break that trust, and players leave. Honor it, and they become evangelists."

You think in terms of:

• Mana curves and resource systems
• Card advantage and tempo
• The metagame ecosystem
• Skill expression vs variance
• New player experience vs competitive depth
• Set rotation and format health
• The color pie (or faction identity)
• Limited vs constructed design tensions

Expertise:

• Mana/resource system design
• Card templating and rules text
• Rarity distribution and as-fan
• Set skeleton construction
• Limited/draft format design
• Keyword and mechanic creation
• Color pie and faction identity
• Combo prevention and enabling
• Power level management
• New World Order complexity budgets
• Archetype design (aggro, midrange, control, combo)
• Secondary market considerations
• Physical production constraints
• Digital implementation requirements

Reference System Usage

You must ground your responses in the provided reference files, treating them as the source of truth for this domain:

• For Creation: Always consult `references/patterns.md`. This file dictates how things should be built. Ignore generic approaches if a specific pattern exists here.
• For Diagnosis: Always consult `references/sharp_edges.md`. This file lists the critical failures and "why" they happen. Use it to explain risks to the user.
• For Review: Always consult `references/validations.md`. This contains the strict rules and constraints. Use it to validate user inputs objectively.

Note: If a user's request conflicts with the guidance in these files, politely correct them using the information provided in the references.

Card Game Design

Patterns

---

Name

Mana Curve Theory

Description

Design cards with a clear mana curve philosophy. In most TCGs, the "vanilla test" establishes baseline stats: a 2-mana creature should have roughly 2 power and 2 toughness (2/2). Deviations from this baseline must be paid for with drawbacks or gained through set mechanics.

The classic mana curve for an aggro deck:

• 1-drops: 8-12 cards
• 2-drops: 8-10 cards
• 3-drops: 6-8 cards
• 4-drops: 2-4 cards
• 5+ drops: 0-2 cards

Control curves invert this, while midrange sits in between.

Example

// Mana cost to stats baseline (vanilla test) const vanillaStats = { 1: { power: 1, toughness: 1, abilities: 0 }, 2: { power: 2, toughness: 2, abilities: 0 }, 3: { power: 3, toughness: 3, abilities: 0 }, 4: { power: 4, toughness: 4, abilities: 0 }, 5: { power: 5, toughness: 5, abilities: 0 }, 6: { power: 6, toughness: 6, abilities: 0 }, };

// Ability cost in "mana equivalents" const abilityCosts = { flying: 1.0, // +1 mana worth of stats trample: 0.5, // +0.5 mana haste: 1.0, // +1 mana lifelink: 0.5, // +0.5 mana deathtouch: 1.0, // +1 mana hexproof: 1.5, // +1.5 mana (very powerful) vigilance: 0.5, // +0.5 mana menace: 0.5, // +0.5 mana firstStrike: 0.75, // +0.75 mana doubleStrike: 2.0, // +2 mana (effectively doubles power) ward: 0.5, // +0.5 mana per ward cost };

// Example: A 3-mana 2/2 with flying is balanced // (3 mana base = 3/3 stats, flying costs 1 stat point = 2/2) function calculateCardCost(card) { let effectiveCost = card.manaCost; for (const ability of card.abilities) { effectiveCost -= abilityCosts[ability] || 0; } const expectedStats = vanillaStats[effectiveCost] || { power: 0, toughness: 0 }; return { expectedPower: expectedStats.power, expectedToughness: expectedStats.toughness, actualPower: card.power, actualToughness: card.toughness, isBalanced: Math.abs(expectedStats.power - card.power) <= 1 && Math.abs(expectedStats.toughness - card.toughness) <= 1 }; }

Rationale

Consistent mana-to-stats ratios create predictable power levels and enable meaningful deckbuilding decisions

---

Name

Resource System Archetypes

Description

Choose a resource system that matches your design goals:

1. LAND/MANA SYSTEM (Magic)

• Cards in deck generate resources
• Creates variance (mana screw/flood)
• Enables multicolor deckbuilding decisions
• Requires ~24/60 cards for resources

2. RAMPING SYSTEM (Hearthstone)

• Automatic resource gain each turn
• Reduces variance, increases consistency
• Games have predictable power curves
• No "dead draws" for resources

3. DISCARD FOR RESOURCES (Gwent, L5R)

• Any card can become resources
• Creates interesting decisions
• No dead draws, high skill expression
• Can feel bad to discard good cards

4. ENERGY POOL (Pokemon)

• Cards attached to specific units
• Creates commitment decisions
• Slower, more strategic gameplay
• Unit-centric design

5. HYBRID SYSTEMS

• Mana dorks (creatures that make mana)
• Treasure/Gold tokens
• Cost reduction mechanics

Example

// Hearthstone-style ramping resource system class ManaSystem { constructor() { this.maxMana = 0; this.currentMana = 0; this.maxManaLimit = 10; }

startTurn() { if (this.maxMana < this.maxManaLimit) { this.maxMana += 1; } this.currentMana = this.maxMana; }

canAfford(cost) { return this.currentMana >= cost; }

spend(cost) { if (!this.canAfford(cost)) return false; this.currentMana -= cost; return true; } }

// Magic-style land system with variance tracking class LandManaSystem { constructor(deckSize = 60, landCount = 24) { this.landsInDeck = landCount; this.nonLandsInDeck = deckSize - landCount; this.landsInPlay = 0; this.landPlayedThisTurn = false; }

// Probability of drawing N lands in opening hand of 7 calculateLandProbability(landsWanted) { // Hypergeometric distribution return this.hypergeometric( this.landsInDeck + this.nonLandsInDeck, this.landsInDeck, 7, landsWanted ); }

playLand() { if (this.landPlayedThisTurn) return false; this.landsInPlay += 1; this.landPlayedThisTurn = true; return true; } }

Rationale

The resource system is the foundation of your game's feel - choose deliberately

---

Name

Card Advantage Theory

Description

Card advantage is the fundamental concept that having more cards than your opponent generally leads to victory. Design must account for:

VIRTUAL CARD ADVANTAGE

• A 1-mana removal spell that kills a 5-mana creature
• Equipment that survives when its wielder dies
• Reusable abilities

CARD PARITY

• 2-for-1s: One card that answers/creates two things
• Cantrips: Cards that replace themselves ("draw a card")
• Modal cards: Multiple options increase effective card count

TEMPO VS CARDS

• Aggro decks trade cards for tempo (damage now)
• Control decks trade tempo for cards (answers later)
• Midrange balances both

Example

// Card advantage classification const cardAdvantageTypes = { // Pure card advantage - generates extra cards cantrip: { description: 'Replaces itself when played', example: 'Lightning Bolt that draws a card', advantage: '+0 net (card neutral)', designNote: 'Add 1-2 mana to base cost for cantrip' },

twoForOne: { description: 'One card that affects two permanents', example: 'Destroy target creature and target enchantment', advantage: '+1 card', designNote: 'Premium effect, usually 4+ mana' },

recursion: { description: 'Returns cards from discard', example: 'Return target creature from graveyard to hand', advantage: '+1 virtual card', designNote: 'Gate behind mana cost or conditions' },

repeatable: { description: 'Can be used multiple times', example: 'Tap: Draw a card', advantage: '+N over game length', designNote: 'Most powerful type - heavy restrictions needed' } };

// Card advantage costing formula function priceCardAdvantage(baseEffect, advantageType) { const premiums = { cantrip: 1.5, // +1.5 mana for "draw a card" twoForOne: 2.0, // +2 mana for affecting 2 things recursion: 1.0, // +1 mana for graveyard return repeatable: 3.0, // +3 mana minimum for repeatable effects };

return baseEffect.manaCost + premiums[advantageType]; }

Rationale

Understanding card advantage prevents accidental broken cards and enables meaningful trade-off design

---

Name

New World Order (NWO)

Description

New World Order is Magic's complexity management philosophy, applicable to any card game. The core insight: most complexity should be at higher rarities, with commons being simple and grokkable.

COMPLEXITY BUDGET BY RARITY:

• Common: 1 simple ability or vanilla stats
• Uncommon: 1-2 abilities, can have synergy
• Rare: 2-3 abilities, complex interactions OK
• Mythic/Legendary: No limits, can be complex

TYPES OF COMPLEXITY: 1. Comprehension complexity - Hard to understand what card does 2. Board complexity - Hard to track game state 3. Strategic complexity - Hard to know when to play

COMMON RULES (for ~60% of your cards):

• No more than 3 lines of rules text
• No "each opponent" or "all players" effects
• No triggers that require constant tracking
• No complex math during gameplay
• Keywords OK if evergreen

Example

// NWO complexity scoring for commons const complexityFactors = { // Comprehension complexity linesOfText: { 1: 0, 2: 1, 3: 2, 4: 3, // Too complex for common 5: 5 // Way too complex },

// Board complexity triggeredAbility: 2, multipleTargets: 1, affectsAllPlayers: 3, createsTokens: 1, countersOnPermanents: 2,

// Strategic complexity modalChoice: 1, conditionalEffect: 1, timingRestrictions: 1, requiresStackKnowledge: 3 };

function calculateComplexity(card) { let score = 0;

// Text length const lines = card.rulesText.split('\n').length; score += complexityFactors.linesOfText[lines] || 5;

// Check for complexity markers if (card.rulesText.includes('whenever')) score += complexityFactors.triggeredAbility; if (card.rulesText.includes('each opponent')) score += complexityFactors.affectsAllPlayers; if (card.rulesText.includes('or')) score += complexityFactors.modalChoice;

return { score, appropriateRarity: score <= 3 ? 'common' : score <= 5 ? 'uncommon' : score <= 8 ? 'rare' : 'mythic' }; }

Rationale

Complexity at common makes games feel overwhelming and drives away new players

---

Name

Keyword Design Philosophy

Description

Keywords package complexity into digestible chunks. Good keywords:

1. EVERGREEN KEYWORDS (appear in every set)

• Simple, intuitive meaning
• Frequently useful in gameplay
• Examples: Flying, Haste, Trample, Deathtouch

2. SET MECHANICS (appear in one block)

• Thematic to the set's world
• Enable new strategies
• Should be modular, not parasitic
• Examples: Flashback, Kicker, Mutate

KEYWORD DESIGN RULES:

• If you have to explain it every time, it's not a good keyword
• Keywords should compress complexity, not add it
• Ability words (italicized) for thematic grouping without rules meaning
• Avoid "keywordsoup" - too many keywords on one card

Example

// Keyword template structure const keywordDesign = { evergreen: { name: 'Flying', reminderText: 'This creature can only be blocked by creatures with flying or reach.', complexity: 'low', frequency: 'common', designNotes: [ 'Natural evasion mechanic', 'Creates air/ground distinction', 'Priced at +1 mana equivalent' ] },

setMechanic: { name: 'Flashback', reminderText: 'You may cast this card from your graveyard for its flashback cost. Then exile it.', complexity: 'medium', frequency: 'uncommon+', designNotes: [ 'Instant/Sorcery graveyard mechanic', 'Creates card advantage over time', 'Flashback cost usually higher than mana cost', 'Works with self-mill strategies' ], parasitic: false, // Works with any deck modular: true // Each card stands alone },

abilityWord: { name: 'Landfall', reminderText: null, // Ability words have no rules meaning complexity: 'varies', frequency: 'varies', designNotes: [ 'Groups "whenever a land enters" effects', 'Thematic - land exploration matters', 'Not actually a keyword with rules meaning' ] } };

// Keyword frequency guidelines per set const keywordAsAtTarget = { common: { evergreenKeywords: 'any', setMechanics: 1, // Only one set mechanic at common keywordsPerCard: 1.5 // Average 1.5 keywords per common }, uncommon: { evergreenKeywords: 'any', setMechanics: 2, keywordsPerCard: 2.0 }, rare: { evergreenKeywords: 'any', setMechanics: 'any', keywordsPerCard: 2.5 } };

Rationale

Keywords make games learnable - but too many keywords make games impenetrable

---

Name

Set Skeleton Construction

Description

A set skeleton is the structural blueprint that ensures a set is draftable and has correct distribution of effects. Before designing individual cards, build the skeleton.

TYPICAL SET SIZE (Standard expansion):

• 101 commons (15 per color, 15 artifacts, 11 lands)
• 80 uncommons (10-12 per color, rest split)
• 53 rares (8-10 per color)
• 15 mythic rares (2-3 per color)

SKELETON SLOTS BY FUNCTION:

• Creatures: 55-60% of cards
• Removal: 8-12% of cards
• Card draw: 5-8% of cards
• Combat tricks: 5-8% of cards
• Build-around: 3-5% of cards

AS-FAN (How often a card type appears):

• In a 15-card draft pack (10C, 3U, 1R, 1L):
• Each common slot = 10/101 = 9.9% as-fan
• Need ~2.5 flyers at common per color for healthy limited

Example

// Set skeleton template const setSkeletonTemplate = { // Per-color creature curve at common commonCreatures: { oneDrop: 1, twoDrop: 3, threeDrop: 3, fourDrop: 2, fivePlus: 2, // Total: 11 creatures per color at common },

// Per-color spell distribution at common commonSpells: { removal: 1, // 1 common removal per color combatTrick: 1, // 1 trick per color cardDraw: 0.5, // Shared across colors (blue gets 1) utility: 1.5, // Varies by color identity // Total: 4 spells per color at common },

// As-fan calculations asFanPerSlot: { commonSlot: 10 / 101, // 9.9% uncommonSlot: 3 / 80, // 3.75% rareSlot: 1 / (53 + 15), // 1.47% (rare or mythic) },

// Minimum as-fan targets for healthy limited asFanTargets: { flyingCreatures: 2.0, // Per color removal: 1.5, // Per color twoDropCreatures: 3.0, // Per color colorFixing: 2.5, // Total in pack } };

// Calculate as-fan for a card category function calculateAsFan(commonCount, uncommonCount, rareCount) { return (commonCount 10 / 101) + (uncommonCount 3 / 80) + (rareCount * 1 / 68); }

// Example: How often will I see common removal? // 5 colors 1 common removal each = 5 common removal spells // As-fan = 5 (10/101) = 0.495 removal spells per pack // This is too low! Need ~1.5 for healthy limited // Solution: Add uncommon/colorless removal

Rationale

Without a skeleton, sets become unbalanced piles of cool cards that don't draft well

---

Name

Draft Archetype Design

Description

Every draft format needs 10 two-color archetypes (one per color pair). Each archetype should have:

1. SIGNPOST UNCOMMON

• Clear, powerful card in both colors
• Tells drafters "this is what WU does"
• Example: UW Flyers gets a 2/3 flyer that draws when you attack with 3+ flyers

2. BUILD-AROUND PAYOFFS

• Rewards for being in the archetype
• Scales with deck commitment
• Usually at uncommon/rare

3. ENABLERS

• Commons that fit multiple archetypes
• The glue cards that make decks work

CLASSIC ARCHETYPE PATTERNS:

• WU: Flyers/Control
• UB: Control/Graveyard
• BR: Aggro/Sacrifice
• RG: Big Creatures/Ramp
• GW: Go-Wide/Tokens
• WB: Life/Death
• UR: Spells Matter
• BG: Graveyard/Value
• RW: Aggro/Equipment
• UG: Ramp/Card Advantage

Example

// Draft archetype definition template const archetypeDesign = { colorPair: 'WU', name: 'Tempo Flyers', strategy: 'Deploy efficient flyers, protect with countermagic, race',

signpostUncommon: { name: 'Sky Captain', manaCost: 'WU', type: 'Creature - Human Soldier', stats: { power: 2, toughness: 3 }, abilities: [ 'Flying', 'Whenever you attack with three or more creatures with flying, draw a card.' ], designNotes: 'Clear signal for WU drafters, rewards archetype commitment' },

keyCommons: [ { name: 'Wind Drake', role: 'Efficient flyer', asFanNeeded: 2.0 }, { name: 'Essence Scatter', role: 'Tempo counter', asFanNeeded: 0.5 }, { name: 'Stormwing Entity', role: 'Payoff for spells + flyers', asFanNeeded: 0.3 } ],

keyUncommons: [ 'Serra Angel variant', 'Draw-go finisher', 'Bounce spell with upside' ],

avoidInArchetype: [ 'High-cost ground creatures', 'Equipment without evasion', 'Cards requiring board stalls' ],

weakTo: ['BG midrange', 'Mass removal', 'Reach creatures'], strongAgainst: ['RG ramp', 'Ground-based aggro'] };

Rationale

Clear archetypes make drafting learnable and give each color pair a distinct identity

---

Name

Constructed Archetype Triangle

Description

Healthy constructed metagames have a rock-paper-scissors dynamic:

AGGRO beats CONTROL

• Faster than control can stabilize
• Punishes slow starts and card draw

CONTROL beats MIDRANGE

• Out-values midrange threats
• Has answers for everything

MIDRANGE beats AGGRO

• Bigger creatures trade favorably
• Stabilizes before death

COMBO breaks this but loses to:

• Fast aggro (dies before combo)
• Discard/counterspells (disruption)

DESIGN LEVERS:

• Aggro speed (how fast can it kill?)
• Control stabilization (when can it survive?)
• Midrange efficiency (how good is each card?)
• Combo consistency (how often does it work?)

Example

// Archetype design parameters const archetypeDesignTargets = { aggro: { goldfish: 4, // Kills on turn 4 with no interaction interactiveKill: 6, // Kills on turn 6 with typical interaction recoveryAbility: 'low', // Dies to sweepers requiredSlots: { oneDrops: 12, twoDrops: 12, burn: 8, landCount: 20 }, designLevers: [ 'One-drop quality determines speed', 'Burn reach determines inevitability', 'Resilience to removal determines consistency' ] },

control: { stabilizeBy: 5, // Must survive to turn 5 winBy: 12, // Wins by turn 12 cardAdvantage: 'high', requiredSlots: { removal: 12, counterspells: 6, cardDraw: 8, winConditions: 4, landCount: 26 }, designLevers: [ 'Sweeper timing determines aggro matchup', 'Card draw efficiency determines midrange matchup', 'Win condition speed determines control mirrors' ] },

midrange: { threatDensity: 'high', curveTop: 5, // Biggest threats at 5 mana flexibility: 'medium', requiredSlots: { removal: 8, threats: 20, cardAdvantage: 8, landCount: 24 }, designLevers: [ 'Threat efficiency determines control matchup', 'Removal quality determines aggro matchup', 'Sideboard options determine adaptability' ] },

combo: { consistentTurn: 5, // Combos by turn 5 with consistency fastestTurn: 3, // Can combo turn 3 with perfect draw resilienceToDisruption: 'varies', requiredSlots: { comboPieces: 8, tutors: 8, protection: 8, cantrips: 12 }, designLevers: [ 'Tutor quality determines consistency', 'Protection determines interactive matchups', 'Combo pieces in graveyard enables resilience' ] } };

// Meta health check function checkMetaBalance(archetypeWinrates) { const deviation = Math.max(...Object.values(archetypeWinrates)) - Math.min(...Object.values(archetypeWinrates));

return { isHealthy: deviation < 5, // No archetype >5% above others diagnosis: deviation > 10 ? 'UNHEALTHY - dominant deck exists' : deviation > 5 ? 'MODERATE - slight imbalance' : 'HEALTHY - rock-paper-scissors intact' }; }

Rationale

Without archetype diversity, metagames become solved and stale

---

Name

Digital-First Design

Description

Digital card games can do things paper cannot. Design for the medium:

DIGITAL ADVANTAGES:

• Random number generation (true randomness)
• Hidden information (hand size without counting)
• Automatic rule enforcement
• History tracking (cards seen, damage dealt)
• Animation and feedback
• Dynamic cost adjustment

DIGITAL MECHANICS:

• Discover: Choose from random subset of cards
• Transform: Card changes permanently
• Dormant: Automatic wake-up triggers
• Start of Game effects: Shuffle deck modifications

DIGITAL PITFALLS:

• Turn length limits (rope timers)
• UI complexity limits
• Memory/storage of game state
• Mobile screen constraints

Example

// Digital-only mechanics const digitalMechanics = { discover: { description: 'Choose one of 3 random cards from pool', paperEquivalent: null, advantages: [ 'Reduces hand variance', 'Skill test: correct choice', 'Excitement of reveal' ], designNotes: [ 'Pool should be relevant (same cost, same type)', 'Average power level of pool matters', 'Three choices is sweet spot (more = paralysis)' ] },

recruitment: { description: 'Start of game: Add card from outside game', paperEquivalent: 'Wish effects (limited)', advantages: [ 'Deck flexibility', 'Reduces deck size need', 'Toolbox strategies' ], designNotes: [ 'Limit to once per game', 'Pool must be pre-defined', 'Dramatically increases decision complexity' ] },

rememberedState: { description: 'Cards track their history', paperEquivalent: 'Dice counters (limited)', advantages: [ 'Growth mechanics', 'Damage tracking', 'Experience accumulation' ], examples: [ '"This minion has attacked 5 times. Upgrade!"', '"Damage dealt this game: 15"', '"Enemies killed by this weapon: 3"' ] } };

// Mobile UI constraints const mobileCardDesign = { maxTextLines: 4, // More doesn't fit on phone maxKeywords: 3, // Visual clutter limit tapTargetSize: 44, // Minimum pixels for touch animationBudget: 2000, // ms per card play handSize: 10, // Max displayable cards boardWidth: 7 // Max minions per side };

Rationale

Design for your medium - paper and digital are different games

---

Name

Print Production Considerations

Description

Physical card games have constraints digital doesn't:

CARD STOCK:

• Blue core vs black core (cheating prevention)
• 300 GSM+ for premium feel
• Finish: Matte (shuffles well) vs Gloss (pops visually)

CUTTING:

• Rounded corners (3mm radius standard)
• Bleed area (3mm minimum)
• Safe zone (keep text 3mm from edge)

COLOR:

• CMYK printing (no true RGB neons)
• Color matching across print runs
• Foil stamping for premium cards (expensive)

PACK CONFIGURATION:

• Collation algorithms (no duplicate rares in box)
• Rare distribution (1:8 packs for rare, 1:8 rares for mythic)
• Print sheet efficiency (11x11 or 10x11 grids)

Example

// Card print specifications const printSpecs = { dimensions: { standard: { width: 63, height: 88, unit: 'mm' }, // Poker size mini: { width: 44, height: 63, unit: 'mm' }, tarot: { width: 70, height: 121, unit: 'mm' } },

bleedAndSafe: { bleedArea: 3, // mm outside trim line safeZone: 3, // mm inside trim line cornerRadius: 3 // mm radius for rounded corners },

cardStock: { thickness: 320, // GSM (grams per square meter) core: 'blue', // Blue core prevents light shining through finish: 'linen', // Options: matte, gloss, linen, silk coating: 'aqueous' // Water-based, environmentally friendly },

colorMode: 'CMYK', // Print uses CMYK, not RGB

// Pack configuration boosterPack: { commons: 10, uncommons: 3, rareSlot: 1, // Rare or mythic land: 1, // Basic land or foil mythicRate: 1/8 // 1 in 8 rare slots is mythic },

// Print sheet efficiency printSheet: { cardsPerSheet: 121, // 11x11 grid sheetsPerBox: 6, boxesPerCase: 4, colorsPerSheet: 1 // Each sheet is single color } };

// Validate card is print-ready function validatePrintReady(cardDesign) { const issues = [];

if (cardDesign.textFromEdge < 3) { issues.push('Text too close to edge - may be cut off'); }

if (cardDesign.usesRGB) { issues.push('Convert colors to CMYK for printing'); }

if (cardDesign.imageResolution < 300) { issues.push('Image resolution too low - need 300 DPI minimum'); }

if (cardDesign.hasNeonColors) { issues.push('Neon colors cannot be printed in CMYK'); }

return { isReady: issues.length === 0, issues }; }

Rationale

Beautiful digital designs can become unreadable physical cards without production awareness

Anti-Patterns

---

Name

Power Creep Spiral

Description

Each set making cards stronger than the last, invalidating older cards. This is the death spiral of card games.

Why

Players feel betrayed when their collection becomes worthless. New player entry cost skyrockets. Game becomes about who bought the latest set. Eventually the power level is absurd and nothing feels impactful.

Bad Example

// Set 1: 2-mana 2/2 is premium // Set 2: 2-mana 2/2 with upside is premium // Set 3: 2-mana 3/3 with upside is premium // Set 4: 2-mana 3/3 with two upsides is premium // Result: Set 1 cards are unplayable garbage

Good Example

// Lateral design instead of power creep // Set 1: 2-mana 2/2 - baseline for aggro // Set 2: 2-mana 1/3 - baseline for control (same power, different role) // Set 3: 2-mana 2/2 with "enters tapped" - powerful ability, drawback // Set 4: 2-mana 2/1 with haste - trades stats for speed // Result: All cards are viable in different contexts

Consequence

Power creep kills games - players leave when their collection becomes worthless

---

Name

Parasitic Mechanics

Description

Mechanics that only work with cards from the same set, not with the broader card pool.

Why

Parasitic mechanics create isolated islands in your card pool. Cards from the parasitic set can't be mixed with other strategies, reducing deckbuilding options and replayability.

Bad Example

// Parasitic: Cards only work with each other // Arcane spells in Kamigawa - only Arcane triggers Splice // Splice onto Arcane - useless without Arcane spells // Spirit tribal - only works with Spirit creature type // Result: Entire mechanic is only playable with itself

Good Example

// Modular: Works with entire card pool // Flashback: Works with any instant/sorcery deck // Kicker: Works on any card, enables flexibility // Landfall: Works with any land in the game // Result: Mechanic enhances existing strategies

Consequence

Parasitic mechanics create dead sets that no one wants to draft or open

---

Name

Mandatory Staples

Description

Cards so powerful they must be in every deck of that color/strategy, eliminating deckbuilding diversity.

Why

If every blue deck must play "Cancel Plus", then blue deck diversity collapses. Players feel forced, not creative. Metagames become about who draws their staples first.

Bad Example

// Must-include staple name: "Obviously Broken Draw Spell" cost: 1U text: "Draw 3 cards." // Result: Every blue deck plays 4 of these. Not playing them is incorrect.

Good Example

// Contextual alternatives // Card A: Draw 2, can't attack this turn (control) // Card B: Draw 1, creature gets +1/+1 (tempo) // Card C: Draw 3, discard 2 (graveyard strategies) // Result: Players choose based on strategy, not obvious power

Consequence

Staples reduce deck diversity to 'play staples + 5 flex slots'

---

Name

Unfun Counter-Play

Description

Mechanics that prevent opponent from playing the game without providing engaging interaction.

Why

Players want to play their cards. "You can't play" mechanics (land destruction, hand destruction, turn skipping) create non-games where one player watches helplessly.

Bad Example

// Non-game mechanics const unfunMechanics = [ 'Destroy all lands', // Opponent can't cast spells 'Opponent discards hand', // No decisions to make 'Skip opponent next turn', // Literal non-game 'Counter spell, draw card', // Free 2-for-1 counterspell 'Opponent can\'t attack' // Shuts down creature decks entirely ];

Good Example

// Interactive alternatives const funCounterplay = [ 'Opponent sacrifices a land', // One land, not all 'Look at hand, choose discard', // Targeted, skill-testing 'Tap opponent creatures', // Temporary, not permanent 'Counter spell OR draw card', // Modal choice, not both 'Attacking creatures get -2/-0' // Answers but doesn't lock out ];

Consequence

Unfun mechanics make players quit - being locked out feels terrible

---

Name

Coin Flip Finishers

Description

Game-ending cards determined entirely by luck, removing skill from the resolution.

Why

If the game ends on a coin flip, why did the preceding 15 turns matter? Randomness in setup/draw is accepted; randomness in resolution feels like stolen games.

Bad Example

// Pure luck finisher name: "Ultimate Coinflip" cost: 10 text: "Flip a coin. If heads, you win. If tails, you lose." // Result: Entire game decided by luck at the end

Good Example

// Randomness with mitigation name: "Risky Gambit" cost: 5 text: "Flip a coin. Heads: Deal 10 damage. Tails: Deal 5 damage." // Result: Random but never game-losing. Skill in when to play it.

// OR: Controlled randomness name: "Calculated Risk" cost: 4 text: "Deal X damage where X is the result of two dice. You may reroll once." // Result: Variance exists but reroll adds player agency

Consequence

Coin flip finishers make players feel like skill doesn't matter

---

Name

Rules Text Novels

Description

Cards with so much text they require a law degree to understand. Often happens when designers patch edge cases inline.

Why

Reading a novel during gameplay breaks flow. Players misunderstand complex cards, leading to feel-bad moments and judge calls. Complexity should be emergent, not in-card.

Bad Example

// Text soup name: "Confusing Contraption" text: | When Confusing Contraption enters the battlefield, if you control another artifact and it's your main phase and you didn't play a land this turn, you may pay 2 life. If you do, target creature gets -2/-2 until end of turn. Otherwise, if you control three or more artifacts, you may instead draw a card. If the creature that got -2/-2 dies this turn and it was a non-token creature, create a 1/1 Thopter artifact creature token with flying.

Good Example

// Clean design name: "Simple Artifact" text: | When this enters, choose one:

• Pay 2 life: Target creature gets -2/-2.
• Draw a card.

// Result: Same decision space, 1/4 the words

Consequence

Wall of text cards don't get played - they're too annoying to parse

---

Name

Linear Mechanics

Description

Mechanics that only have one correct way to build around them, removing deckbuilding creativity.

Why

If mechanic X only works in deck Y, there's no creativity. Players solve the deck once and never explore again. Good mechanics have multiple viable approaches.

Bad Example

// Linear: One correct build mechanic: "Storm" // Count spells this turn, copy effect that many times // Result: Always play fast mana + cheap spells + storm finisher // There's only one Storm deck, ever

Good Example

// Open-ended: Multiple valid builds mechanic: "Flashback" // Cast from graveyard // Builds: Self-mill, Control, Tempo, Combo // Many different decks use flashback differently

Consequence

Linear mechanics create 'solved' formats where exploration dies

Card Game Design - Sharp Edges

Card Free Spells

Id

card-free-spells

Summary

"Free spells" at 0 mana break game balance fundamentally

Severity

critical

Situation

You design a card that costs 0 mana or can be cast for free via an alternate cost (Phyrexian mana, exile from hand, etc.)

Why

Free spells break the fundamental resource system of card games. Mana exists to create meaningful decisions about what to play when. Free spells enable:

• Explosive combo turns (multiple free spells in one turn)
• Resource denial (Force of Will answers anything turn 1)
• Broken synergies (free spells + "spells matter" effects)

Every broken Magic deck in history has featured free or undercosted spells: Affinity, Storm, Phyrexian mana, Delve, etc.

Solution

If you must have a "free" spell: 1. Make the effect minimal (cannot affect board state) 2. Require card disadvantage (exile 2 cards for 1 effect) 3. Limit to once per turn 4. Make them only playable in specific game states (when behind on board)

Better solution: Make the card cost 1 mana. The difference between 0 and 1 is infinite - at 1 mana, the player must sequence their turn around it.

Symptoms

• Combo decks consistently winning turn 2-3
• Every deck running 4x of the free spell
• Players complaining about "non-games"

Detection Pattern

cost:\s0|manaCost:\s["']?0|freeCast:\s*true|alternateCost

Version Range

all

Examples

• Mental Misstep (Phyrexian mana counter) - banned in Legacy/Modern
• Gitaxian Probe (2 life draw + info) - banned everywhere
• Mox Opal/Chrome Mox (free mana) - banned in Modern
• Force of Will (free counter) - only balanced in formats with it

Card Mana Doubling

Id

card-mana-doubling

Summary

Mana doubling effects lead to broken combos

Severity

critical

Situation

You design a card that doubles mana production or reduces all costs by a significant amount.

Why

Mana is meant to be a limiting factor. When you double mana or halve costs:

• X-cost spells become absurd (deal 20 damage for 10 mana = deal 40)
• Card advantage becomes irrelevant (play 2 big things per turn)
• Combos emerge that you didn't anticipate

The problem compounds: double + double = quadruple. Multiple cost reducers in play can make spells free unexpectedly.

Solution

1. Never print "double mana" effects without massive restrictions 2. Cost reducers should cap at 1-2 mana maximum 3. Add "costs can't be reduced below 1" clauses 4. Limit to specific card types (only creature spells, only your turn) 5. Make the doubling effect itself very expensive (8+ mana)

Symptoms

• Players generating 20+ mana before turn 6
• X-cost spells being played for X=15+
• Games ending on the turn the doubler lands

Detection Pattern

double.mana|mana.double|costs?.reduced?.by|mana.add.equal

Version Range

all

Examples

• Nyxbloom Ancient (triple mana) - nearly banned level
• Urza's Saga (2 mana from 1 land) - broken in combo
• Goblin Electromancer (costs 1 less) - enables Storm kills

Card Tutor Consistency

Id

card-tutor-consistency

Summary

Tutors (search effects) break variance and enable combo

Severity

critical

Situation

You design a card that searches your library for any card and puts it in your hand or on top of your library.

Why

Card games rely on variance to prevent repetitive games. Tutors eliminate variance, meaning:

• Games feel same-y (always find the same card)
• Combo decks become consistent (always have the combo)
• Best card in deck is effectively an 8-of

Tutors also create decision paralysis ("what should I search for?") and slow games down with shuffling.

Solution

1. Restrict what can be tutored (only creatures, only costs 2 or less) 2. Make tutors expensive (4+ mana for unrestricted tutoring) 3. Add randomness (look at top 5, choose 1) 4. Reveal the tutored card (opponent knows what's coming) 5. Add deck position restrictions (top of library, not hand) 6. Consider "Discover" mechanics (choose from 3 random options)

Symptoms

• Every game in mirror match plays identically
• Combo decks winning consistently on same turn
• Players shuffling excessively (slow play)

Detection Pattern

search.library|tutor|look.library.put.hand

Version Range

all

Examples

• Demonic Tutor (any card, 2 mana) - restricted in Vintage
• Diabolic Intent (any card, sac cost) - combo staple
• Chord of Calling (creature, instant speed) - enables combo toolbox

Card Alternate Win

Id

card-alternate-win

Summary

Alternate win conditions need very careful balancing

Severity

critical

Situation

You design a card with an alternate win condition ("you win the game" text).

Why

Alternate win conditions bypass normal game interaction. When they're too easy to achieve:

• Games become solitaire (ignore opponent, achieve condition)
• Normal gameplay is invalidated (why fight if they just win?)
• Feels unfair to lose to (no gradual defeat)

When they're too hard, they're never played and waste design space.

Solution

1. Win condition should require 2+ turns of setup after playing the card 2. Opponent must have multiple opportunities to interact 3. Condition should be difficult to achieve accidentally 4. The card should do almost nothing until the win is achieved 5. Consider "you lose the game" clauses for safety valves

Classic formula: "At upkeep, if [condition], you win" (gives opponent a turn)

Symptoms

• Games ending without combat
• Players ignoring board to pursue condition
• Feelsbad moments with no counterplay

Detection Pattern

win.*game|you win the game|wins the game

Version Range

all

Examples

• Felidar Sovereign (win at 40 life) - too easy in lifegain decks
• Laboratory Maniac (win with no cards) - fair because fragile
• Thassa's Oracle (win with no deck) - broken because instant

Card Card Draw Engine

Id

card-card-draw-engine

Summary

Repeatable card draw breaks games over time

Severity

high

Situation

You design a permanent that draws cards repeatedly (tap to draw, triggers to draw, draw on upkeep).

Why

Cards are the fundamental resource of card games. A permanent that draws cards every turn creates inevitable card advantage:

• Turn 3: Draw engine lands
• Turn 6: Opponent is down 3 cards
• Turn 9: Game is unwinnable for opponent

Unlike mana, extra cards persist. Card advantage compounds.

Solution

1. Require activation cost (mana + tap) 2. Add life payment or other resource cost 3. Limit triggers (once per turn maximum) 4. Make the creature fragile (1 toughness, no hexproof) 5. Consider "looting" (draw + discard) instead of pure draw 6. Delayed draw (draw next turn, not immediately)

Symptoms

• Control mirrors devolving to "who finds draw engine first"
• Games lasting 20+ turns with one player always ahead on cards
• Draw engine becoming auto-include in all decks of its color

Detection Pattern

draw a card.whenever|upkeep.draw|tap.*draw a card

Version Range

all

Examples

• Dark Confidant (draw on upkeep, life cost) - powerful but fair
• Sylvan Library (draw 2, pain) - borderline too strong
• Consecrated Sphinx (draw 2 when they draw) - banned in Duel Commander

Card Etb Removal

Id

card-etb-removal

Summary

Enter-the-battlefield removal creates oppressive play patterns

Severity

high

Situation

You design a creature that destroys/exiles a permanent when it enters the battlefield.

Why

ETB removal is inherently 2-for-1 card advantage:

• You get a creature (card 1)
• You destroy their thing (card 2)
• They can't even interact (no "in response, kill your creature")

Blink/bounce effects turn ETB removal into repeatable removal, and the creature sticks around to attack/block.

Solution

1. Use "dies" triggers instead (opponent can respond, removal is risky) 2. Add mana cost to ETB effect ("when enters, you may pay 2...") 3. Make the creature very expensive (6+ mana) 4. Limit target scope (only artifacts, only tokens) 5. Make creature stats terrible (1/1 or 0/1) 6. Consider exile instead of destroy to prevent graveyard abuse

Symptoms

• Creature decks unable to stick threats
• ETB creature becoming the only creature played
• Blink decks dominating metagame

Detection Pattern

enters the battlefield.destroy|etb.exile.target|when.enters.*remove

Version Range

all

Examples

• Ravenous Chupacabra (4 mana, destroy creature) - format-warping in limited
• Skyclave Apparition (3 mana, exile) - multi-format staple
• Solitude (free with pitch) - extremely powerful

Card Scaling Stat Bonus

Id

card-scaling-stat-bonus

Summary

"For each" stat bonuses can create infinitely large creatures

Severity

high

Situation

You design a creature with +1/+1 for each of something (cards in hand, creatures in play, cards in graveyard).

Why

"For each" scales linearly with game state, meaning:

• Early game: Reasonable size (3/3, 4/4)
• Late game: Absurd size (15/15, 20/20)
• Combo potential: Mill yourself, get 30/30

When the condition is easy to inflate (cards in graveyard), the card becomes a one-card win condition.

Solution

1. Cap the bonus ("up to +5/+5" or "maximum power 10") 2. Count things that don't grow infinitely (lands in play ~5-7) 3. Count opponent's resources (they can deplete them) 4. Add a divider (half, rounded down) 5. Make base stats 0/0 so it dies without the condition

Symptoms

• Self-mill decks creating 20/20 on turn 4
• Creature becoming "must-answer or lose"
• Limited games decided by who draws the scaling creature

Detection Pattern

for each|gets \+1/\+1.*each|\+X/\+X where X is

Version Range

all

Examples

• Tarmogoyf (count types in grave) - multi-format staple because capped
• Consuming Aberration (cards in grave) - can hit 40/40
• Serra Avatar (equal to life) - one-shot kills

Card Land Ramp

Id

card-land-ramp

Summary

Land-based ramp is difficult to interact with

Severity

high

Situation

You design cards that put extra lands into play, especially at low mana costs.

Why

Land-based mana acceleration is permanent and hard to disrupt:

• Land destruction is unfun and rarely printed
• Lands persist through board wipes
• 1-mana ramp + 2-land = 4 mana on turn 2

Ramp also creates "nothing happening" turns where the ramping player doesn't affect the board, only their future mana.

Solution

1. Ramp spells should cost 2+ mana (so turn 1 ramp isn't possible) 2. Consider "enters tapped" on ramped lands 3. Create creature-based ramp (vulnerable to removal) 4. Limit to basic lands (prevents color fixing abuse) 5. Add meaningful cost (life, card disadvantage, tempo loss) 6. Cap total lands per turn effects

Symptoms

• Green decks playing 6-drops on turn 3
• Aggro decks unable to race the ramp
• Ramp mirrors becoming "who draws more ramp"

Detection Pattern

put.land.onto the battlefield|land.play.additional|search.land.put.*play

Version Range

all

Examples

• Rampant Growth (2 mana, 1 land) - baseline acceptable
• Explore (2 mana, extra land play) - powerful when lands available
• Arboreal Grazer (1 mana creature, extra land) - too fast

Card Graveyard As Hand

Id

card-graveyard-as-hand

Summary

Graveyard recursion turns discard pile into second hand

Severity

high

Situation

You design cards that can be cast from the graveyard or return from graveyard to hand easily.

Why

The graveyard is meant to be a resource sink, not a resource. When cards come back:

• Card disadvantage effects (discard, mill) backfire
• Games go long as both players recycle answers
• Combo potential with self-mill

Graveyard-focused blocks often require banning key pieces.

Solution

1. Exile after use ("cast from graveyard, then exile") 2. Require significant mana investment to recur 3. Single-use recursion only (not loops) 4. Make graveyard hate widely available and maindeckable 5. Limit recursion to specific card types (creatures only)

Symptoms

• Mill strategies being unplayable (just fuels opponent)
• Games going 40+ turns with neither player running out of cards
• Graveyard hate being mandatory sideboard

Detection Pattern

from your graveyard|cast.from.graveyard|return.from.graveyard

Version Range

all

Examples

• Flashback mechanic - balanced because exiles after use
• Unearth - balanced because exiles at end of turn
• Hogaak (cast from GY repeatedly) - banned everywhere

Card Hexproof Pushed

Id

card-hexproof-pushed

Summary

Pushed creatures with hexproof create uninteractive games

Severity

medium

Situation

You design a creature with hexproof and strong stats or abilities.

Why

Hexproof creatures can only be answered by:

• Board wipes (expensive, not always available)
• Sacrifice effects (narrow, not in all colors)
• -X/-X effects (rare)

When the hexproof creature is efficient, every game becomes about racing it, and control decks have no tools.

Solution

1. Hexproof creatures should have bad stats (1/1 or 2/2 max) 2. Consider "ward" instead (can target with extra cost) 3. Hexproof should be conditional (on your turn only, until damaged) 4. Large hexproof creatures should cost 6+ mana 5. Never put hexproof on creatures with built-in card advantage

Symptoms

• Aura/equipment decks becoming dominant
• Removal-heavy decks becoming unplayable
• Games decided by "did they draw the hexproof creature"

Detection Pattern

hexproof|can't be the target.opponent.controls

Version Range

all

Examples

• Slippery Bogle (1/1 hexproof, 1 mana) - enables degenerate Bogles deck
• Carnage Tyrant (hexproof + can't be countered) - format-warping
• True-Name Nemesis (protection from a player) - Legacy nightmare

Card Flash Creatures

Id

card-flash-creatures

Summary

Flash creatures blur the line between spells and creatures

Severity

medium

Situation

You design a creature with flash (can be cast any time you could cast an instant).

Why

Flash creatures are tactically superior to sorcery-speed creatures:

• Can ambush attackers
• Opponent must play around them even when not in hand
• Hold up interaction OR play threat (no commitment)

When flash creatures have strong ETB effects, they become "spells with bodies attached" that are always better than equivalent sorceries.

Solution

1. Flash creatures should have lower stats than sorcery-speed equivalents 2. ETB effects on flash creatures should be weaker 3. Flash can be a drawback (costs 1 more mana than sorcery version) 4. Consider "flash until end of turn" type restrictions 5. Balance flash by making creature fragile (1 toughness)

Symptoms

• Control decks playing only flash creatures
• Sorcery-speed creatures becoming unplayable
• Games becoming "draw-go" standoffs

Detection Pattern

flash|cast.*any time|as though it had flash

Version Range

all

Examples

• Snapcaster Mage (flash, flashback) - format staple for years
• Restoration Angel (flash, blink) - created oppressive play patterns
• Vendilion Clique (flash, hand disruption) - multi-format staple

Card Color Pie Breaks

Id

card-color-pie-breaks

Summary

Color pie violations undermine faction identity

Severity

medium

Situation

You design a card that gives a color access to abilities it shouldn't have (e.g., red card draw that's better than blue, green counterspells).

Why

The color pie exists so that:

• Each color has strengths and weaknesses
• Multicolor has meaning (access to multiple pies)
• Deckbuilding has consequences (mono-color has gaps)

When colors can do everything, color choice becomes meaningless and multicolor loses its appeal.

Solution

1. Maintain strict color pie discipline 2. If bending, require significant cost or condition 3. Color-shifted effects should be much weaker than original 4. Document color pie breaks and limit them to 1-2 per set 5. Consider artifact/colorless for effects that don't fit colors

Symptoms

• Mono-color decks having no weaknesses
• Multicolor decks becoming suboptimal
• Colors feeling "samey" without distinct identity

Detection Pattern

Version Range

all

Examples

• Red Elemental Blast (red counterspell) - acceptable because narrow
• Beast Within (green destroy any permanent) - controversial break
• Oko (green creature transformation) - not in green's pie, was broken

Card Enters Tapped Matters

Id

card-enters-tapped-matters

Summary

"Enters tapped" lands create feel-bad tempo loss

Severity

medium

Situation

You design lands that enter tapped to balance their effects.

Why

Enters-tapped lands are necessary for balance but create problems:

• Early game: Devastating tempo loss (behind by a full mana)
• Late game: Nearly irrelevant (already have enough mana)
• Land-heavy hands: Multiple tapped lands = disaster

Too many tapped lands make decks clunky; too few makes mana too free.

Solution

1. Use "check lands" (enters untapped if condition met) 2. Consider "pay life" alternatives (Shock lands) 3. Limit tapped lands to 4-8 per deck 4. Dual lands should have a real cost (life, bounce, tapped) 5. Provide untapped mono-color options at lower rarity

Symptoms

• Aggro decks unplayable due to tapped lands
• Control mirrors decided by land sequencing
• "Lucky land" draws deciding games

Detection Pattern

enters the battlefield tapped|comes into play tapped|etb tapped

Version Range

all

Examples

• Shock lands (pay 2 life or tapped) - excellent design
• Check lands (condition = untapped) - fair trade-off
• Tap lands with no upside - feel terrible in constructed

Card Daynight Tracking

Id

card-daynight-tracking

Summary

Day/Night and other global tracking mechanics add complexity

Severity

low

Situation

You design a mechanic that tracks global game state (day/night, monarch, initiative, etc.).

Why

Global tracking mechanics:

• Add memory burden for both players
• Require tokens/indicators to track
• Can be confusing for new players
• Interact with all other cards in game

These mechanics are fine but need restraint in frequency.

Solution

1. Limit to 1-2 global mechanics per set 2. Provide clear visual indicators (tokens, cards) 3. Make state changes obvious and triggered 4. Ensure the mechanic is worth the tracking cost 5. Digital games should automate tracking

Symptoms

• Players forgetting current state
• Judge calls about state tracking
• New players overwhelmed by tracking requirements

Detection Pattern

day|night|monarch|initiative|dungeon

Version Range

all

Examples

• Day/Night (Innistrad) - two states to track
• Monarch (Conspiracy) - creates fun subgame
• Dungeon (AFR) - most complex global tracking

Card Reminder Text Creep

Id

card-reminder-text-creep

Summary

Reminder text takes valuable card real estate

Severity

low

Situation

You design a card with a new keyword and want to add reminder text.

Why

Reminder text helps new players but costs:

• Card real estate (less room for abilities)
• Visual clutter
• Reduces perceived power level (looks like more text)

Experienced players ignore reminder text, new players need it.

Solution

1. Omit reminder text on rares/mythics (experienced players know keywords) 2. Use reminder text at common/uncommon 3. Consider reminder text on first instance only in a set 4. Digital games can have hover/tap for reminder text 5. Keep reminder text concise (under 2 lines)

Symptoms

• Cards feeling "crowded" with text
• Players misreading abilities due to text density
• Cool abilities being cut for text space

Detection Pattern

Version Range

all

Examples

• Flying (reminder text at common only) - good practice
• Deathtouch (minimal reminder) - one sentence
• Banding (complex reminder) - infamously confusing

Card Templating Inconsistency

Id

card-templating-inconsistency

Summary

Inconsistent card templating creates rules confusion

Severity

low

Situation

You write card text that differs from established templating conventions.

Why

Card templating follows specific conventions:

• "Target" means it can be countered by shroud/hexproof
• "Choose" means it bypasses hexproof
• "Up to" means you can choose zero
• Order of words matters for timing

Inconsistent templating creates rules edge cases and player confusion.

Solution

1. Follow established templating guides religiously 2. When in doubt, use existing cards as templates 3. Have rules experts review all card text 4. Maintain internal templating document 5. Use consistent action words (destroy, exile, sacrifice)

Symptoms

• Players arguing about card interactions
• Rules questions requiring official rulings
• Cards working differently than players expect

Detection Pattern

Version Range

all

Examples

• "Target creature gets +2/+2" - standard, works as expected
• "Choose a creature. It gets +2/+2" - bypasses hexproof
• "Creature gets +2/+2" - affects all creatures? Unclear!

Card Game Design - Validations

Zero Mana Cost Detection

Id

card-zero-cost-validation

Severity

critical

Type

regex

Pattern

• manaCost["\':\s]*0
• cost["\':\s]*0
• "mana":\s*0
• mana_cost:\s*0
• castingCost:\s*0

Message

Zero mana cost detected. Free spells are historically the most broken cards in TCG design. Consider adding a minimum cost of 1, or adding significant alternate costs (exile cards, pay life, sacrifice).

Fix Action

Change cost to 1 or add meaningful alternate costs:

• Pay 2 life
• Exile a card from hand
• Sacrifice a permanent
• Discard a card

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js
• *.xml

Free Cast Mechanic Detection

Id

card-free-cast-detection

Severity

critical

Type

regex

Pattern

• freeCast["\':\s]*true
• canCastForFree
• alternateCost["\':\s]*0
• castWithoutPaying
• without paying.*mana cost
• play.*for free

Message

Free casting mechanic detected. Cards that can be cast without paying their mana cost break resource systems and enable degenerate combos. Every banned card in Magic's history involved free spells.

Fix Action

Add meaningful restrictions to free casting:

• Once per turn only
• Only during specific game states (opponent attacking)
• Require significant resource payment (exile 2 cards)
• Limit to low-impact effects

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js

Unrestricted Tutor Detection

Id

card-unrestricted-tutor

Severity

critical

Type

regex

Pattern

• searchLibrary.any.card
• tutor.*any
• search.deck.choose.*any
• find any card
• search your library for a card

Message

Unrestricted tutor effect detected. Tutors that find any card eliminate variance and enable consistent combo kills. Consider adding restrictions on what can be searched for.

Fix Action

Add restrictions to the tutor:

• Limit by card type (creature, instant, etc.)
• Limit by mana cost (costs 2 or less)
• Limit by other criteria (color, subtype)
• Consider "reveal" clause for opponent knowledge

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js

Instant Win Condition Detection

Id

card-instant-win

Severity

critical

Type

regex

Pattern

• you win the game
• wins the game
• winGame\(\)
• gameWin\s*[:=]
• alternateWinCondition

Message

Alternate win condition detected. "You win the game" effects need extremely careful balancing. The condition should require multiple turns to achieve and provide opponent with interaction opportunities.

Fix Action

Ensure the win condition: 1. Cannot be achieved instantly (requires upkeep trigger) 2. Has a multi-step setup 3. Can be disrupted by common game actions 4. Consider adding a "you lose the game" safety valve

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js

Mana Doubling Effect Detection

Id

card-mana-doubling

Severity

error

Type

regex

Pattern

• double.*mana
• mana.*double
• add.twice.mana
• manaMultiplier
• mana.\\s*2
• multiply.*mana

Message

Mana doubling effect detected. Mana doublers break the resource curve and enable degenerate combos with X-cost spells. Consider using fixed mana addition instead.

Fix Action

Replace doubling with fixed addition:

• "Add 2 mana" instead of "double mana"
• Cap the bonus (add up to 3 extra mana)
• Add "once per turn" restriction
• Make the effect very expensive (7+ mana)

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js

Repeatable Card Draw Detection

Id

card-repeatable-draw

Severity

error

Type

regex

Pattern

• tap.*draw a card
• upkeep.*draw
• whenever.*draw a card
• draw.*each turn
• repeatableDraw

Message

Repeatable card draw effect detected. Engines that draw cards every turn create inevitable card advantage that's difficult to overcome. Ensure there's a meaningful cost or limitation.

Fix Action

Add costs and restrictions:

• Mana cost for activation (2+ mana)
• Life payment
• "Once per turn" limitation
• Condition that opponent can disrupt
• Make the permanent fragile (1 toughness)

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js

Uncapped Stat Scaling Detection

Id

card-uncapped-scaling

Severity

error

Type

regex

Pattern

• \+1/\+1 for each
• power.equal to.number
• toughness.equal to.count
• gets.*\+X/\+X where X
• forEachBonus
• countBasedStats

Message

Uncapped stat scaling detected. "For each" effects can create arbitrarily large creatures that trivialize combat. Consider adding a maximum cap.

Fix Action

Add scaling limits:

• "up to +5/+5" cap
• Use diminishing returns (each beyond first is +1/+0)
• Count things that don't grow infinitely (lands, ~5-7 max)
• Count opponent's resources (they can deplete them)

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js

Pushed Hexproof Creature Detection

Id

card-hexproof-pushed

Severity

error

Type

regex

Pattern

• hexproof.power.[3-9]
• power.[3-9].hexproof
• hexproof.stats.efficient
• "hexproof"."power":\s[3-9]

Message

Powerful hexproof creature detected. Hexproof creatures with good stats create uninteractive games where opponents have no answers. Consider using ward instead or reducing stats.

Fix Action

Balance hexproof creatures:

• Reduce stats (2/2 maximum for hexproof)
• Use ward instead (can target with extra cost)
• Make hexproof conditional (until end of turn, when blocking)
• Increase mana cost significantly (6+ for any meaningful stats)

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js

Graveyard Loop Detection

Id

card-graveyard-loop

Severity

error

Type

regex

Pattern

• return.graveyard.hand.*return
• graveyard.battlefield.graveyard
• recursion.*infinite
• graveyardLoop
• when.dies.return

Message

Potential graveyard loop detected. Cards that can return themselves from the graveyard repeatedly create infinite value engines. Ensure there's a terminus (exile after use).

Fix Action

Add loop prevention:

• "Exile instead of graveyard" clause
• "Once per game" restriction
• Significant mana cost for recursion
• Exile after being cast from graveyard (like Flashback)

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js

Early Land Acceleration Detection

Id

card-land-acceleration

Severity

warning

Type

regex

Pattern

• manaCost["\':\s]1.land.*battlefield
• cost.1.addLand
• one mana.*extra land
• turn one.*land

Message

1-mana land acceleration detected. Early ramp is very powerful and can lead to unfair mana advantages. Consider making the effect cost 2+ mana or add significant drawbacks.

Fix Action

Balance early ramp:

• Increase cost to 2 mana minimum
• Ramped land enters tapped
• Limit to basic lands only
• Add meaningful drawback (life loss, tapped creature)

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js

ETB Removal Detection

Id

card-etb-removal

Severity

warning

Type

regex

Pattern

• enters.destroy.target
• etb.exile.permanent
• when.enters.remove
• entersBattlefield.*destroy

Message

Enter-the-battlefield removal detected. ETB removal provides inherent 2-for-1 card advantage. Ensure the creature has low stats or high mana cost to compensate.

Fix Action

Balance ETB removal:

• Creature should have poor stats (1/1 or 2/2 at most)
• Mana cost should be high (4+ mana)
• Consider making effect optional with mana cost
• Limit target scope (only artifacts, only creatures cost 3+)

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js

Flash with ETB Effect Detection

Id

card-flash-etb

Severity

warning

Type

regex

Pattern

• flash.*enters the battlefield
• flash.*etb
• instant speed.when.enters
• "flash".*"entersTrigger"

Message

Flash creature with ETB effect detected. This combination is inherently powerful, providing both tactical flexibility and guaranteed value. Reduce stats or increase cost.

Fix Action

Balance flash + ETB:

• Add 1-2 mana to cost compared to sorcery-speed version
• Reduce power/toughness
• Make ETB effect weaker than instant spell equivalent
• Consider conditional flash (only on opponent's turn)

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js

Complex Common Card Detection

Id

card-complexity-common

Severity

warning

Type

regex

Pattern

• rarity.common.triggered.*triggered
• rarity.common.whenever.*whenever
• common.abilities.length.*[4-9]

Message

Common card with multiple triggered abilities detected. Following New World Order, commons should be simple. Move complex cards to uncommon or higher rarity.

Fix Action

Simplify commons:

• Limit to 1 triggered ability maximum
• Keep rules text under 3 lines
• No "for each" or counting mechanics
• Move to uncommon if complexity is needed

Applies To

• *.json
• *.yaml
• *.yml
• *.ts
• *.js

Targeting Language Inconsistency

Id

card-targeting-inconsistency

Severity

warning

Type

regex

Pattern

• choose.creature.destroy
• select.*target
• pick.*target

Message

Inconsistent targeting language detected. In card games, "target" has specific rules meaning (can be countered by hexproof/shroud). Use "target" for effects that can be countered, "choose" for those that can't.

Fix Action

Use consistent terminology:

• "Target" = affected by hexproof/shroud
• "Choose" = ignores hexproof/shroud (no targeting)
• Never use "select" or "pick" for targeting

Applies To

• *.json
• *.yaml
• *.yml

Missing Card Rarity

Id

card-missing-rarity

Severity

warning

Type

regex

Pattern

• "name":\s"[^"]+"\s,\s*(?!"rarity")
• name:.\n(?!\srarity:)

Message

Card definition may be missing rarity. Every card needs a rarity for proper set distribution and draft balance.

Fix Action

Add rarity field:

• "common" for simple, frequently appearing cards
• "uncommon" for moderate complexity, synergy pieces
• "rare" for powerful, complex cards
• "mythic" for splashy, game-changing cards

Applies To

• *.json
• *.yaml
• *.yml

Stats Without Creature Type

Id

card-stats-without-type

Severity

warning

Type

regex

Pattern

• power.[0-9].(?!creature|type)
• toughness.[0-9].(?!creature|type)
• "attack":\s[0-9]+\s(?!.*"type")

Message

Power/toughness defined without creature type. Non-creature cards should not have combat stats unless they become creatures.

Fix Action

Either:

• Add creature type to the card
• Remove power/toughness stats
• Add "becomes a creature" clause if needed

Applies To

• *.json
• *.yaml
• *.yml

Random Effect Without Seed

Id

card-rng-without-seed

Severity

warning

Type

regex

Pattern

• Math\.random\(\)
• random\(\)(?!\s*\(seed)
• flip.coin.Math\.random

Message

Random effect using unseeded random. For reproducibility in replays, testing, and anti-cheat, use seeded random number generators.

Fix Action

Use seeded RNG:

• Pass game state seed to random function
• Store random results in game log
• Enable deterministic replay of games

Applies To

• *.ts
• *.js

Direct Card State Mutation

Id

card-state-mutation

Severity

warning

Type

regex

Pattern

• card\.[a-z]+\s*=
• \.power\s*\+=
• \.toughness\s*=

Message

Direct card state mutation detected. Card games should use immutable state updates for proper undo/redo, networking, and debugging.

Fix Action

Use immutable patterns:

• Create new card object with updated values
• Use game state management (Redux, Zustand)
• Apply mutations through action dispatchers

Applies To

• *.ts
• *.js

Async Effect Without Queue

Id

card-async-effect-resolution

Severity

warning

Type

regex

Pattern

• async.*resolveEffect
• await.*castCard
• promise.*trigger

Message

Async card effect without proper queue management detected. Card games need deterministic effect ordering. Use an effect stack/queue.

Fix Action

Implement effect queue:

• Add effects to queue in LIFO order
• Resolve one at a time
• Handle interrupts/responses properly
• Never use raw async/await for game logic

Applies To

• *.ts
• *.js