StudyLens: An AI Tutor That Learns How You Think

A Chrome extension that checks homework right on the page, explains each mistake on a whiteboard, and writes practice for it. It remembers how you learn and runs on your own Claude, no API key.

Comment

Inspiration

We got this idea when one of Sachchit's friends, Jordan, who is one of the most hardworking people that we know, copied and pasted answers from ChatGPT. Jordan then came back to sachchit’s room to hang out the next day and Told him that he actually got a 58 on the test that was on that material. he started talking about how he understood it when he was talking to chat but got to the test and completely froze. he wasn't lazy, he just couldn't afford a tutor. Sachchit has been thinking about this since then and when he saw that the project was to create something that learns upon itself he took this as the perfect time to make this project.

What it does

StudyLens is a Chrome extension, a web dashboard and a Claude connector. It sits on top of the homework students already do and teaches instead of giving answers.

  • Check my work: one click on any homework page (Kami, PDFs, Google Docs, problem sets) marks each step. Red means a mistake, green means correct, and amber means "I can't read your handwriting here", so it asks instead of guessing. It names the belief behind the mistake ("the negative only applies to the first term") and asks one question instead of giving the answer.
  • Explain: explanations are drawn step by step on an animated whiteboard, with graphs and diagrams.
  • Practice: new problems aimed at the exact misconception, graded on the server, and scheduled to come back right before you'd forget them.
  • Knows your school: deadlines, grades and materials sync from Canvas and Google Classroom, so help is tied to what's actually due.
  • Learns how you learn: every check, practice answer and Claude conversation updates one learner profile and a 3D skills map. Students can read and edit the profile at any time.
  • Runs on your own Claude: through our MCP connector, a student with Claude needs no API key. Claude reads their screen and profile, puts marks back on the page, and saves what it learned for next time.

How we built it

Stack:

  • Web app: Next.js on Vercel, with Supabase (Postgres + pgvector) behind it.
  • Extension: Manifest V3, built with WXT and React; it draws its overlay inside a shadow root so it never breaks the page underneath.
  • Shared core: one TypeScript package holds the learning logic, so the extension, the web app and the MCP server all agree on it.

Learner model. Everything a student does becomes an event. Each skill's mastery is a recency-weighted average of the evidence, using a 14-day half-life:

$$ w_i = 2^{-\Delta t_i / 14}, \qquad \text{mastery}(s) = \frac{\sum_i w_i \, c_i}{\sum_i w_i} $$

Here $c_i \in {0,1}$ is whether attempt $i$ was correct and $\Delta t_i$ is its age in days. Recent work counts most, so the model forgives you once you've improved, and asking about a topic never counts as being bad at it. Every 25 events, a consolidation step rewrites the profile in plain English (for example, "learns best from one worked example, then a single question").

Spaced repetition. Practice uses SM-2. After the first two reviews, the gap between reviews grows by an "ease factor" that adapts to how well you answer:

$$ I_1 = 1,\quad I_2 = 6,\quad I_n = I_{n-1}\cdot EF, \qquad EF' = EF + \big(0.1 - (5-q)(0.08 + 0.02(5-q))\big) $$

where $q \in [0,5]$ is the quality of your answer.

A watchdog on the AI. Every model output goes through verifiers before a student sees it:

  • arithmetic is re-checked numerically;
  • marks must point at real places on the page;
  • answer keys never reach the browser.

If a check fails, the model gets one retry with a written critique. If it fails again, that piece is dropped instead of shown. Every run is logged, and if more than 30% of the last 20 runs for a feature fail, a circuit breaker switches that feature off.

Claude mode. When there's no API key, the extension queues a task. The student's Claude picks it up with MCP tools (get_pending_check, get_learner_profile), and submit_check_result puts the marks back on the page. Claude's output passes through the same verifiers.

Challenges we ran into

  • Trusting the AI. Early versions sometimes "found" mistakes that weren't there, or misread messy handwriting and graded the misreading. A wrong correction is worse than none, so we built the amber "not sure, can you tell me?" state and the verifier and retry loop.
  • No API key at all. Supporting students without paid model access meant redesigning the flow around a task queue that Claude completes through MCP, while keeping it a single click.
  • Fragile extensions. Chrome refused to load our extension because a math-rendering library contained an invisible Unicode "noncharacter" that minification turned into invalid UTF-8. We wrote a build plugin that rewrites those characters and a packaging check that refuses to ship a bad zip.
  • Videos that wouldn't play on Windows. Our demo videos worked on our machines but showed blank cards on Windows. The renderer was writing full-range colour video that Windows' hardware decoders reject, and re-encoding fixed it.
  • Privacy. A tool that sees your screen has to earn trust. Tracking is off by default, students can pause it per site, and everything StudyLens learns about them is visible and editable.

Accomplishments that we're proud of

  • A tutor that says "I don't know" instead of confidently guessing. Uncertain handwriting is flagged, not graded.
  • No API key needed: through MCP, a student's own Claude does the thinking, so StudyLens costs almost nothing to run per student.
  • One learner model fed by three sources (school courses, Claude conversations, and the student's own work) that every part of the product reads before teaching.
  • A verification layer with retries, critiques and circuit breakers, so a bad model output never reaches a student.
  • A real, deployed product: a live site, a downloadable extension, a working MCP server, and 78 passing tests.

What we learned

  • Good tutoring is mostly restraint. One well-chosen question beats a paragraph of explanation, and the research backs this up: students who practised with plain ChatGPT scored 17% worse once it was taken away, while a hint-giving tutor avoided that drop.
  • Memory changes everything. A tutor that remembers you drop negative signs is a different product from one that meets you fresh every time.
  • Verification is a feature. With LLMs, how you check the output matters as much as the prompt.
  • Cost is an equity issue. Our most impactful decision wasn't a model choice. It was letting students bring their own AI so the tool can stay free.

What's next for StudyLens: An AI Tutor That Learns How You Think

  • Real students this semester: pilot with classmates and measure what matters, which is whether they can solve the next problem on their own.
  • More subjects: extend beyond algebra and chemistry to essays, coding and history, with feedback suited to each.
  • Teacher view: an opt-in, privacy-first summary of class-wide misconceptions, so teachers know what to reteach.
  • More platforms: Schoology, Brightspace and Notion, plus mobile for photographing paper homework.
  • Smarter memory: use the learner model to predict which skills a student is about to forget and schedule practice before quizzes.

Built With

Share this project:

Updates

Submission history