Large Language Models in Game Development: Implications for Gameplay, Playability, and Player Experience

1. Problem Statement

While existing research on Large Language Models (LLMs) in games focuses heavily on technical applications (e.g., procedural content generation, dialogue systems) and their potential for variability and personalization, there is a significant gap in understanding how LLM integration fundamentally alters established game engineering constructs. Specifically, current literature lacks empirical insight into how embedding generative AI as a core architectural component impacts:

• Gameplay: The set of activities and rules available to the player.
• Playability: The usability, stability, and coherence of the game system.
• Player Experience (PX): The engagement, enjoyment, and perception of fairness during interaction.

The authors argue that treating LLMs merely as content generators overlooks the structural challenges they introduce when coupled with deterministic game logic, such as difficulty calibration, output correctness, and system coherence.

2. Methodology

The study employs a collaborative autoethnographic approach, a qualitative method where the researchers (student developers) analyze their own lived experiences to understand broader socio-technical practices.

• Context: Two distinct game projects were developed over 3–6 months in undergraduate software engineering settings:
  1. Wizdom Run: A Unity-based RPG where players import study notes. The LLM generates multiple-choice questions (MCQs) based on these notes, which drive combat mechanics (mana replenishment, boss battles).
  2. Sena: A sustainability-focused educational game where the LLM facilitates dialogue, scenario interpretation, and feedback generation for decision-making scenarios.
• Participants: Seven student developers (five of whom are co-authors) who integrated LLMs (Google Gemini, OpenAI) as architectural components rather than auxiliary tools.
• Data Collection: Five reflective narratives (approx. 2 pages each) written during and after development, focusing on decisions, challenges, and perceived effects on gameplay/PX. These were triangulated with design documents and code repositories.
• Analysis: Thematic analysis and content analysis were used, guided by the constructs of Gameplay, Playability, and Player Experience.

3. Key Contributions

The paper contributes to both game studies and software engineering by:

• Reframing LLM Integration: Moving beyond "content generation" to view LLMs as architectural components that directly enforce rules and progression.
• Identifying Structural Tensions: Highlighting the conflict between the probabilistic nature of LLMs and the deterministic requirements of game logic (e.g., rule enforcement, difficulty curves).
• Defining New Engineering Requirements: Proposing that successful LLM integration requires specific engineering practices (prompt engineering, schema enforcement, validation pipelines) that are distinct from traditional game development.

4. Key Results

The findings are categorized by the three guiding constructs:

A. Impact on Gameplay Structures

• Operational Coupling: LLM outputs became core operational components. In Wizdom Run, generated questions directly determined resource management (mana) and progression.
• Structured Variability: LLMs introduced dynamic variability based on user input (e.g., specific study notes), creating unique playthroughs. However, this variability was bounded by system constraints; reusing the same input often yielded similar outputs, limiting true diversity.
• Hybrid Logic: The games operated on a hybrid model where probabilistic content generation was layered over stable, deterministic mechanical frameworks.

B. Impact on Playability

• The Necessity of Containment: To maintain playability, developers had to strictly constrain LLM outputs using structured schemas (e.g., JSON) and validation logic. Without this, backend systems failed to parse data, breaking the game loop.
• Difficulty Calibration Challenges: Automated generation struggled with consistent difficulty scaling. "Hard" questions were sometimes generated as "easy," disrupting the intended progression curve.
• Reliability and Fairness: Playability was heavily dependent on output correctness. Instances of mathematically incorrect answers or repetitive answer patterns (e.g., the correct option always appearing in the same slot) undermined player trust and perceived fairness.

C. Impact on Player Experience

• Enhanced Personalization: Players appreciated the ability to use their own materials, creating a sense of endless topic variety and tailored progression.
• Contextual Responsiveness: Dynamic dialogue allowed for clarifying questions, increasing engagement.
• The Predictability Paradox: While variability was desired, players required a baseline of predictability to feel the game was fair. When the LLM failed to stay "on-topic" or generated nonsensical responses, immersion was broken, and trust in the system eroded.

5. Significance and Implications

The study concludes that integrating LLMs into games is not merely an additive process but a reconfiguration of the game architecture.

• For Research: Future work must move beyond cataloging applications to investigating how specific architectural strategies (e.g., prompt engineering, schema validation) influence the stability of playability and the coherence of player experience.
• For Practice:
  • Architectural Shift: Developers must treat correctness, formatting determinism, and difficulty alignment as critical gameplay properties, not just implementation details.
  • New QA Requirements: Traditional testing is insufficient. New validation pipelines are required to ensure generative outputs adhere to game rules and difficulty constraints.
  • Balancing Act: Successful integration requires deliberate strategies to balance the flexibility of generative AI with the structural control needed for a playable, fair, and coherent game experience.

In summary, the paper posits that while LLMs offer powerful tools for personalization, their integration demands rigorous software engineering practices to prevent the degradation of playability and player trust.