View on Steam ↗A conversational game still needs dependable rules
AI2U: With You 'Til The End is a conversational-AI puzzle game. Players talk with expressive characters, explore authored levels, solve puzzles, and reach different endings. Behind those conversations, the game still needs reliable state, timing, animation, persistence, and recovery when something unexpected happens.
I work on the Unity client as Lead Game Developer and help coordinate releases. My responsibility spans the moment an AI-selected action enters the game, the systems a player directly touches, and the production workflows that help the team test and ship stable builds.
My role at a glance
My work is easiest to understand as four connected areas. Character behavior is the center of the experience, but it depends on player-facing features, persistent systems, telemetry, and a reliable production process around it.
Character systems
Behavior trees for every NPC, special actions, chase behavior, and transformation states.
Player features
Art Canvas, puzzles, conversations, music interaction, and player-profile persistence.
Progress & insight
Achievements, PlayFab storage, Steam and itch.io feedback, and gameplay telemetry.
Production systems
Daily merge coordination, external QA, Jira triage, lighting tools, and build support.
Turning AI decisions into dependable character actions
A language model can suggest that a character should move, sit, hug, kiss, laugh, or react to the player. Unity still has to decide whether that action can happen now, move the characters into position, wait for voice and animation timing, manage player control, and return the scene to a valid state.
I designed and developed the project's NPC behavior-tree systems across normal conversations and the Final Chase sequence. The same foundation supports baseline movement and stance changes, special interactions, and the Level 4 character's transformation between human and mermaid forms.
I also coordinate the Unity-side requirements with animators, designers, and backend engineers. That cross-disciplinary boundary matters: the backend can choose an expressive action, while authored gameplay logic remains responsible for physical state and execution.
- 01
Action arrives
The backend selects a character action from current conversation and game context.
- 02
Client validates
Unity checks that the NPC, player, and scene are ready for the interaction.
- 03
Behavior tree runs
Authored states own movement, positioning, timing, and recovery.
- 04
Performance plays
Animation, voice gates, Timeline, VFX, and SFX deliver the action.
- 05
Game stays in control
The interaction returns to a valid gameplay state instead of handing runtime control to the model.
Art Canvas: player expression becomes AI-readable input
In Level 1, I designed and developed an in-game drawing canvas. Players draw with the mouse, choose colors, and adjust line thickness without leaving the game world.
When the drawing is complete, the Unity feature captures it as an image and sends it to the backend for processing by a vision-capable AI module. The feature turns a familiar creative action into structured input that another part of the game can understand.
One achievement system across the game and its platforms
I owned the achievement system from gameplay conditions through persistent storage and player feedback. Unity evaluates each unlock, PlayFab stores the state, the in-game interface updates, Steam receives its corresponding achievement, and itch.io uses a custom notification experience.
The system supports 103 achievements. Its value is not only the number: the same unlock needs to remain consistent across the game, persistent player data, and platform-specific presentation.
One unlock, multiple destinations
More systems players directly touch
Alongside the three larger systems, I developed individual interactions and puzzles across the game. These features range from a self-contained repair puzzle to persistent player profile data.
Interactive puzzle
Electricity repair
Capture the broken state, player interaction, and repaired result.Music interaction
Phonograph
Show the player's input and the game's visible response.Side-NPC conversation
Dark Siren
Use a spoiler-safe exchange that shows this separate character encounter.Persistent player data
Name & bio
Show the player-facing edit and saved-state return.Learning from players and keeping builds stable
I worked with backend engineers to instrument puzzle activity, endings, and NPC interactions on the Unity client. I then reviewed the collected gameplay data with designers so observed player behavior could enter design discussions.
I also designed and coordinated the team's daily Unity merge workflow. Teammates recorded their changes in chat and commits; I organized those changes for integration. After Early Access increased the need for structured stability testing, I helped identify an external QA provider and became the ongoing development-side contact for Jira bug reports.
Player insight
From play to design review
I worked with backend engineers on Unity-side instrumentation, then reviewed the resulting gameplay data with designers to support iteration.
Build reliability
From commits to verified fixes
I coordinated daily Unity integration and served as the development-side contact for the external QA team.
Lighting support for a game whose rooms can change
Level 1 assembles room configurations procedurally, while baked lighting depends on the correct room setup. I developed an internal tool that connects each generated room configuration with its corresponding lightmap data, and I supported lighting effects and performance-oriented testing elsewhere in the game.
What this work has taught me
AI2U has made me comfortable working where disciplines meet. A character problem may come from an AI decision, a gameplay state, an animation dependency, a timing issue, or a missing agreement between teams.
My role is often to find the correct boundary: let the AI provide expression, let authored systems protect the game state, and give the team enough visibility and structure to test what players actually experience.