, 'uncommon', 'rare', 'legendary']), stackLimit: z.number().int().min(1).max(9999), description: z.string().max(240) });

export function validateItemPayload(raw: unknown): z.infer<typeof EconomyItemSchema> { const parsed = EconomyItemSchema.safeParse(raw); if (!parsed.success) { throw new Error(Item validation failed: ${parsed.error.issues[0].message}); } return parsed.data; }

**Rationale:** Zod provides runtime type safety and clear error boundaries. By enforcing positive integers, string length limits, and enum constraints, you prevent AI from generating broken balance values or overflowing UI fields. This pattern scales to quests, NPC dialogue, and item lore.

### Step 2: Integrate Dev-Time Coding & Asset Agents
Coding agents (Claude Code, Cursor, Copilot) should be wired into CI/CD for boilerplate, tooling scripts, and editor extensions. Asset generators (PixelLab, Cascadeur, Suno) should output to a staging directory where humans apply final polish before committing to the repository.

```typescript
// asset-pipeline.ts
import { execSync } from 'child_process';
import fs from 'fs/promises';
import path from 'path';

const STAGING_DIR = './assets/staging';
const COMMIT_DIR = './assets/committed';

export async function stageGeneratedAsset(filename: string, buffer: Buffer): Promise<string> {
  const stagingPath = path.join(STAGING_DIR, filename);
  await fs.writeFile(stagingPath, buffer);
  
  // Trigger automated linting & format check
  execSync(`npx sharp ${stagingPath} --optimize --output ${stagingPath}`, { stdio: 'inherit' });
  
  return stagingPath;
}

export async function promoteToCommit(filename: string): Promise<void> {
  const src = path.join(STAGING_DIR, filename);
  const dest = path.join(COMMIT_DIR, filename);
  
  if (!fs.stat(src).catch(() => false)) {
    throw new Error(`Asset ${filename} not found in staging`);
  }
  
  await fs.copyFile(src, dest);
  await fs.unlink(src);
  console.log(`[Pipeline] Promoted ${filename} to committed assets`);
}

Rationale: Separating staging from committed assets enforces a human-in-the-loop checkpoint. Automated format optimization runs before promotion, ensuring consistent compression and resolution. This prevents AI-generated artifacts from polluting the build pipeline.

Step 3: Deploy Ops-Time Analytics & Moderation Routing

Live operations require real-time pattern detection. Churn prediction models (GNN/XGBoost) and moderation routers (ToxMod, Perspective, Hive) should operate asynchronously, feeding signals back to live-ops dashboards without blocking gameplay.

// ops-router.ts
import { createClient } from '@supabase/supabase-js';

const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_KEY!);

interface PlayerEvent {
  playerId: string;
  eventType: 'chat_message' | 'economy_trade' | 'session_end';
  payload: Record<string, unknown>;
  timestamp: number;
}

export async function routePlayerEvent(event: PlayerEvent): Promise<void> {
  if (event.eventType === 'chat_message') {
    const moderationPayload = {
      text: String(event.payload.text),
      playerId: event.playerId,
      channel: event.payload.channel || 'global'
    };
    
    // Async moderation check; does not block gameplay
    supabase.functions.invoke('moderation-check', { body: moderationPayload })
      .catch(err => console.error('[Ops] Moderation service unavailable:', err.message));
  }
  
  if (event.eventType === 'session_end') {
    const churnSignal = {
      playerId: event.playerId,
      sessionDuration: Number(event.payload.duration),
      lastInteraction: new Date(event.timestamp).toISOString()
    };
    
    supabase.functions.invoke('churn-scorer', { body: churnSignal })
      .catch(err => console.error('[Ops] Churn scoring failed:', err.message));
  }
}

Rationale: Edge functions decouple heavy inference from the game client. Moderation and churn scoring run asynchronously, preserving frame time and network latency. Failures are logged but never crash the session. This matches production requirements for 99.9% uptime and sub-50ms event routing.

Step 4: Implement Constrained Ship-Time PCG

Procedural content in the shipped binary must be deterministic, seed-controlled, and human-reviewed at scale. Use AI to generate candidate pools, then apply rule-based filters before runtime injection.

// pcg-quest-engine.ts
interface QuestTemplate {
  id: string;
  objective: string;
  rewardCurrency: string;
  rewardAmount: number;
  difficulty: number;
}

export class QuestGenerator {
  private seed: number;
  
  constructor(initialSeed: number) {
    this.seed = initialSeed;
  }
  
  private hashSeed(input: string): number {
    let h = this.seed;
    for (let i = 0; i < input.length; i++) {
      h = Math.imul(h ^ input.charCodeAt(i), 2654435761);
    }
    return h >>> 0;
  }
  
  generateQuestPool(candidates: QuestTemplate[], count: number): QuestTemplate[] {
    const pool: QuestTemplate[] = [];
    const usedIds = new Set<string>();
    
    for (let i = 0; i < count; i++) {
      const idx = this.hashSeed(`quest_${i}_${Date.now()}`) % candidates.length;
      const candidate = candidates[idx];
      
      if (!usedIds.has(candidate.id)) {
        pool.push({ ...candidate, id: `${candidate.id}_v${i}` });
        usedIds.add(candidate.id);
      }
    }
    
    return pool;
  }
}

Rationale: Deterministic seeding ensures reproducible quest pools across client/server boundaries. The generator filters duplicates and applies version tags for rollback capability. AI provides the candidate pool; the engine enforces distribution rules. This prevents runtime hallucination and economy inflation.

Pitfall Guide

Pitfall	Explanation	Fix
The Hero String Trap	AI generates critical narrative beats (marriage proposals, festival speeches, achievement unlocks). Players detect synthetic tone immediately, breaking immersion.	Reserve ~50–200 hero strings for human writers. Route all other flavor text through AI with a strict style guide and mandatory editor review.
Unvalidated Economy Math	AI outputs balance values without schema constraints, causing currency sinks/faucets to break or items to become overpowered.	Enforce Zod/TypeBox validation on all generated numbers. Run automated economy simulation tests before merging content PRs.
Runtime LLM Latency & Jailbreaks	Live NPCs or adaptive systems call external LLMs without timeout limits or prompt guardrails, causing frame drops or policy violations.	Implement strict timeout budgets (<200ms), local fallback responses, and content filtering middleware. Never expose raw model outputs to players.
Platform Disclosure Blind Spots	Shipping AI-generated art, music, or text without tracking violates Steam, Apple, and EU AI Act requirements.	Maintain a compliance ledger mapping every asset to its generation source, model version, and human review status. Export manifests for store submissions.
Tone Drift at Scale	AI generates thousands of strings without a centralized style bible, causing inconsistent voice, anachronisms, or tonal whiplash.	Build a style guide database with positive/negative examples. Run all AI outputs through a tone-classifier middleware before staging.
Reverse Adoption Order	Teams start with ship-time AI (live NPCs, runtime PCG) before establishing dev-time validation and ops-time monitoring.	Adopt in sequence: Dev-Time → Ops-Time → Ship-Time. Build validation infrastructure first; deploy runtime features only after monitoring is stable.
Over-Automating Polish	Treating AI-generated sprites, animations, or music as final assets without human refinement.	Use AI for concepting, inbetweening, and variation generation. Mandate artist/engineer polish passes before committing to the build.

Production Bundle

Action Checklist

• Schema Validation: Implement runtime type checking for all AI-generated content before it enters the data pipeline.
• Compliance Ledger: Track model versions, generation timestamps, and human review status for every shipped asset.
• Style Guide Database: Centralize tone rules, vocabulary restrictions, and negative examples for narrative and UI text.
• Async Ops Routing: Decouple moderation, churn scoring, and support triage from the main game loop using edge functions.
• Deterministic PCG: Seed procedural systems, enforce distribution rules, and maintain rollback capability for runtime content.
• Human Checkpoint: Route all hero strings, UI layouts, and audio master files through mandatory editor review before promotion.
• Latency Budgeting: Set strict timeout limits for runtime AI calls and implement graceful fallback responses.

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
Indie pre-production (1–5 devs)	Dev-Time coding agents + schema-validated asset staging	Maximizes throughput without runtime risk; builds validation habits early	Low (API credits + editor time)
Live ops scaling (100k+ MAU)	Ops-Time churn prediction + moderation routing + UA creative iteration	Data volume justifies ML investment; reduces support costs and improves retention spend	Medium (cloud inference + data pipeline)
Voice chat enabled	ToxMod-class voice moderation + async routing + human escalation queue	Prevents platform bans and community toxicity; meets store policy requirements	Low-Medium (moderation API + queue management)
Economy-heavy simulation	AI candidate generation + rule-based balance filters + automated simulation tests	Prevents currency exploits and item inflation; ensures mathematical correctness	Medium (simulation infrastructure + QA automation)

Configuration Template

{
  "pipeline": {
    "staging": "./assets/staging",
    "committed": "./assets/committed",
    "validation": {
      "schema": "zod",
      "strictMode": true,
      "rejectOnFailure": true
    },
    "compliance": {
      "ledgerEnabled": true,
      "trackModelVersion": true,
      "requireHumanReview": ["hero_strings", "ui_layouts", "master_audio"],
      "exportManifest": true
    },
    "ops": {
      "moderation": {
        "provider": "toxmod",
        "timeoutMs": 150,
        "fallback": "queue_for_human_review"
      },
      "churn": {
        "provider": "gnn_xgboost",
        "updateFrequency": "daily",
        "alertThreshold": 0.72
      }
    },
    "pcg": {
      "deterministic": true,
      "seedSource": "server_timestamp",
      "maxPoolSize": 50,
      "deduplication": true
    }
  }
}

Quick Start Guide

1. Initialize Validation Layer: Install Zod or TypeBox. Define schemas for your core content types (items, quests, dialogue). Wire validation into your content import script to reject malformed payloads before they reach the game data store.
2. Wire Dev-Time Agents: Configure Cursor or Claude Code with project-specific context files. Set up CI hooks that run automated linting, format optimization, and schema validation on every PR. Route AI-generated assets to a staging directory, not directly to committed.
3. Deploy Async Ops Hooks: Create edge functions for moderation routing and churn scoring. Integrate them into your event dispatcher so player actions trigger background analysis without blocking the main thread. Set timeout limits and fallback queues.
4. Establish Compliance Tracking: Add a metadata field to your asset pipeline that records model version, generation timestamp, and review status. Export this ledger automatically during build steps to satisfy platform disclosure requirements.
5. Run Deterministic PCG Tests: Seed your procedural generators with server-controlled values. Implement deduplication and distribution rules. Validate outputs against balance constraints before runtime injection. Iterate pool sizes based on simulation results.