Unsent Drafts: P2 The Empathy Machine

Before you step into the inbox, know this: Unsent Drafts isn’t just a story about what has been said, but also about what isn’t said. It is an emotional simulation of hesitation, pride, and the want for connection. Every action  translates to a feeling you’ve probably lived before. The goal of this game is not to win or lose, but to feel seen and noticed. By Aalaap Hegde. 

First I would like to invite you to play my game: https://unsent-vibe-sync.lovable.app/?utm_source=lovable-editor

Premise:

Setting: Unsent Drafts takes place inside a digital inbox, a minimalist, text-driven medium that feels both intimate but dry. Each draft represents a frozen moment in time: 3 a.m. reflections, half-written feelings, and potentially deleted messages. In this game, the interface is both the “map/guide” and the setting itself, and the visual effects shift subtly with tone: cold blues during detachment and conflict, warm hues when empathy rises.

Role: The player assumes the role of a writer confronting the emotional aftermath of a family betrayal: a sibling who lied about a $15,000 debt. There are no side characters on screen, but their presence is implied through the drafts and subject lines. The player’s actions determine whether the sibling becomes forgiving, defensive, or detached.

Player’s Journey: The player logs into inbox, reopens five unsent drafts, and  then decides what to do with each, Send, Edit and Save, or Delete. After revisiting all drafts, a Compose scene invites them to write a final message. Along the way, popups (“Read Immediately”) and shifting background tones show the emotional consequences. Each choice builds toward one of three endings: meeting at a coffee shop, quiet acceptance, or estrangement. 

Understanding: The game invites players to reflect on hesitation, forgiveness, and their own pride. It explores how unresolved conflict stays not just through main family events events but even through the small silences we feel everyday. By the end, players understand that empathy isn’t just an external virtue but it is actually also an act of self confrontation.

Design Intent

I wanted to create an “empathy machine” through constraint, not complexity. I initially tried having several different paths (each with different results), but slowly I realized that I wanted to explore emotional tension within tight parameters. I felt that this mirrors the experience of staring at an unsent email, knowing every choice says something about you. There’s no right option.

Empathy arises not just from sympathy for a character, but from observing their hesitation. By forcing players to pause, reread, and decide what to do with their words, the game simulates the emotional discomfort of unresolved communication. The interactivity also invites the player to feel the freedom of sending, the comfort of deleting, and the safety of leaving some of their feelings. From what we learned in class, this game shows embodied empathy, where players don’t just witness emotions, they perform them through input.

I also wanted class concepts such as meaningful choice, reactive narration, and ludonarrative harmony to influence every design element. “Send,” “Edit,” and “Delete” weren’t just UI buttons—they are heavy actions. Each decision reveals how players feel about regret, making this story both game and a mirror. The design turns emotional states into mechanics, reflecting Jesper Juul’s idea of half-real games where systems and stories coexist. Additionally, the player’s body mirrors the character’s stillness, their enactment (clicking, hesitating) becomes moral participation, their emotional state syncs with the rhythm of sending and waiting, and the environment (a dim, minimalist inbox) acts as an echo chamber for your emotions. I wanted to combine these elements to  make the experience intimate and affective.

Choice of medium:

I began this project with the story about a chef, which was a narrative written in text form. I just did this on a Google Doc to see if purely narrative worked for me. Versions 2 and 3 (Ravenscroft High) were developed in Inform7, which allowed me to experiment with parser based interaction. However, Inform’s structure felt limiting for the emotional intimacy I wanted. The limited command syntax both caused a lot of errors for me (I had no experience in this) and I also felt the medium simulated exploration more than reflection. 

For Unsent Drafts, I decided to code the experience from scratch using HTML, CSS, and JavaScript. I used the tools of Claude Code and Lovable to help me (decently effective but still involved a lot of debugging and learning). However, this approach gave me full control interface design and emotional pacing. I could control how text fades, when a button disables, how long silence lasts before the next message loads. Writing my own system also let me align with class ideas about designing for “medium affordances”. The inbox UI became both map and medium, which leveraged something we’re all very comfortable with (inbox) as an emotional landscape. 

Core Game Structure

1. Introduction -> context (the break) -> view drafts 1-5 -> compose email -> ending
2. Each of the 5 drafts have three main call to actions:
   1. Send email draft to sibling (adds empathy/conflict tone)
   2. Edit and save as a draft (adds reflective/defensive tone)
   3. Delete (adds release/detachment tone)
