AI Interviewer Becomes a Tutor: How N.O.V.A. Replaces Grinding with a Teaching Loop

Most interview prep tools compete on question bank size and answer speed, but the developer-built N.O.V.A. asks a different question: what if the tool's core isn't "answer more questions correctly," but helping users understand where they went wrong? Built on Next.js and NVIDIA model services, this project turns the AI interviewer into a learning system that probes, explains, and tracks weaknesses.

From Assessment to Teaching: A Six-Step Learning Loop

N.O.V.A.'s flow isn't a two-step "ask a question—score it" process, but six stages: generate questions based on the candidate's level, evaluate across four dimensions (accuracy/clarity/completeness/reasoning), adaptively probe with follow-ups, explain concepts when stuck, track weaknesses and misconceptions, and finally generate a personalized prep plan.

The "I don't know" mode is the most interesting design element. When a candidate admits they don't know, the system doesn't skip ahead—it records the attempt as a 0 score (counted toward mastery of that topic), then a teacher agent outputs a structured lesson: a plain-language explanation, technical details, real-world examples, optional diagrams (layered/flow/sequence), a concise answer usable in an interview, common mistakes, and follow-up questions. Users can then retry the original question, move on to the next one, or switch to a similar question.

This lesson is saved to notes, while missed questions go into the "error notebook" for spaced repetition review on a 1→2→4→7→15→30 day schedule. This design turns "don't know" from a failure into a learning event with a review cadence, rather than a one-time consumption.

Engineering Trade-offs: Multi-Agent, Latency, and Graceful Degradation

Architecturally, N.O.V.A. uses Next.js (App Router, React 19, Tailwind) with SQLite—built-in node:sqlite locally, and an embedded Turso replica in the cloud, so hosts with ephemeral disks don't lose data. Models go through NVIDIA's OpenAI-compatible API, with keys stored encrypted and never sent to the browser.

On prompt design, the author deliberately avoids "one giant prompt playing the interviewer," instead making each role its own agent: interviewer, question generator, answer evaluator, teacher, coding interviewer, code reviewer, system design evaluator, hiring committee, and so on. Each agent returns strict JSON, making outputs testable and tunable in isolation without affecting other stages.

Latency is the biggest UX pain point. Reasoning models sometimes take 20–70 seconds and truncate JSON. The author's approaches include: offering a "fast mode" that lowers thinking effort (e.g., reasoning_effort: low, or disabling thinking on Nemotron 3), which by their testing returns in about 3 seconds on Nemotron 3 Super via NVIDIA's hosted API; only the interviewer's reply sits between the answer and the next question, with scoring run in the background and the next question pre-generated while the user answers; and if the first question takes over 12 seconds or the JSON is invalid, falling back to a human-curated question bank with keyword-coverage scoring, with reports labeling the source. Even with AI turned off, the app runs end to end.

Code execution security is also isolated: Python runs via Pyodide in a Web Worker with a time limit, SQL runs on SQLite compiled to WebAssembly, and reference solutions stay on the server until the user solves the problem.

Exponential Moving Average (EMA) is used in the article to update mastery: after each answer, new mastery = α × this score + (1-α) × old mastery, with α typically 0.2–0.4, giving recent performance more weight and smoothing the curve. Compared to a simple average, EMA reflects progress or regression quickly, but can also lag due to a single anomalous fluctuation, so it's often paired with a minimum-attempt threshold before being shown externally.

Turso embedded replica is a mechanism for syncing a cloud SQLite database to the app locally: local reads and writes go through the embedded replica, which then syncs with the primary database in the background, avoiding data loss on hosts with ephemeral disks while retaining SQLite's lightweight nature.

Pyodide + Web Worker refers to running CPython compiled to WebAssembly inside the browser; Web Workers provide a separate thread to avoid blocking the UI, and setTimeout or terminate() can implement time-limited interruption, making it suitable for isolating untrusted code.

The Unresolved Problem: Is the Feedback Actually Effective?

The author admits that the truly hard part isn't generating feedback, but judging whether the feedback is useful. Currently they only look at whether mastery of a topic rises after an "I don't know" lesson plus subsequent retries, but rigorous evaluation methods are lacking. Mastery is updated with an exponential moving average, weighting recent performance more heavily; weaknesses drive the daily plan, and the readiness score is recalculated after each session—this machinery runs, but it's still far from "proving learning is effective."

This is also a common challenge for teaching-oriented AI tools of this kind: short-term metrics (retry accuracy, mastery curves) are easy to make look good, but long-term transfer effects are hard to attribute. The author openly solicits evaluation ideas from developers and educators, and the project is accessible online. For anyone building AI learning products, N.O.V.A.'s value may not lie in its feature list, but in how it lays out engineering details like "graceful degradation," "structured output," and "error review cadence" for open discussion.

Spaced Repetition is based on the Ebbinghaus forgetting curve, scheduling reviews when memory is about to decay; the 1→2→4→7→15→30 day intervals in the article are a common simplified sequence. Its effectiveness depends on "difficulty adaptation": lengthen intervals when correct, shorten them when wrong, otherwise the cadence easily becomes rigid.

Learning Transfer refers to the ability to apply knowledge learned in a training context to new contexts. Short-term retry accuracy gains may just mean memorizing the original answer rather than mastering the concept, so evaluating teaching-oriented AI requires designing unseen new questions or real tasks to test transfer—this is precisely the root of what the author calls "long-term transfer effects being hard to attribute."

One-line Summary

N.O.V.A. uses multi-agent architecture to transform the AI interviewer into a six-step teaching system that probes, explains, and reviews weaknesses.

Paragraph Summary

N.O.V.A. is an AI interview prep project built on Next.js and NVIDIA model services, whose core isn't question quantity but helping users understand where they went wrong. It designs the flow as a six-step teaching loop: level-based questions, four-dimension evaluation, adaptive probing, structured lessons when stuck, weakness tracking, and a personalized prep plan. The "I don't know" mode records unknown questions as 0 and generates a lesson, with missed questions entering an error notebook reviewed on a 1→2→4→7→15→30 day spaced repetition schedule. Engineering-wise it uses multi-agent architecture with strict JSON output, addressing reasoning-model latency and JSON truncation via fast mode, background scoring, question pre-generation, and a 12-second timeout fallback to a question bank, with code and SQL exercises isolated in the browser. The author candidly admits the evaluation challenge of whether feedback is truly effective remains unsolved.