My Kid Said They Wanted to Make a Game

 

I'd started making games as a hobby.

I'd previously completed a tarot project with AI, and a Four Pillars of Destiny (saju) project too. Both were substantial enough to warrant 20-part development diaries, and I'd gained confidence in AI-collaborative development. While thinking about what to tackle next, games caught my eye. A domain I'd never built for, but had plenty of experience playing. My developer curiosity was piqued.

So I asked my kid. "Dad's been making games as a hobby lately. Do you have a game you'd like to make? We could build it together."

Their eyes went wide. "Really? I can do it too?"

"Sure. What kind of game do you like?"

A moment of thought, then the answer: "A dating sim."

I was caught off guard. I'd expected them to say a shooter, a puzzle game, maybe something like Minecraft. A dating sim? I have no idea where they picked that up — trending among friends, maybe — but the look on their face was dead serious.

And for some reason, that answer wouldn't leave my head. Partly surprise at a middle school girl's taste, but more than that, something inside me had responded.

A Developer's Reflex

I'm a developer. Building things is what I do for a living. So when someone asks "can we make this?" my brain kicks in automatically. Can we? Technically, almost anything is possible. The real questions are always elsewhere: time, planning, polish, and the willpower to see it through.

The moment my kid said "dating sim," the developer brain started evaluating feasibility. Visual novels. Dating sims. Games made of text and choices. No flashy action, no complex physics. Instead, there's a story, there are choices, and those choices shape relationships.

I'm not entirely a stranger to game development. Back in the early 2000s, when the world was transitioning from DOS to Windows, I was building game libraries from scratch. Parsing bitmap and PCX image formats by hand, fixing screen flicker with double buffering. There was no Unity, no Unreal back then. But that was over twenty years ago, and today's game development ecosystem is an entirely different world.

But a visual novel? The core isn't code — it's scenario. Get the branching logic and state management right, and the skeleton is done. And scenario design is exactly where AI collaboration shines brightest.

I could do this.

Why a Dating Sim, of All Things?

My kid choosing a dating sim was, honestly, intriguing for me too.

I'd had a personal curiosity about the visual novel genre. More of a question than an interest. Can a game, as a medium, genuinely touch human emotions? Can a few choice prompts and text create real feelings? This isn't a technical question — it's a design question.

Most games focus on achievement over emotion. Level up, clear, score, rank. Visual novels are different. The entire purpose is emotion. The process of growing to like someone, the moment a relationship fractures, the realization that it's already too late. Making the player experience these things firsthand.

Does it actually work? If so, how do you design for it? My kid's answer lit the fuse on that curiosity.

And one more thing. This project was fundamentally different from tarot or saju. Tarot was about structuring data. Saju was about translating complex domain logic into code. A visual novel is about designing emotion. I wanted to see what AI could do in the domain of human feeling — and where it would hit its limits.

Asking AI the First Question

There's something I always do when starting a project: ask AI the most basic question possible.

"I want to make a visual novel game. Where should I start?"

I sent this single sentence to Claude. In the response, I encountered the name Ren'Py for the first time.

Ren'Py. A Python-based visual novel engine. Less a game engine than a dedicated visual novel toolkit. The dialogue system, choices, branching, and UI are already built in. Edit one file called script.rpy, and you have a working visual novel.

The minimal code AI showed me looked like this:

define e = Character("Eileen")

label start:
    scene black
    e "Hello."
    e "This is my first visual novel test."

    menu:
        "Choice A":
            jump route_a
        "Choice B":
            jump route_b

label route_a:
    e "You chose A."
    return

label route_b:
    e "You chose B."
    return

That's it. Define scenes with label, create choices with menu, branch with jump. Ten lines and you have a functioning visual novel. Just edit this file after installation, and you can reach "engine understood" status in thirty minutes.

That was the moment I knew. This was doable. No complex rendering pipeline, no physics engine needed. Story and choices, and the logic that weaves them together. That's all.

AI went one step further, identifying three things to nail early in the project: script structure, asset folder organization, and route design. The third point especially caught my attention — a warning that without route design upfront, branching becomes unmanageable later. AI occasionally speaks like a seasoned developer, and this was one of those moments.

The Real Problem Isn't Code

Ren'Py's technical barrier is low. Any developer who knows Python can grasp the engine in a day. Variable declarations, conditionals, branching. All familiar territory.

But as I continued the conversation with AI, something else came into focus. Not code structure — scenario structure. Not technical problems — design problems.

When I asked AI "how should I build the emotion system?", the answer surprised me. I expected a simple proposal about raising and lowering affection points. Instead, AI suggested layering emotions. Separating disposition, momentary feelings, and relationship state. Not treating love as a single variable, but as a combination of trust, intimacy, and fear of loss.

This wasn't a coding problem. It was a question of how to understand human emotion and what structures to abstract it into.

And I realized: the real journey of this project wasn't writing code — it was designing scenarios. Making a visual novel isn't technically hard. But making one that genuinely moves the player's emotions is an entirely different challenge.

Telling My Kid

A few days later, I told my kid. "Let's make that dating sim. A story game. Where the story changes based on what you choose."

"I get to pick?"

"Yeah. The story changes depending on what you choose."

"What happens if I pick something bad?"

"It might make you sad."

"Why?"

I couldn't answer right away. Why would it make you sad? It's a fictional character, a fictional story. Why do people feel real emotions from something that isn't real? My kid's simple question was, in fact, the core of this entire project.

The Direction

This series isn't a record of completing one visual novel. It's a record of designing its scenario.

How do you draw out human emotion in a short span of time? What kind of emotional experiences can you create with choices as your only tool? What role can AI play in this process, and where does it show its limits?

Code comes later. First, the scenario must be designed. The structure of emotion must be understood. Only then does code gain meaning.

Starting from a child's question, passing through a developer's curiosity, arriving at a journey of designing emotion with AI. That story begins now.

---

Next: What Even Is a Visual Novel? — Dissecting the Genre with AI