Inspiration

Solving LeetCode problems alone is a different skill from solving them in a real interview. The hard part is explaining your thinking out loud while you code, and existing practice tools do not train that. Chatting with a general-purpose LLM falls short too: it cannot see your editor, it answers every pause, and it praises whatever you say. We wanted an interviewer that listens, watches the code, knows when to stay quiet, and asks the follow-up a real interviewer would ask.

What it does

The candidate picks a problem, a session length, and a mode (Interview or Coach), then talks through the solution in a live Python editor. Tommy, the AI interviewer, hears the candidate and reads the code at the same time, so its questions are grounded in both, such as asking why a check comes before a store on a specific line.

At the end, the candidate gets a report with:

  • Scores from 1 to 4 on correctness, edge cases, complexity, and clarity of reasoning, each backed by a quote of what they actually said or wrote
  • A "said vs. did" check for claims the code contradicts
  • A scrubbable replay where code, transcript, and audio move together
  • A redo option for any moment they failed to explain

How we built it

  • Frontend: Next.js (App Router, TypeScript) and React, with Monaco as the editor and Pyodide running the candidate's Python in the browser.
  • Speech: Deepgram Flux streaming for speech-to-text and end-of-turn detection. The browser connects directly using short-lived tokens minted by our server. ElevenLabs streaming TTS gives the interviewer its voice.
  • Reasoning: An OpenAI-compatible LLM in JSON mode. A fast model drives the live conversation, and a stronger model writes the report.
  • Decision ledger: On every call, the model returns each design decision visible in the code, with the exact line and whether the candidate explained why. The browser sends the ledger back on the next call. Probes may only target unexplained decisions, and the ledger is the backbone of the report.
  • Stateless server: The browser holds all session state and sends it on every request, so API keys stay on the server and no database is needed.

Challenges we ran into

  • Turn-taking. Telling when the candidate has finished speaking versus when they are pausing mid-thought. We combined Deepgram's turn detection with a model-side classification of the latest speech.
  • Barge-in. Letting the candidate interrupt without the interviewer transcribing its own voice. A loudness signal pauses the line almost instantly, and real recognized words confirm the cut. We track how much of the line was actually heard, so the model knows what went unsaid.
  • Latency. Turn-based pipelines feel slow. Streaming voice playback, short backchannels, and brief thinking sounds made the conversation feel live without making speculative model calls.
  • Grounding. Models paraphrase or invent quotes. We check every quote in the report against the transcript and the code, and the report labels unverified ones.
  • Stale replies. A reply computed before the candidate's latest words or code changes is often wrong. Any such reply is dropped, and a fresh consult runs instead.

What we learned

  • Guard rails belong in code, not prompts. Cooldowns, follow-up limits, and dropping stale probes were far more reliable as browser logic than as instructions to the mod
  • Describe the shape of a good reply, never example sentences. The model copied every template we wrote, so every probe started to sound the same.
  • Perceived latency matters as much as real latency. Small audio cues changed how human the interviewer felt more than any model change did.
  • Tight scope pays off. One language, three problems, and Chrome only let two developers ship a polished end-to-end experience in a weekend.

Built With

Share this project:

Updates

Submission history