ReRun

• 

  Home Screen Show Selection after the TV is turned on

• 

  Warm Up Question

• 

  TV Show

• 

  Mid Show Quiz, Testing active recall

• 

  Generate Your Own Show

Inspiration

Students already turn their notes into "brainrot" videos and AI study podcasts — then passively watch them. And passive AI help measurably damages learning. In a ~1,000-student randomized controlled trial (Bastani et al., PNAS 2025), unrestricted GPT-4 access raised assisted practice scores by 48% — while unassisted exam scores fell 17% below the no-AI control. Follow-up RCTs (Liu et al., 2026, N=1,222) find AI assistance also reduces persistence on later unassisted work. Students feel productive; durable learning goes down.

The same PNAS study points at the fix: the harm disappeared when the AI was constrained to guide instead of answer. ReRun takes that finding to its logical end — an AI format where the learner is the one who has to answer. Learning science backs the mechanic: retrieval practice beats passive review for long-term memory, and a corrective follow-up after a miss is where the gain compounds.

Nobody had built the format for that. Flashcards, study podcasts, and gamified quizzes all treat retrieval as an activity you can skip, skim, or abandon. ReRun inverts the architecture: retrieval is the gate, not the activity — the episode structurally cannot advance until you answer, and a miss doesn't reveal the answer, it branches the story into a re-teach. That's a format constraint, the way a crossword's constraint is the grid. Kids' television solved attention fifty years ago — appointment viewing, a host, a cliffhanger before every break. We took that format and made the cliffhanger a question. ReRun is appointment television for your homework: a show you cannot passively consume, because answering is the only way forward.

What it does

ReRun turns notes into an interactive retro-TV episode built on one loop: teach before you ask, pause for retrieval, adapt a retry after a miss.