3. After you send the first message (if you choose to do so), you’ll see that your sibling immediately reads your message and see how you feel, which hones into the empathy. There’s also no call to action so this adds a level of constraint.

As the player moves through five drafts, each action (Send, Edit, or Delete) adds emotional weight (both emotionally and logically into the game). Sending increases empathy and conflict, editing reflects introspection or defensiveness, and deleting builds distance or detachment. After all drafts are completed, the game looks at the overall emotional balance. If most choices lean toward sending or empathy, the story ends with “The Coffee Shop”, a scene of reconnection and forgiveness. If the actions are balanced between send and delete, the player experiences “The Stillness”, a moment of quiet reflection and acceptance. If the player deletes often or chooses defensiveness, they reach “The Fallout”, where estrangement is final and irreversible.

I wanted to use a branch and bottleneck design, where player’s emotions create distinct paths that ultimately converge in one of three states, ensuring each ending feels earned without overcomplicating the experience. I previously tried having a fully branched out story, but this created way too many situations and the focus of this game was creating empathy. 

Iteration and Design History:

Iteration #1 — The Chef (20th-Century France)

Core idea: You play as a talented chef whose ambition isolates him from his peers. After being expelled from a prestigious kitchen, you must rebuild from nothing and rediscover purpose through creation and mentorship.

Playtester: this was an informal play test since it was done in class for an assignment

Playtest feedback:

• Add player choices to increase agency and replayability.
• Slow down emotional beats to enhance empathy.
• Clarify the redemption arc (ego → humility → mentorship).
• Make the setting more vivid and grounded.

  

Changes that I made:

I realized that this current story didn’t have enough that I needed for an IF. I could have added other chefs/patrons to the story, but I realized changing the storyline to something more interesting and relatable would be better. As such, I decided to create a mystery-themed story which takes place in a high school. I also think the current story felt more like a morality tale/journey narration rather than an empathy machine. Also choices were framed around values (protecting pride vs. admitting fault) rather than plot branches, so in the new iteration I wanted to have explicit places to make choices.

Iteration #2 — Last Bell at Ravenscroft High (v1)

Core idea: An abandoned high school becomes a memory space where the player relives past relationships. As they explore classrooms, gyms, and libraries, they collect “fragments” and a “truth score” that determine closure.

Playtester: my friend (someone who went to a big public school with a tradition to bury time capsules). I chose him to see if he would resonate with this part of the story.

Playtest feedback:

• Pure text felt flat and needed visual or auditory cues.
• Decision trees were too shallow; add antagonists and deeper conflict.
• The story needed more specific world details for immersion.
• Player goals and motives weren’t emotionally clear.

Changes that I made: the story needed to be a lot deeper and exciting. I first wrote a new narrative that used a lot more imagery and specific details that made the story more interested. I wanted to paint such a vivid picture that the player felt that they were the character. The next thing that I did was add an implied antagonist and echoes of conversations/objects that reveal emotional context. I also added more potential branches, more rooms, and generally a more complicated storyline.

Iteration #3 — Ravenscroft High (Expanded Build)

Core idea: Expanded branching dialogues, an implied antagonist, and subtle supernatural cues reframed the mystery around guilt and memory.

Playtester: My brother

Playtest feedback:

• The available options for typing were unclear.
• Writing felt cinematic and cohesive, but players still didn’t emotionally connect to the game
• Needed clearer introspection moments after choices.
• Navigation and input flow required polish..

Demo video: https://youtube.com/shorts/gJVIjs4Co-8

In this video, we can see that some parts of the game are intuitive, while others are very confusing. The main problem is actually figuring out what the total set of prompts are. In the start, I explain the rules but don’t give too much information. At around 10 seconds, he starts putting in input and it’s working well. However, around the 35 second mark, he starts getting confused on what exact input to show. Around the 50 second mark, we can see how confused he is about the responses. 

Changes that I made:

Ultimately, I think the story was very interesting but it didn’t achieve the assignment’s main goal, which was empathy. A few changes were needed. First, I wanted to use a more visual medium. A part of this decision was the fact that I’m more of a visual engager than a reading one, so this would make internal play testing more exciting. I also wanted to have more flexibility over the exact decision paths and exact text shown on the screen (one of my play testers thought Inform7 was a little confusing). As such, I decided to create a new storyline with a very strong empathy core: a fight between siblings and build the game out from scratch.

Iteration #4 — Unsent Drafts (Early Pivot)

