EurekaAI

Flashcards
Quiz
Feynman Explainer
Feynman Score
Landing Page
Dashboard
Socratic Solver
Mistake Journal with Diagnostic

Inspiration

I've been a JEE aspirant. I know exactly what the study loop looks like: watch a video, read the solution, feel like you understand it, sit down in the exam, and not be able to solve that very same question.

The problem isn't effort. Most serious aspirants put in solid hours of study per day. The problem is how they study. Passive consumption of solutions, copying steps and highlighting notes creates the illusion of understanding without actually absorbing it. Recognition feels like knowledge until the exam proves otherwise.

The research on this is unambiguous. Bloom's 2-Sigma Problem (1984) showed that students tutored one-on-one perform two standard deviations better than those in conventional classrooms. The Learning Pyramid puts retention from reading at 10% and retention from teaching at 90%. Karpicke & Roediger (2008) demonstrated that active retrieval beats passive re-reading by 2.4x. Every serious learning researcher points to the same conclusion: you have to be forced to generate the answer yourself.

No existing platform does this. Khan Academy, BYJU'S, Doubtnut all show the solution. ChatGPT gives you the answer instantly. Anki tests recall but doesn't build problem-solving depth. There is no tool that sits between you and the answer and refuses to move until you've genuinely tried.

That gap is what EurekaAI is built to fill.

What it does

EurekaAI is an anti-cheat, active-learning AI tutor that refuses to give students the answer. Instead of handing out solutions on demand, it uses four research-backed tools to force genuine understanding:

Socratic Solver — Upload any problem and EurekaAI responds with targeted questions, not solutions. Hints escalate only after 3 stuck turns. Hard problems automatically route to a deeper reasoning model. The AI is explicitly prompted to delay answers and track where your reasoning breaks down, session by session.

Feynman Explainer — Explain a concept in your own words (text or voice). EurekaAI returns a structured 0–100 score, identifies the exact gaps in your reasoning, and fires a sharp follow-up question to address them. The scoring pipeline outputs structured JSON (score + specific gaps + targeted follow-up), which is a novel implementation with no direct equivalent in existing ed-tech.

Focus Mode — A full distraction-free study environment: PDF rendered on canvas with a custom page range selector, drag-to-highlight, drop note pins, built-in Pomodoro timer (25 min sessions), flashcard creator, and quiz generator which are all provided in one screen without switching tabs.

Mistake Journal — Every wrong attempt is logged, tagged by concept, and gets an AI-generated root-cause diagnosis. The system tracks resolved vs. unresolved error patterns over time, surfacing your blind spots before exam day.

How we built it

Frontend: Next.js 14 (App Router) + React 18, styled with vanilla CSS and CSS custom properties with heavy use of glassmorphism, micro-animations, and bento grid layouts for the landing page.

AI/LLM: Groq (llama-3.3-70b) powers the Socratic Solver, Feynman gap analysis, and Mistake Journal diagnosis. The Feynman pipeline specifically uses structured JSON output mode to guarantee parseable, actionable feedback. Hard JEE problems route to a deeper reasoning model for better hint quality.

Database & Auth: Supabase Postgres with @supabase/ssr for server-side authentication. The Mistake Journal stores per-user error logs, concept tags, and resolution state.

PDF rendering: PDF.js via CDN, rendered on HTML canvas with custom annotation and highlight layers built on top.

Math rendering: react-markdown + rehype-katex + remark-math for LaTeX equations throughout the solver and explainer interfaces.

Hosting: Hosted on Vercel which has zero cold starts on the free tier, global CDN for the Next.js app.

The entire infra runs at zero cost on free tiers (Supabase + Groq + Vercel), scaling to several hundred users before any paid plan is needed.

Challenges we ran into

Socratic enforcement is prompt-level only. A sufficiently persistent user can jailbreak the "never give the answer" constraint through multi-turn pressure. We mitigated this with session-scoped context that tracks reasoning progress and re-anchors the prompt at each turn, but it's not airtight.

