---
id: wiki-2026-0508-game-system-design-prompt
title: Game System Design Prompt
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [game system design prompt, LLM game design, AI game designer]
duplicate_of: none
source_trust_level: B
confidence_score: 0.85
verification_status: applied
tags: [game-design, prompt-engineering, llm, system-design, ai-design]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: Game Design / Prompt
  applicable_to: [LLM, Game Design, Prototyping]
---

# Game System Design Prompt

## 매 한 줄
> **"매 LLM 의 의 의 game system 의 design 의 의 prompt 패턴"**. 매 mechanic + balance + economy + progression. 매 modern: 매 Claude / GPT 의 의 game prototype 의 ideate. 매 caveat: 매 LLM output 의 의 의 playtesting 의 still 필요.

## 매 핵심

### 매 game system pillar
- **Mechanic**: 매 player action.
- **Dynamic**: 매 emergent.
- **Aesthetic**: 매 player feel (MDA framework).
- **Loop**: 매 core gameplay loop.
- **Progression**: 매 short / medium / long term.
- **Economy**: 매 resource / cost / sink.
- **Balance**.

### 매 LLM 응용
1. **Mechanic ideation**.
2. **Balance simulation** (LLM as analyzer).
3. **Quest / encounter design**.
4. **Item / power name + flavor**.
5. **Dialogue**.
6. **Tutorial scaffold**.

## 💻 패턴

### Master prompt template
```python
SYSTEM_GAME_DESIGNER = """You are a senior game systems designer. Apply MDA framework.

For each system: specify mechanic + dynamic + aesthetic.
Consider: player agency, fairness, fun, retention, monetization (if applicable).
Output structured JSON or markdown — no prose-only responses."""
```

### Mechanic ideation
```python
def ideate_mechanic(theme, genre, llm):
    prompt = f"""Design 5 core mechanics for a {genre} game with theme '{theme}'.

For each:
- Name
- 1-line description
- Player verb (what they DO)
- Tension (what makes it interesting)
- Failure mode (what could feel bad)

Output as JSON list."""
    return json.loads(llm.generate(prompt))
```

### Balance simulation
```python
def simulate_balance(units, scenarios, llm):
    prompt = f"""Analyze unit balance.

Units:
{json.dumps(units, indent=2)}

Scenarios: {scenarios}

For each unit pair, predict:
- Win probability
- Counter relationship
- Skill ceiling

Identify any:
- Dominant strategy
- Useless unit
- Coin-flip matchup

Output JSON."""
    return json.loads(llm.generate(prompt))
```

### Economy design
```python
def design_economy(currencies, sources, sinks, llm):
    prompt = f"""Design economy for game.

Currencies: {currencies}
Sources (where it comes from): {sources}
Sinks (where it goes): {sinks}

Output:
- Inflation risk
- Whale-friendly check
- F2P-friendly check
- Recommended ratios
- Edge cases (offline farm, exploit)"""
    return llm.generate(prompt)
```

### Progression curve
```python
def design_progression(total_play_hours, milestones, llm):
    prompt = f"""Design XP / level curve.

Target play hours: {total_play_hours}
Key milestones: {milestones}

Output:
- XP per level (formula)
- Time to each milestone
- Rewards per level
- Plateau-avoidance design
- Late-game retention hooks"""
    return llm.generate(prompt)
```

### Encounter generator
```python
def encounter(player_level, party_size, biome, llm):
    prompt = f"""Generate an encounter.

Party: {party_size} players, level {player_level}
Biome: {biome}
Difficulty target: medium-hard

Output JSON:
- enemies: [{{type, count, position}}]
- terrain hazards
- objective (kill / survive / escort)
- reward (XP, loot pool)
- 3 tactical decision points"""
    return json.loads(llm.generate(prompt))
```

### Item / power flavor
```python
def name_item(stats, theme, llm):
    prompt = f"""Generate evocative names + flavor for items with these stats.

Stats: {stats}
Theme: {theme}

Output 5 options with:
- Name
- 1-line flavor text
- Source / origin lore"""
    return llm.generate(prompt)
```

