Proof — Relentless AI Tutor

The active-recall AI tutor that diagnoses your technical explanations and diagrams through relentless Socratic interrogation.

Comment

Inspiration

  • As a computer science student grinding through dynamic programming algorithms like Unbounded Knapsack and Coin Change, I constantly ran into the "illusion of competence"—also known as Tutorial Hell. You watch a video, memorize a highly-optimized 1D array transition formula, and think you understand it. When you paste your explanation into a standard LLM, it acts like a sycophant, replying with "Great job! That is correct!"

  • But in a real technical interview or production environment, memorized formulas break down. Standard chatbots don't check if you understand why the capacity loop must iterate forwards instead of backwards, or if you forgot the bounds-checking logic that prevents an IndexOutOfBoundsException. I wanted to build an AI that doesn't just give you the answers, but actively hunts for the gaps in your logic.

What it does

Proof is a Socratic diagnostic learning tool designed specifically for developers and engineers. Instead of answering your questions, it forces you to explain concepts to it.

  • Relentless Interrogation: If you feed it a textbook explanation of an algorithm, it will accept the math but immediately pivot to challenge the underlying memory mutations or edge cases (e.g., "What happens to your array when the capacity is smaller than the item's weight?").

  • Multimodal Architecture Diagnosis: You can drag and drop system design flowcharts. Proof visually parses the diagram and challenges structural blind spots, such as how a specific database caching layer handles a cache stampede.

Distraction-Free Immersion: A custom glassmorphism UI over a topographical contour background keeps the focus entirely on the active recall loop.

How we built it

  • Core Stack: We built the application using Next.js 16 (App Router) and React 19, utilizing Turbopack for lightning-fast local development.

  • AI Engine: The Socratic diagnostic engine is powered by Gemini 3.5 Flash integrated via the Vercel AI SDK. We engineered a strict system prompt that forbids the AI from giving away answers, forcing it to scale difficulty dynamically based on the user's input.

  • Multimodal Optimization: To handle system architecture diagrams without blowing up API latency or quotas, we implemented a custom client-side Offscreen Canvas pipeline. This compresses raw image payloads to under 150kb locally before the network request is ever fired.

  • Resilient State Management: Deep learning sessions are valuable. We implemented a sliding-window local

Challenges we ran into

Balancing the AI's persona was incredibly difficult. Standard LLMs are heavily fine-tuned to be helpful and accommodating. Forcing Gemini to adopt a strictly Socratic, slightly adversarial stance—where it refuses to write code for the user and instead asks targeted diagnostic questions—required extensive prompt engineering and context-window tuning.

Additionally, managing the state of a multi-turn multimodal conversation (mixing text algorithms with (O(W)) space complexity proofs like (dp[w] = \max(dp[w], dp[w - weight[i]] + value[i])) and complex architecture images) required careful orchestration between the Vercel AI SDK and our local storage caching layer to prevent UI hydration mismatches.

Accomplishments that we're proud of

The "Gotcha" Engine: Successfully tuning the AI to bypass theoretical math and target actual implementation flaws (like missing if (w >= weight[i]) logic gates that cause real-world production outages).

Zero-Latency Feel: The combination of client-side image compression and custom animated diagnostic loading states makes the complex multimodal processing feel instantaneous to the user.

What we learned

Building Proof taught us a massive amount about Next.js 16 caching layers and the intricacies of the Vercel AI SDK. More importantly, it proved that interacting with AI doesn't have to be a passive experience. By flipping the prompt dynamic—making the human the prompter and the AI the evaluator—we learned how to create a highly effective active-recall loop.

What's next for Proof — Relentless AI Tutor

We plan to expand Proof's diagnostic engine into specific technical interview simulations (e.g., dedicated System Design or behavioral loops). We are also exploring a GitHub integration where Proof can act as a Socratic PR reviewer, asking developers to defend their architectural choices before a merge is approved.

Built With

Share this project:

Updates

Submission history