Inspiration
AI tutors are confidently wrong in a way that's uniquely damaging to a learner. A student can't tell a correct explanation from a merely fluent one — that's the whole reason they're learning. So when an AI walks you through an algorithm and quietly describes something the code doesn't actually do, it isn't a small error: it teaches something false to the one person who has no way to check.
I wanted a tutor whose visuals were physically incapable of disagre
What it does
Give Forever any source material — a textbook chapter, lecture notend it builds a complete multi-scene course:
- a board that gets drawn as the tutor talks
- a tutor voice that explains it line by line
- real code that actually runs, in a sandbox
- questions that check whether you understood
What makes it different is what it refuses to do. Every visual walkthrough is derived from a real recorded execution of real code, never from a model's guess about what the code probably does. Every factual claim on the boardk it came from. Teaching that fails those checks is dropped ratherthan shipped weak.
How I built it
Next.js and Node on Alibaba Cloud ECS, with Qwen models through Alibaba Model Studio behind a single client. Course builds run as background jobs on BullMQ + Redis, so the browser never waits — the player opens ied scene extends what's watchable.
The core is a society of specialised agents that argue with each ottic validators they cannot talk their way past:
Teacher plans the lesson arc from your source Board Director designs what appears on screen Grounding Auditor objects to any claim the source doesn't support Pedagogy Critic objects to teaching that won't land Arbiter rules on the objections, bindingly Code Runner writes and EXECUTES real code in a sandbox Execution Tracer records what actually happened, step by step Voice Writer narrates the board and declares its teaching moves
The visual engine instruments a real Python execution and compiles that recording into animation. It enforces hard invariants and throws rather than narrate from evidence it can't back: the order shown must equal the recorded orded only at its recorded discovery, an edge may only light up if itexists in the recording, and dependency arrows come only from reads that actually happened.
Challenges I ran into
The hardest problems weren't AI problems. Six configuration and error-handling faults stacked up, and each one looked like total product failure on its own:
- the app was reading an empty database while the real one sat untouched
- the queue worker wasn't running, so submitted courses waited
- a fast-but-shallow model was writing the teaching narration
- the retry logic **didn't recognise the two most common network ertried
- and the worst one: a dead text-to-speech vendor was deleting finished lessons, because voicing ran inside scene generation, so a scene that couldn't be spoken was thrown away — even though it had already passed every
Finding that last one meant learning to test the real production pant one.
Accomplishments that I'm proud of
- 103 algorithms visualised with zero per-problem code — nondividual algorithm — at 0 errors
- 957 automated tests
- Deterministic gates that catch bad teaching instead of trusting tejects a "definition" that never actually defines anything; anothercatches a scene describing the picture instead of the material
What I learned
That honest failure is a feature. It's tempting to build a demo that always produces something; it's far more useful to build one that refuses when it can't verify.
And that a system is only as good as the path you actually test. Fonient code path while the real one was failing for reasons my testsstructurally could not see.
What's next for Forever
- Path-reconstruction visuals for dynamic programming
- A JavaScript execution recorder, so JS gets the same verified tre
- Wiring the mastery model into adaptive practice, so the tutor picks your next question from what you actually haven't learned
A note on scope
Forever is an ongoing open-source project, and its commit history is public. During this event I worked on the correctness engine and the reliability of the generation pipeline — including the execution-verification invarianvalidators, and the six fixes described above.
Log in or sign up for Devpost to join the conversation.