### Tutorial scaffolding
```python
def design_tutorial(mechanics_to_teach, llm):
    prompt = f"""Design a tutorial that teaches these mechanics WITHOUT text walls.

Mechanics: {mechanics_to_teach}

For each:
- Trigger (when to introduce)
- Teaching method (do > read)
- Verification (how to know learned)
- Failure recovery"""
    return llm.generate(prompt)
```

### Loop analysis
```python
def analyze_core_loop(actions, llm):
    prompt = f"""Analyze core loop.

Player actions in order: {actions}

Output:
- Loop duration (seconds)
- Reward density
- Decision per loop
- Cognitive load
- Comparison to similar games' loops
- Improvement suggestions"""
    return llm.generate(prompt)
```

### Difficulty curve
```python
def difficulty_curve(stages, llm):
    prompt = f"""Design difficulty curve.

Stages: {stages}

Output for each:
- Challenge type (skill / knowledge / time)
- Player power vs enemy power ratio
- Optional / required
- Frustration mitigation"""
    return llm.generate(prompt)
```

### Monetization (F2P safe)
```python
def design_monetization(game_type, llm):
    prompt = f"""Design ETHICAL monetization for {game_type}.

NO:
- Pay-to-win
- Loot box for kids
- Predatory FOMO
- Hidden costs

YES:
- Cosmetic
- Battle pass with reasonable progress
- Convenience (storage, time-skip optional)
- Expansions

Output strategy + price points."""
    return llm.generate(prompt)
```

### Risk audit
```python
def design_risk_audit(design, llm):
    prompt = f"""Audit this game design for risks.

Design:
{design}

Identify:
- Toxic player behavior potential
- Boring strategies (camping, grinding)
- Bug exploits
- Accessibility gaps
- Monetization concerns
- Cultural sensitivities"""
    return llm.generate(prompt)
```

### Playtest survey gen
```python
def playtest_survey(features, llm):
    prompt = f"""Generate playtest survey covering these features.

Features: {features}

Mix:
- Likert scales
- Open-ended ("what frustrated you?")
- Behavioral ("what did you avoid?")
- Comparison ("vs game X")"""
    return llm.generate(prompt)
```

### Iteration log
```python
def design_iteration(prev_design, playtest_data, llm):
    prompt = f"""Update design based on playtest.

Previous design: {prev_design}
Playtest data: {playtest_data}

Output:
- Top 3 changes
- Hypothesis behind each
- Metric to validate
- Risk of regression"""
    return llm.generate(prompt)
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Greenfield | Mechanic ideation prompt |
| Balance issue | Simulate balance |
| Economy | Design economy + audit |
| Engagement low | Loop + progression analyze |
| Player frustration | Difficulty curve + tutorial |
| Monetization | Ethical pattern |

**기본값**: 매 LLM 의 ideation tool — 매 final = playtest. 매 risk audit + ethics + accessibility checklist 매 항상.

## 🔗 Graph
- 부모: [[Game-Design]] · [[Prompt-Engineering]]
- 변형: [[MDA-Framework]] · [[Drama Management Systems]]
- 응용: [[Dynamic Difficulty Adjustment (DDA)]] · [[Computational-Creativity]]
- Adjacent: [[Foundation-Models]] · [[Dynamic Few-Shot]] · [[Be-Detailed]]

## 🤖 LLM 활용
**언제**: 매 prototype. 매 brainstorm. 매 review.
**언제 X**: 매 final balance (playtest needed). 매 IP-sensitive.

## ❌ 안티패턴
- **LLM output 의 ship**: 매 playtest 없이.
- **No risk audit**: 매 toxic / exploit miss.
- **Ignore F2P ethics**: 매 predatory.
- **Single iteration**: 매 design = 매 iterative.

## 🧪 검증 / 중복
- Verified (MDA framework Hunicke, game design literature, LLM capabilities).
- 신뢰도 B.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — prompt patterns + 매 mechanic / balance / economy / loop / monetization code |