• Bring your own material to create your shows. Paste notes or drop text, PDF, DOCX, PPTX, CSV, photos, audio, or video. GPT-5.6 writes a complete episode as Zod-validated structured output — teaching beats, retrieval checks, and the corrective retry branch for every concept — behind an originality and moderation guardrail. gpt-image-2 streams original per-scene art onto the Stand By card; gpt-4o-mini-tts voices the host.
• Five original, fully voiced pilots ship in the box (biology, cells, circuits, Newton's laws, the water cycle) on channels CH 04–08 — playable offline, with no API key and no network call. Judges can experience the complete loop in under two minutes.
• The miss is the mechanic. A wrong answer triggers Rewind & retry: the show re-teaches the concept with a different authored analogy, then serves a simpler question. A second miss reveals the answer and moves on. No red X, no failure state — a corrective branch, on the aired path of every episode.
• A real television, not a themed quiz. The remote's pause/play, rewind, fast-forward, AUTO, captions, mute, and ratings buttons all drive real player state. CRT boot, static, channel guide, "Please Stand By" — all functional UI, not decoration.
• Keep the episode. Generated shows persist for seven days and export to MP4 (in-browser capture + server-side ffmpeg conversion, with a safe WebM fallback).

Why the format is the fix

The research above names three specific ways AI study help fails. Each one maps to a ReRun mechanic — and every mechanic is architectural, enforced by the player and the schema, not a prompt the model is merely asked to follow.

1. Failure: passive consumption feels like studying. Study podcasts and note-to-video tools convert notes into something you watch — assisted practice feels productive while unassisted performance drops. ReRun's answer: retrieval is the gate. The episode has no path forward except an answer. You cannot scrub past a question, and even AUTO mode stops at one. Watching ReRun is retrieval practice, because watching alone is structurally impossible.
2. Failure: the AI hands over answers, so the student never retrieves. The PNAS harm (−17% on unassisted exams) came from unrestricted answers, and it disappeared when the AI was constrained to guide instead. But a chat tutor's "guide, don't answer" constraint lives in a system prompt a student can talk their way around. ReRun's answer: a first miss cannot produce the answer — the interface has no such affordance. It airs a corrective scene that re-explains the concept with a materially different analogy (a difference enforced at schema-validation time, not suggested in a prompt) and then asks a simpler question. The answer is revealed only after a second attempt, and only after re-instruction.
3. Failure: AI assistance erodes persistence on later unassisted work. ReRun's answer: a miss is a plot beat, not a failure state. The retry branch sits on the aired path of every episode — no red X, no score penalty, no dead end — and because every concept must carry 3–5 typed teach steps before its first question (a schema requirement), every question is answerable from what the show just taught. The learner keeps answering because the show keeps making answering possible.

Placed next to the formats it will be compared to:

The difference is not polish. Every adjacent format lets the learner opt out of the one activity that produces durable memory; ReRun makes opting out impossible while making staying in feel like television.

How we built it

We pair-programmed with Codex end to end for one week, and kept a human-reviewed audit trail in CODEX_LOG.md — every milestone, what Codex contributed, and how it was verified.

How Codex accelerated our workflow

Codex let us move from a written product contract to a runnable, judgeable learning loop on the first build day — without treating generated code as unreviewed output. We gave it concrete contracts (the player flow, EpisodeSpec, scene-authoring rules, and test plan), used it to implement each bounded subsystem, then reviewed the behavior and recorded the verification before advancing. That accelerated three parts of the work in particular:

• From design to an integrated vertical slice. Codex turned the P0 contracts into the interactive player, fixture, branching engine, remote controls, responsive UI, and validation layer in one integrated pass, so we could test the complete wrong-answer → re-teach → retry loop early rather than assemble disconnected screens.
• Fast, evidence-backed iteration. When the CRT framing and viewport failed on real desktop and phone checks, Codex helped carry out three focused rework passes while typecheck, tests, production builds, and browser verification remained part of every milestone. The work log preserves the decisions, artifacts, and outcomes instead of relying on a vague claim that AI “built the app.”
• Making the judge path resilient. After we decided that a demo requiring an API key was unacceptable, Codex implemented the offline catalog, deterministic option shuffle, audio manifest, and media fallbacks around the bundled originals. That transformed a live-AI prototype into a complete no-key experience judges can actually run.
• Codex built the working, non-trivial core: the Next.js 15 / React 19 CRT player (~1,200-line state machine: shots, takeovers, branch reactions, reduced-motion support), the 600-line Zod EpisodeSpec schema that every episode — authored or generated — must validate against, the branching beat engine, and five API routes (episode generation, multi-format ingestion, streaming scene art, TTS, video export).
• GPT-5.6 (Responses API, structured outputs) authors live episodes against that schema, so a generated show is guaranteed to contain teach-before-ask steps and a retry branch — the pedagogy is enforced by types, not vibes.
• We made the product calls; Codex executed them. The decisive one: bundle all 46 MB of original media — 268 narration MP3s and 32 art plates — into the repo so the full experience needs zero keys. Codex then built the deterministic option shuffle, the audio manifest, and the offline catalog around that decision.
• 25 tests across 5 suites (fixtures, audio catalog, media routes, theming/art fallbacks, video export) plus typecheck and production build gate every change.

Challenges we ran into

• Making generation never block playback. Art, narration, or even the model itself can fail; every media call has an authored fallback (scene-type art treatments, bundled audio, WebM-instead-of-MP4), so the show always airs.
• Teaching a language model to teach. Early GPT-5.6 episodes quizzed without teaching. We iterated the schema and system prompt with Codex until every concept carries 3–5 typed teach steps (hook, define, analogy, example, contrast, recap) before its first question — and retries must use a materially different explanation, enforced at validation time.
• A CRT that respects real art. Getting uncropped 16:9 scene plates, a 2.5D camera, and a phone-safe tube frame to coexist took three logged rework passes.

Accomplishments that we're proud of

• A complete, coherent product experience — not a proof of concept: power on, pick a channel, learn, miss, rewind, retry, finish, and export — every step demonstrated and runnable.
• The judge path works with zero setup: npm install && npm run dev, no .env.
• Every piece of media is original and classroom-safe — original hosts, original shows, an explicit no-imitation guardrail in every image prompt.

What we learned

Codex is at its best when you give it a contract, not a wish. Writing the EpisodeSpec schema and the scene-authoring rules first turned Codex into a reliable implementer of a designed system — and turned GPT-5.6 into a reliable author inside it.

What's next for ReRun

Season two: spaced re-airing of missed concepts ("reruns" of your weakest scenes — the name was always the roadmap), classroom channel lineups for teachers, and shareable episode links. And the study this format is asking for: a small classroom pilot measuring retention against passive-review baselines, using the same retrieval checks the episodes already contain.

Built With

• codex
• gpt-4o-mini-tts
• gpt-5.6
• gpt-image-2
• next.js
• react
• typescript
• vitest