function buildPersonalWebsite() {
  const developer = new Developer('Enes Arıkan');
  const skills = ['React', 'TypeScript', 'Next.js', 'TailwindCSS'];
  
  developer.setExperience([
    { role: 'QA Engineer', company: 'Insider', years: 2 },
    { role: 'Software Tester', company: 'Various', years: 3 }
  ]);
  
  const projects = developer.createProjects([
    'E-commerce Platform',
    'Task Management App', 
    'Weather Dashboard',
    'Portfolio Website'
  ]);
  
  return {
    portfolio: developer.showcase(projects),
    blog: developer.shareKnowledge(),
    contact: developer.getContactInfo(),
    playground: developer.createInteractiveGames()
  };
}

class CareerJourney {
  constructor() {
    this.levels = [];
    this.currentLevel = 0;
    this.experience = 0;
  }
  
  addExperience(role, company, duration) {
    this.levels.push({
      title: role,
      company: company,
      duration: duration,
      skills: this.getSkillsForRole(role)
    });
    this.levelUp();
  }
  
  levelUp() {
    this.currentLevel++;
    this.experience += 100;
    console.log(`Level up! Now at level ${this.currentLevel}`);
  }
  
  getSkillsForRole(role) {
    const skillMap = {
      'QA Engineer': ['Testing', 'Automation', 'Bug Tracking'],
      'Frontend Developer': ['React', 'JavaScript', 'CSS'],
      'Full Stack Developer': ['Node.js', 'Databases', 'APIs']
    };
    return skillMap[role] || [];
  }
}

// Initialize the journey
const career = new CareerJourney();
career.addExperience('QA Engineer', 'Insider', '2 years');

// Bug hunting mini-game logic
function createBugHunt() {
  const bugs = [
    { type: 'NullPointerException', severity: 'high' },
    { type: 'RaceCondition', severity: 'critical' },
    { type: 'MemoryLeak', severity: 'medium' },
    { type: 'InfiniteLoop', severity: 'high' }
  ];
  
  return {
    findBugs: () => bugs.filter(bug => bug.severity === 'high'),
    fixBug: (bugId) => console.log(`Fixed bug: ${bugId}`),
    score: bugs.length * 10
  };
}

// Skill tree implementation
const skillTree = {
  frontend: {
    react: { level: 5, unlocked: true },
    typescript: { level: 4, unlocked: true },
    nextjs: { level: 4, unlocked: true }
  },
  testing: {
    automation: { level: 5, unlocked: true },
    manual: { level: 5, unlocked: true },
    performance: { level: 3, unlocked: true }
  },
  tools: {
    git: { level: 4, unlocked: true },
    docker: { level: 2, unlocked: false },
    kubernetes: { level: 1, unlocked: false }
  }
};

export default buildPersonalWebsite;
Back to Blog
Game development setup representing generative AI in games
January 18, 2025·Game Development

Generative AI in Game Development: Real Uses vs. Hype

From AI-generated assets to procedural dialogue, the tools are impressive — but knowing when to use them changes everything.

AIGame DevelopmentUnityGenerative AI

Game development has always been one of the most creative and technically demanding disciplines in software. Now AI tools are reshaping almost every layer of it — art, audio, narrative, code, QA. Having worked across Unity-based mobile games and tested games professionally, I've had a front-row seat to what's actually changing and what's still wishful thinking.

Where AI Is Genuinely Useful

Concept art and visual references: Midjourney and similar tools have become standard in early-stage game development for quickly generating mood boards, character concept variations, and environment sketches. Indie developers who previously couldn't afford concept artists can now produce 50 visual directions in an afternoon and pick the best. This is a real unlock.

Texture and asset variation: Generating tiling textures, icon variations, and UI elements has become dramatically faster. For a mobile game that needs 200 item icons with a consistent aesthetic, this is genuinely transformative.

Dialogue and narrative scaffolding: LLMs are excellent for generating first-draft NPC dialogue, quest text, and lore documents. They don't replace narrative directors or writers, but they compress the blank-page problem significantly. A writer can review and refine 50 NPC conversations in the time it used to take to write 10.

Code assistance: GitHub Copilot inside Unity has become part of many developers' workflows. Boilerplate MonoBehaviour scripts, state machine implementations, UI code — these go faster with AI assistance.

Where It's Still Overhyped

"AI-generated games": The claim that AI can generate a complete, playable, balanced game is years away. Game design is deeply iterative and judgment-based. AI can accelerate components; it can't yet assemble them into something with the feel of a well-crafted experience.

Fully AI-voiced characters: AI voice synthesis has improved dramatically, but replacing voice acting for main characters in story-driven games produces something players notice and find unsatisfying. It works for ambient crowds and minor NPCs; it doesn't yet work for characters that carry emotional weight.

Automated game testing: This is the area I know best. AI tools can automate some regression testing and pathfinding coverage, but gameplay testing — does this feel fun? Is this difficulty curve punishing? Is this UI confusing? — remains stubbornly human.

What Changes for Indie Developers

The most significant shift is capability democratization. A solo developer in 2025 can produce visual and audio quality that would have required a small team in 2020. The ceiling for a solo project has risen substantially.

But this creates a new bottleneck: design judgment. When you can generate 1,000 assets quickly, the skill that matters is knowing which 20 are good and how to use them well. Taste and design thinking become the scarce resource, not production capacity.

AI in QA for Games

From a testing perspective, AI introduces new categories of things to verify:

  • Procedural content quality: If AI generates level sections, you need to test not just that they're technically valid but that they're playable and appropriately challenging
  • NPC dialogue consistency: AI-generated dialogue can drift in tone or contradict established lore — requires a review pass that didn't exist before
  • Bias in generation: AI image tools can produce outputs that reflect training data biases, especially visible in character representation

My Take

The developers I see thriving with AI tools are those who use them as accelerators for specific bottlenecks rather than replacements for craft. AI handles the volume; the developer handles the judgment.

That balance will shift over time. But for now, the games that feel special are still built by people who care deeply about every detail — and who happen to have very powerful new tools available.

I built several mobile games using Unity and Buildbox. See the projects page for details.