Inspiration
Important decisions rarely fail because people lack information. They fail because tradeoffs are difficult to feel before they happen.
We created WTF: What The iF, also called What If, to help people emotionally rehearse possible futures before making a decision. Instead of returning another list of pros and cons, the application turns each decision into three visual stories: choosing the path, declining it, and testing it through a reversible experiment.
The idea came from a simple belief: sometimes seeing an ordinary day inside a possible future carries more weight than reading advice about it.
What it does
Users describe a decision, its context, time horizon, and stakes. The AI then identifies:
- The deeper tension behind the decision
- The most important uncertainty
- An observable signal the user should watch
- Three meaningfully different possible futures
Each future contains personalized reasoning and three live-action scene descriptions. The application presents these as short cinematic concept reels using distinct visuals.
When video generation is available, individual scenes can be submitted to the OpenAI Videos API and rendered as MP4 clips. When video access or quota is unavailable, the application remains demonstrable through clearly labeled local concept reels.
What If does not predict the future or tell users what to choose. It helps them see the consequences, emotions, and tradeoffs they may otherwise overlook.
How we built it
We built the application with:
- ASP.NET Framework 4.8.1 and ASP.NET MVC 5
- Microsoft SQL Server and LocalDB for development
- OpenAI Responses API with GPT-5.6
- Structured Outputs using a strict JSON schema
- Optional OpenAI video generation
- Razor, CSS, and vanilla JavaScript
- Codex with GPT-5.6 Sol medium as our development collaborator
The Responses API transforms the user’s situation into a structured decision analysis. The schema ensures that every result includes three outcomes and three scenes per outcome.
Sessions, outcomes, scene prompts, video jobs, and generated-video paths are stored in SQL Server. All database connections use a single WhatIfDb connection string, making deployment configuration straightforward.
Codex helped us develop the architecture, debug the API integration, improve the experience, generate visual assets, prepare the database, and produce the public demonstration video.
Challenges we ran into
Our first prototype felt too scripted. Different questions produced similar outcome titles, repeated images, and generic advice. That undermined the central idea because the audience could not clearly see where AI was contributing.
We redesigned the prompt and response structure so the AI must infer the tension beneath each decision, explain why each path matters, and create scenes grounded in the user’s specific context.
We also faced API quota limitations. The application successfully reached OpenAI, but requests returned HTTP 429 while the account lacked usable API credits. We handled this by building a transparent local demonstration mode rather than presenting fallback output as AI-generated.
Other challenges included:
- Producing distinct visuals for all three outcomes
- Communicating long-running video rendering progress
- Correctly implementing strict Structured Outputs
- Making LocalDB work reliably during development
- Converting the solution from a desktop launcher into a deployable IIS web application
- Keeping API keys and production database credentials out of source control
Accomplishments that we're proud of
We are proud that What If goes beyond a chatbot response. It turns AI reasoning into an experience that users can inspect, compare, replay, and remember.
The application now:
- Produces personalized, structured decision analysis
- Presents three genuinely different futures
- Creates distinct three-scene concept reels
- Clearly distinguishes OpenAI output from local fallback output
- Stores complete decision sessions in SQL Server
- Supports asynchronous video-rendering jobs
- Remains functional when video generation is unavailable
- Builds and publishes as a deployable ASP.NET web application
Most importantly, it preserves the user’s agency. The AI does not give a verdict. It makes hidden assumptions and tradeoffs visible.
What we learned
We learned that AI quality is not only about selecting a capable model. The surrounding product design determines whether users can recognize and trust the intelligence behind the result.
Structured Outputs made the model’s reasoning usable by the application, but structure alone was insufficient. We also needed strong prompts, validation, transparent fallback behavior, and a visual language that reflected the user’s actual situation.
We learned that generated media works best as a decision-rehearsal tool when scenes focus on ordinary moments: a conversation, a difficult morning, a financial consequence, or a feeling that appears months after the decision.
We also learned that AI should support judgment, not replace it. Possible futures are valuable because they generate better questions, not because they claim certainty.
What's next for WTF (What The iF)
Next, we want to develop What If into a complete decision-rehearsal platform:
- Combine rendered scenes into one continuous short film
- Add natural AI narration and sound design
- Allow users to adjust assumptions and regenerate only the affected futures
- Compare emotional, financial, relational, and practical consequences
- Add private sharing with trusted friends or mentors
- Track which observable signals appeared after a decision
- Support alternative video providers as the media ecosystem evolves
- Add stronger privacy controls and automatic retention limits
- Evaluate whether the experience genuinely improves decision clarity
Our long-term vision is simple: before committing to an important decision, people should be able to visit its possible futures and return with better questions.
Log in or sign up for Devpost to join the conversation.