LLM hallucination in hints. Models are more likely to generate a plausible-sounding hint than admit uncertainty, especially in niche, tough problems. We addressed this with two layers: prompting the model to cite which concept each hint is anchored in, and an explicit intellectual honesty clause baked into the system prompt which ensures that if the model isn't confident in the next step, it's required to say so outright ("I'd recommend checking a textbook solution rather than risk sending you down the wrong path") rather than fabricate a plausible-sounding nudge. A wrong hint is worse than no hint, and the prompt enforces that.

Focus Mode annotation persistence. Highlights and note pins are session-local until Supabase storage is fully wired. This was the hardest feature to ship at hackathon pace because PDF canvas coordinates need to be serialised and re-mapped on page re-render, so we prioritised getting the experience right and deferred the persistence layer.

Groq free-tier rate limits under concurrent use required debouncing Feynman submissions and adding a queue indicator in the UI so users know their request is processing, not dropped.

Accomplishments that we're proud of

Feynman scoring pipeline is novel. No existing ed-tech platform evaluates conceptual depth with structured output (score + specific gaps + targeted follow-up) in real-time. We built this from scratch.

Strict Socratic enforcement that actually works; the AI consistently refuses direct answers across physics, chemistry, and math problems at JEE Advanced difficulty. Getting this to hold across edge cases took significant prompt engineering.

Focus Mode is a full study workspace in a single screen: PDF canvas, page range selector, annotations, Pomodoro, flashcards, and quizzes.

Research-grounded design Every feature maps to a published finding: Bloom's 2-Sigma Problem for the Solver, Roscoe & Chi (2007) for the Explainer, Ariga & Lleras (2011) for Focus Mode, Ebbinghaus for the Mistake Journal, and even the Pomodoro timer concept is backed by research. We didn't add features for the sake of features.

Zero-cost infra that scales The entire stack runs free until several hundred users.

What we learned

Prompt engineering is engineering. Getting an LLM to reliably not do something (give an answer) under adversarial conditions is a real systems problem which requires context management, session state, and re-anchoring logic, not just a single instruction. It took us multiple iterations to get the prompt which managed to work across situations.

Structured output is underutilised in ed-tech. Most AI tutoring tools return free-form text. By forcing JSON output from the Feynman pipeline, we could build dynamic UI around the score, gap list, and follow-up question separately, thereby making the feedback far more actionable.

The biggest UX problem in study tools isn't features, it's friction. Students abandon tools the moment they have to switch tabs, re-upload files, or re-authenticate. Every opportunity to leave the study zone is an opportunity for distraction. Which is why, everything we built was obsessed with reducing that friction, with Focus Mode packs so much into one screen.

The long-term moat is data, not features. Every Socratic session generates labelled reasoning traces. At scale, this becomes a proprietary dataset of competitive exam problem-solving patterns that no competitor can replicate, and could be the foundation for a fine-tuned domain model.

What's next for EurekaAI

Concept Graphs — visual maps of how topics connect across Physics, Chemistry, and Math, with your weak nodes highlighted based on Mistake Journal data.

Persistent Focus Mode annotations — Supabase storage integration so highlights and notes survive across sessions.

Fine-tuned domain model — collect failure cases and reasoning traces at scale, fine-tune on top of an open model, and route 80% of queries off Groq's API entirely for better unit economics.

Institutional B2B — white-label version for coaching centres with custom problem banks, bulk licensing, and student performance analytics dashboards.

PYQ and solutions based refining — the LLM could be fine tuned based on artificially generated, hint based mock conversations derived from PYQs and solutions of multiple exams, ensuring greater accuracy.

AI Use Disclosure

Used Claude for early feature validation and feature/architecture brainstorming, then built the app in Antigravity (AI-assisted IDE) which handled a large share of the actual code generation and iteration. Groq's Llama models power the in-app AI features (Socratic solver, vision-based problem parsing), so AI was also used within the product, not just to build it.