Blocktopia

Blocktopia World
Create Task and Add Options
User Twin Profiles and Journal
Simulation Events happen in task area

Inspiration

When making high-stakes decisions—like choosing an apartment, deciding whether to adopt a pet, or buying furniture—people often have to imagine an entire future life from an empty room or a blank state: sunlight, flow, commute stress, noise, neighborhood convenience, and even emotional experience. This process relies heavily on mental simulation, but it’s hard to externalize and compare—or revisit later. Blocktopia is inspired by the idea of turning that “imagined life” into a visual, traceable comparison of options—so decisions feel clearer and more confident.

What it does

Build your digital twin by capturing your preferences, hard constraints, and weights through a brief self-intro and calibration chat.
Create decision tasks: enter a task prompt, add options and basic details, and let the system automatically RAG and enrich each option into an evidence pack.
Normalize your preferences and evidence into a unified JSON schema, then compile everything into a WorldGraph that forms your Blocktopia “town.”
Run scenario/event simulations (global or local random events) to stress-test options and compare how they perform across different real-life situations—so you can decide with more confidence.

How we built it

Blocktopia is built around one thread: structured data + traceable evidence + playful presentation.
On the frontend, I relied heavily on Google AI Studio to rapidly prototype the interaction. On the backend, I iterated through “vibe coding” and split the system into two major modules:

WorldGraph Compiler: merges user input with evidence and compiles it into a world structure that can be rendered and simulated.
1.1 User Twin: based on the user’s self-introduction and calibration chat, the model extracts preferences, constraints, and weights into a strictly constrained JSON format.
1.2 Option Evidence Pack: after the user provides options (e.g., an apartment listing URL), the system retrieves and enriches evidence from public data—such as safety/crime, neighborhood coverage and convenience, noise, walkability, and commute—and outputs everything in a unified JSON schema. This evidence pack is then combined with the User Twin and fed into the compiler to power simulation and define event “thresholds.”
Event ↔ Option Simulator: triggers global and local random events on top of that world structure, creating differentiated experiences and outcomes across options.

Challenges we ran into

The biggest challenge was building a system that could reliably collaborate with itself from scratch. This wasn’t just about plugging in a Gemini API—it meant continuously resolving boundaries between modules, enforcing data contracts, and maintaining traceability and consistency: what the model is allowed to infer vs. what must be backed by evidence; how to prevent different stages from contaminating each other; and how to keep the frontend, retrieval, and compilation layers aligned under one stable schema. Due to time constraints, I haven’t completed the full end-to-end loop yet, but the process helped me build the core skeleton from zero and define a clear next path: make the workflow more automated, more robust, and more reusable.

Accomplishments that we're proud of

This is an experimental attempt. I want AI’s value to go beyond “answering questions on a screen” and instead integrate into real life in a richer, more tangible way—acting as an augmentation layer when people make high-stakes decisions.
From a design perspective, data-driven decision tools usually take one of two forms: dashboards (progress bars, charts, KPI cards) or pure conversational interfaces (completing tasks through chat). Both can be efficient, but they can also make users feel like they’re being led by the system. How the data was obtained, what steps the system took, what just happened, and what the user actually did—these often get flattened into a single output or a short answer.
In Blocktopia, the core problem I wanted to address is this “black box” feeling. Instead of building a dashboard with a chat side panel, I placed the decision process inside an immersive 2.5D map: options become walk-up, comparable “tiles/buildings,” evidence and tradeoffs can be expanded in context, and simulated events visibly change outcomes on the map. This way, users keep a sense of control while also understanding what the AI is doing, why it’s doing it, and how their choices shape the result.

What we learned

As a designer with no coding background, this project helped me build an end-to-end understanding of a product-grade technical pipeline: how to break a system into maintainable modules, synchronize data across components with a structured JSON contract, and define the role of a large language model at different stages (extraction, enrichment, compilation, simulation). I also learned how implementation details can directly shape the user experience—from small front-end interaction issues (e.g., hover states interfering with button clicks) to higher-level prompt design that makes the model clearly understand its current role and output contract.

What's next for Blocktopia

Due to limited time, I haven’t fully wired the Evidence Pack → WorldGraph pipeline yet. Next, I want to complete this integration end-to-end so evidence reliably powers the compiled world and option tiles.
Controllable randomness for simulation: upgrade global/local events from purely random occurrences to triggers driven by evidence and thresholds, and generate clear event explanations (why it fired, which metrics it affected) so simulation feels like stress-testing, not a lottery.
Long-term vision: the Twin profile should be learnable and evolving—adapting over time as the user completes more tasks and decisions, gradually capturing their decision patterns and shifting priorities.