Usaid

Experience the future before you choose it

Comment

Inspiration

Most people make major life decisions with incomplete information. Career shifts, relocations, relationships, and financial bets often depend on instinct, short-term emotion, or advice that does not reflect the full picture.

We wanted to build something that makes long-term decision-making feel more concrete. Instead of asking an AI for one generic answer, we asked: what if you could explore multiple realistic futures before committing to a choice?

That idea became Usaid, an AI-powered cognitive time simulator that helps users examine possible outcomes, trade-offs, and second-order effects before making an important decision.

This was also a strong fit for Contral IDE. Since Contral is built around understanding the code you ship, we used that mindset while building Usaid: every feature had to be explainable, traceable through the repo, and defendable at the architecture level.

What it does

Usaid helps users simulate different future paths from a single life decision.

  1. A user enters a real decision in natural language.
  2. The system combines that decision with the user's profile, including risk tolerance, priorities, and current situation.
  3. Gemini generates multiple distinct timelines with different probabilities, trade-offs, and second-order effects.
  4. Each timeline is shown with structured events and scores across emotional, financial, career, relationship, and risk dimensions.
  5. The user can select timelines to compare side by side.
  6. The user can inject a follow-up decision into an existing path and generate a new branch of futures.

The result is not just advice. It is a structured way to think through uncertainty.

How it is built

Usaid is a full-stack application with a repo structure that is easy to reason about and explain.

  1. Frontend: Built with React, TypeScript, and Vite. State is handled with Zustand and data fetching is handled with React Query. The interface focuses on clear timeline cards, comparison views, and an immersive glass-style visual system with theme and sound controls.

  2. Backend: Built with Node.js and Express. The backend handles authentication, decision creation, timeline generation, decision branching, and protected API routes.

  3. Database: Prisma with SQLite is used to persist users, decisions, timelines, timeline events, and feedback data.

  4. AI Layer: Google's Gemini models power the simulation engine through @google/genai. We use a model fallback chain and a structured JSON response contract so the frontend can reliably render generated futures.

  5. Decision Engine: The prompt is not based only on the latest question. It also uses user profile context and recent decisions so the generated futures feel more personalized and internally consistent.

How Contral IDE helped us

Contral IDE was especially valuable because this project has multiple moving parts: prompt design, structured AI output, route logic, persistence, and frontend rendering. We did not want a project we could demo but not explain.

Contral's repo-aware workflow helped us:

  1. Understand the data flow from decision input to Gemini generation to database storage to timeline rendering.
  2. Iterate faster on prompt structure while still keeping the JSON contract understandable.
  3. Review architectural choices across frontend, backend, and database layers without losing context.
  4. Build features we could confidently defend in a finals Q&A, not just visually demo.

That matters for Usaid because the product only works if both the user experience and the reasoning behind the system are coherent.

Challenges we ran into

  1. Keeping timelines plausible: It is easy for a generative model to produce dramatic but unrealistic futures. We had to push the system toward balanced, structured, and plausible outputs instead of generic motivational text.

  2. Turning AI output into product data: Free-form text is hard to use in an interface. We solved this by asking for structured JSON with consistent fields for metrics, events, trade-offs, and second-order effects.

  3. Making branching feel meaningful: The follow-up decision flow needed to feel like a real extension of the original path, not just a fresh unrelated generation.

  4. Designing for comprehension: Since the app shows uncertainty, probabilities, and multiple paths at once, the interface had to stay readable even when the underlying idea is complex.

Accomplishments that make us proud

  1. A clear product concept: Usaid takes a complex idea, future simulation for personal decisions, and turns it into something interactive and understandable.

  2. Structured AI integration: We moved beyond chatbot-style responses and built a system that generates renderable, comparable, multi-path futures.

  3. Branching decision workflow: Users are not limited to a one-shot answer. They can explore "what if" scenarios by injecting new decisions and generating new branches.

  4. A defendable architecture: This is not just a flashy UI. We can explain how the prompt works, how data is persisted, why timelines are structured the way they are, and how each layer connects.

What we learned

  1. Good AI products need structure, not just a strong model. The quality of the experience depends heavily on prompt design, response contracts, and how well the output maps to product behavior.

  2. Context improves usefulness. Risk tolerance, priorities, and previous decisions make the generated futures much more relevant than a one-line prompt alone.

  3. Explainability is a competitive advantage. Building with Contral IDE pushed us to understand every layer more clearly, which improved both development speed and confidence in the final product.

What's next for Usaid

  1. Reality feedback loop: We already have groundwork for capturing actual outcomes. The next step is using that feedback to evaluate and improve future simulations.

  2. Richer timeline evaluation: We want stronger scoring, clearer confidence signals, and better comparison tools across paths.

  3. Advisor-style simulation layers: Future versions could include specialized perspectives such as career, financial, or risk-focused analysis on top of the timeline engine.

  4. Broader use cases: The same system could be extended beyond personal decisions into startup planning, research direction, and team strategy scenarios.

Built With

Share this project:

Updates