InterviewForge

An adaptive AI mock interview coach that turns any job description into a personalized technical interview, where every answer you give shapes the next question you face.

Comment

Inspiration

Most interview prep tools give you a static question bank. You grind LeetCode. You read FAANG blog posts. You memorize answers.

Then you walk into a real interview, where the interviewer listens to your answer, probes your weaknesses, and adjusts in real time; and nothing feels the same.

Static prep doesn't simulate dynamic interviews.

InterviewForge was built around one core insight: every answer you give should change the next question you face. That's how real interviews work. That's what we built.

What it does

InterviewForge turns any job description into a fully personalized adaptive mock interview experience.

  • Paste a job description - the app analyzes it and extracts the top 5 interview domains with importance scores and role-specific preparation guidance

  • Choose your interviewer - practice with a Friendly Mentor, a professional Google Recruiter, or a brutal Amazon Bar Raiser. Each mode changes tone, follow-up behavior, and feedback language noticeably

  • Start your adaptive interview - 8 questions distributed across your domains. After every answer, a live Adaptation Panel shows your score, rating, and exactly why the next question got harder, stayed the same, or pulled back

  • Speak your answers - voice input via the Web Speech API lets you answer out loud, simulating a real interview environment instead of typing responses

  • Review your session - an Adaptive Path Timeline visualizes your full difficulty curve. A personalized 48-hour study plan targets your weakest areas

  • Track improvement - past sessions are saved locally so you can see your score trend over time

How we built it

InterviewForge was built entirely using MeDo through structured, iterative multi-turn conversations.

The build followed a deliberate stage-by-stage prompting strategy:

  • Stage 1: JD parsing and domain extraction with importance scoring
  • Stage 2: Adaptive interview loop with transparent scoring logic and visible adaptation reasoning
  • Stage 3: Session summary with Adaptive Path Timeline and difficulty line graph
  • Stage 4: Interviewer personality modes with mode-specific AI behavior
  • Stage 5: Voice input via Web Speech API for realistic interview simulation
  • Stage 6: Polish - typing animations, color coding, smooth transitions, mobile responsiveness

Rather than prompting MeDo to "build an interview app," each stage was structured with explicit data schemas, adaptation rules, and acceptance criteria, keeping the output focused and consistent across every iteration.

Challenges we ran into

Scoring leniency. Early versions graded answers too generously; elaborate but vague responses were scoring in the 60s when they deserved below 50. The fix required explicit rubrics with a strict rule: correctness and relevance only, never length or confidence of language.

Question repetition. When difficulty dropped repeatedly, the app recycled earlier questions. Solving this required explicit session-wide question tracking and dynamic generation with randomized angle variations — ensuring no two sessions feel identical even with the same JD.

Adaptation visibility. Making the adaptive engine transparent, not just functional, was the key design challenge. The Adaptation Panel needed to show users exactly why each question changed, turning a hidden AI decision into a visible, understandable learning moment.

Accomplishments that we're proud of

  • A genuinely adaptive interview engine where difficulty responds to every single answer in real time
  • The Adaptive Path Timeline — a visual proof that the interview was truly adaptive, not random
  • Three distinct interviewer personalities that change AI behavior noticeably, not just cosmetically
  • Voice input that makes practice feel like a real interview
  • High question variance across sessions — the same JD produces meaningfully different interviews every time
  • A complete, polished, deployable app built entirely through MeDo conversations

What we learned

Prompt structure is software architecture.

The quality of the final application was directly proportional to how precisely each prompt defined its inputs, outputs, and edge cases. Vague prompts produced vague features. Explicit prompts — with schemas, rules, and boundary conditions — produced features that worked.

The most important prompting insight: show the AI what the data should look like. Providing a JSON schema for the Adaptation Panel produced a consistent, structured output every time. Describing it in words alone did not.

MeDo handled the implementation. The real work was product thinking — knowing what to build, in what order, and how to define done.

What's next for InterviewForge

  • Cloud sync for session history across devices
  • Full audio playback of AI questions for end-to-end voice interview simulation
  • Peer benchmarking — compare your scores against others practicing the same role
  • Calendar integration to schedule the generated study plan
  • Company-specific question packs for FAANG, startups, and specific engineering disciplines

Built With

Share this project:

Updates