Core idea: The story shifted to an epistolary format—a character revisiting unsent emails to their estranged brother.

Play tester: My brother (11th grade and someone I have a very close bond with). I gave him no context for this story and wanted to see how he felt. He gave me a hug after 🙂

Build limitations:

• Only “read” and “delete” existed; no “send/edit” options.
• No context for the conflict or emotional stakes.
• No endings—experience felt unfinished

Playtest feedback:

• Needed stronger mechanical stakes (e.g., actually sending).
• Missing narrative grounding—players didn’t understand the fight.
• Add closure to complete the empathy arc.

Changes to be made:

He resonated with the tone and realism, but I saw that empathy needed a causal connection: they needed to know why the fight mattered. I realized I could merge the intimacy of letters with reactive design mechanics by adding a lot more detailed text to the narrative and making the conflict very specific (a sibling estrangement). Other than this, I felt that the story was quite strong because of all the past play test feedback being integrated into this one.

Iteration #5 — Unsent Drafts

What it is now:
Five unsent emails written over three years, a “Compose” sequence, and endings determined by cumulative tone and final actions. The inbox itself acts as the map and memory space—a UI metaphor for guilt, hesitation, and reflection.

Playtesters: my friend. She has two younger brothers and I wanted to see her perspective.

Playtest Feedback:

• Both starting and ending felt really abrupt. Add some contextualization especially at the start (why did this fight even happen). Same thing at the end, add an ending that really drives the empathy.
• Structure got a little repetitive (5 drafts one after the next). Maybe add a surprise component
• Need a more drastic change on how the decisions players make have an impact on the ending state.

Final Changes after Playtesting:

• Added vivid story context and graphics.
  • I wrote a new opening sequence revealing the $15,000 lie and fallout that caused the estrangement. Subtle background visuals and interface cues reinforce emotional tone—an example of embedded narrative through visual context.
• Introduced the “Read Immediately” popup moment.
  • After the first email is sent, a timed message appears: “Read immediately.”
  • This small constraint halts gameplay, transforming a simple click into an emotional silence. It applies the design principle that limiting control can heighten empathy, forcing players to experience the discomfort of waiting.
•  Added multiple ending states. The story now concludes with one of three outcomes:
  • Coffee Shop (Reconciliation) — empathy-dominant path
  • Stillness (Acceptance) — balanced reflection
  • Fallout (Estrangement) — conflict-dominant path

 

Each ending reflects not just player decisions but the emotional pattern those choices created, turning reflection itself into the main mechanic that I wanted to focus on.

Reflection:

I did this:
I built Unsent Drafts from scratch to understand how hesitation could be a storytelling tool to drive empathy. By coding everything, from pauses to fades and transitions, I treated silence as a design element, not a gap. Every click became an ethical choice, mirroring the unease of sending or withholding a message. The game embodies Bogost’s idea of procedural rhetoric, where emotion is communicated through system behavior rather than exposition.

I learned this:
Empathy is not built through dialogue or backstory; it grows through tone and consequence. The player’s smallest actions, and even not making an action, can have very strong effects on their empathy towards a specific topic. Isbister’s How Games Move Us reframed empathy for me as participation rather than observation, and Jenkins’ Narrative Architecture reminded me that environment alone can hold emotional meaning. By designing the inbox as both space and metaphor, I learned how mechanics can teach reflection without ever breaking immersion.

From class discussions, I also realized that empathy deepens when players feel uncomfortable, which was something that initially was weird for me but then I understood. Cognitive dissonance, when the easy choice feels morally wrong, forces genuine introspection. I leaned into that discomfort, allowing the interface to deny closure and mirror the tension of real communication breakdowns. The result is not a clean emotional payoff but a quiet resonance that stays after the browser closes.

Next time:
If I had more time, I would evolve Unsent Drafts into a dynamic empathy simulator that reacts to how long players wait or how carefully they write. I want to build procedural emotional systems that change tone based on hesitation or sincerity, capturing what is usually invisible in digital dialogue. I would also experiment with AI-driven reflection, where the game reads the player’s messages and mirrors them back with empathy or misunderstanding. The goal would be to move beyond scripted emotion and create something that truly feels alive. I would have also liked the opportunity to playtest with more different audiences. I think since I had to pivot twice earlier on, I didn’t get as many play tests as I wanted for the final version. Lastly, I would spend more time with the images. I wanted to actually film the fight scene at the start as well as have a lot more images through the story, but unfortunately I didn’t have the time. I would consider adding all these features in p4.