Inspiration
SchoolSims handed us a prompt about leadership under pressure: a promising opportunity, a tight four-week deadline, and a development team whose capacity is already spoken for. As hackathon participants running on caffeine and competing commits, we found the premise suspiciously relatable.
Going into the build, we kept circling a set of deeper questions: how do we use AI to represent cultures and languages that aren't all our own without it feeling like a caricature? And to what extent can we modularize an experience for efficiency without stripping away human nuance?
We wanted to build a simulation where learners could step into that leadership dilemma while choosing the language and character they experienced it through. In iClass, changing who appears on screen or what language they speak doesn't alter the substance of the problem. Representation should shape how someone enters the room—not dictate a character's competence or the consequences of a decision.
That became our central rule: different presentations, the exact same meaningful friction.
What it does
Our prototype—iClass (a play on classic Cupertino branding that pivots to Interactive Class)—walks learners through a high-stakes leadership scenario. A partner college demands a new feature delivered in four weeks before signing a contract, while the engineering team is already at capacity. The learner has to choose between committing to the aggressive deadline or proposing a phased pilot, watching the downstream trade-offs play out in real time, and reflecting on the outcome.
Before jumping in, learners select a language, a character category, and a gender. The platform dynamically loads the matching portraits and video assets. Right now, our integrated build supports 59 verified combinations across seven languages (32 men's and 27 women's options), strictly filtering the UI so users are only offered combinations backed by complete media.
At the end of a run, participants can leave star ratings and written feedback—automatically tagged with their session configuration—or flag concerns regarding how race or language was represented. Because AI voices can easily miss human context, giving participants a direct line to report cultural or linguistic friction is essential. We also integrated optional ElevenLabs audio narration that cleanly disconnects when toggled off to save tokens, though live narration and mid-slide playback still need a bit more battle-testing.
How we built it
We built on top of a React and TypeScript frontend paired with a Python FastAPI backend. Because the scenario logic and branching choices live in structured JSON while the player simply renders the state, we were able to scale out character and language selection without rewriting the core narrative engine.
Expanding gender representation started with a full audit of our supplied video assets. We added women's media across African, Latin, and South Asian character options, alongside a dedicated Hijab character option. Earlier on, we realized that trying to generate a matching headshot first and working backward to the video caused visual mismatches—so we flipped the workflow and extracted the cast-panel portraits directly from the generated videos so the colleague introducing the scenario actually matched the person on screen. Existing men's asset paths stayed completely untouched.
On the backend, we extended the API rather than breaking its existing contract. Requests that omit a gender parameter gracefully default to the original men's behavior, and the review schema gained an optional gender field without invalidating older records. We also forced explicit UTF-8 handling across our multilingual JSON pipelines so Windows and Mac machines would finally agree on what the text actually said.
Our team essentially operated as four teammates: three humans working across Windows and Mac, plus an amorphous, multi-personality bot (switching between Codex and Claude to inspect, implement, and debug). Because neither AI assistant could inherit context by telepathy—despite how convenient that would have been—our single source of truth had to be readable, modular code, a strict API contract, and verifiable test results.
Challenges we ran into
Our first hurdle was figuring out which version of our own project we actually had. Between missing features from earlier checkouts, placeholder media, and local environment quirks, "it works on my machine" quickly required a follow-up question: which machine, and on which commit?
As the build progressed, our teammate's review and branding updates collided with our gender-expansion work. Rather than just persuading Git to stop showing conflict markers and hoping for the best, we merged both histories onto an isolated integration branch—keeping main clean while we manually verified that both feature sets actually behaved together.
Then came the ethnicity dropdown. It animated beautifully. It also displayed approximately zero useful options.
On smaller viewports, conflicting CSS positioning rules collapsed the upward-opening menu into oblivion. Our earlier automated checks completely missed it because triggering a click in code is not the same thing as a human eyeball actually seeing the button on screen. We untangled the positioning logic and added real pointer checks across five viewport sizes until the dropdown finally accepted that visibility was part of its job description.
Accomplishments we are proud of
We successfully merged the expanded gender representation, multilingual support, and participant review system without breaking the scenario's decision tree or our existing codebase architecture.
Rather than trusting a green build light, we verified all 59 portrait-and-video combinations, backward-compatible API calls, multilingual review storage, and full user journeys across both narrative outcomes. We also hardened the feedback flow: if a review submission fails, the user's written text stays intact for a retry instead of vanishing behind an undeserved success message.
To keep our automated tests fast and free, we wired up temporary review storage and stubbed out the ElevenLabs service so we could run full verification suites without polluting real feedback data or burning paid audio tokens. We even packaged the integrated build into a self-contained Git bundle so it can be spun up cleanly in a separate directory.
What we learned
A passing build is a great starting line and a terrible finish line. A compiler won't tell you if a video is a placeholder, if the wrong character loaded, or if a dropdown menu has quietly migrated outside the visible universe.
We learned to tie every claim to concrete evidence: inspect the file paths, hit the API, load the actual media, and click through the real interface. We also saw firsthand how much small architectural discipline matters—an optional schema field, a preserved filename, or an explicit UTF-8 flag can save a teammate hours of late-night confusion.
Most of all, we learned how to ship meaningful features without treating every new idea as an excuse to tear down the foundation.
What's next for iClass
Immediate next steps include auditing our caption tracks, verifying live ElevenLabs narration, smoothing out mid-slide muting, and testing natively across macOS and Safari. While our local JSON store works well for a hackathon prototype, deploying at scale will require migrating reviews to a dedicated database.
We're currently locking in our Windows environment as the primary demo rig and preparing to publish the integrated branch as a standalone release.
SchoolSims asks learners to balance ambition, team capacity, and trust. Building iClass gave us a real-time crash course in all three—plus an unscheduled bonus lecture on CSS positioning that definitely wasn't in the syllabus.
Built With
- elevenlabs
- fastapi
- gemini
- react
- typescript