• 

• 

• 

• 

• 

• 

• 

• GIF

Repomind

Proof-of-work for coursework in the age of AI — Repomind verifies that students actually did, and understand, their projects.

Inspiration

Spend ten minutes with anyone who grades a programming course and you will hear the same complaint: a folder of sixty GitHub repositories due at midnight, and no real way to tell them apart. Some are clearly templated. A few arrive as a single commit that drops a finished project in one shot. The professor suspects that part of the class handed the whole thing to an AI — but suspicion is not evidence, and you cannot fail a student on a hunch.

That is the moment the problem became obvious to us. AI has not just made coursework easier to fake; it has made the fake indistinguishable from the real thing on the surface. A repository that compiles, a submission that is on time, an assignment that looks finished — none of it proves a student did the work or understood it. The artifacts we have always graded quietly stopped meaning what we assumed they meant.

We built Repomind because grading should be about evidence, not guesswork, and because a grade should be something a student earns and a department can stand behind.

What it does

Repomind is a coursework platform for computer-science departments that verifies student work instead of only collecting it. It runs the full lifecycle — courses, sections, assignments, projects, quizzes, and vivas — but everything is organized around three questions a normal LMS never asks.

Did they do it? When a student links their GitHub repository to a course, Repomind analyzes the commit history, the authorship, and how the work actually came together over time, then returns a plain verdict: Verified, Review, or Flagged. Faculty see the evidence behind that verdict; students see only the word, so the signal informs grading without turning into a public accusation.

Do they understand it? From the student's own project, Repomind generates a short knowledge-check quiz. Passing it means more than "I submitted something" — it means the student can answer for the thing they handed in.

Can they defend it? A structured viva runner, backed by a per-project question bank, adds the human layer for high-stakes evaluation.

All of it rolls into a live course standing, and the entire app is shaped around three roles. Students get a verified record of their work and a single, honest view of what needs them right now. Faculty get a grade-at-a-glance hub that triages an entire section in seconds — who is waiting, what is flagged, what is ready to grade. Admins get a state-of-the-platform console for integrity, approvals, and grading-override oversight.

The one-line version: every LMS collects submissions; Repomind verifies them.

How we built it

The app runs on Next.js with React Server Components and TypeScript from end to end, so most of the work happens on the server and the client stays light. The academic model — courses to sections to projects to evaluations, quizzes, and vivas — lives in PostgreSQL through Prisma.

Authentication is handled by Better Auth over GitHub OAuth, which does double duty: it signs students in and grants authorized access to the GitHub API, where the authenticity engine reads commit timelines, authorship, and language fingerprints. Project analysis runs through an automated pipeline with in-flight job tracking, so the interface can honestly report queued, running, or a result without ever misrepresenting state, and quiz and analysis work fans out to background jobs instead of blocking a request.

On the front end we built our own design system rather than leaning on an off-the-shelf component kit: an overview-first set of primitives — a page-leading summary band, preview cards, an urgency-sorted "needs you" queue, and one responsive card grid — on a restrained dark theme. The rule is the same everywhere: lead with meaning, use a single accent, and never show a tally where a sentence tells the truth better.

For the development loop we used bun, Biome, Vitest, and Playwright, with unit tests across the scoring and grading logic and end-to-end coverage of the quiz runner.

Challenges we ran into

The hardest problem was not technical — it was fairness. An authenticity signal that is too aggressive punishes honest students who squash their commits or push in bursts; one that is too lenient is useless. We resolved it by keeping authenticity pointer-only for students — a verdict word, never a number — and placing the full evidence only in front of faculty, so the system informs a human decision rather than replacing it.

React Server Components were the second lesson. The boundary between server and client is unforgiving: a pure helper that drifted into a client module quietly took an entire page down at request time, which taught us to design the seam between data and interactivity on purpose instead of by accident.

The third challenge was making something this dense feel like a product rather than a control panel. A genuinely information-rich academic tool wants to become a wall of numbers, and getting it to read as calm and premium took a real design pass: a single type voice, one accent color, consistent spacing, and one source of truth for every count, so the same number never disagrees with itself across screens.

Accomplishments that we're proud of

We have a working product, not a slideshow. The verification flows run end to end across all three roles, the authenticity verdicts are grounded in real commit data, the quizzes are generated from real projects, and the course standing reconciles across every surface where it appears. On top of that, it looks shipped: the interface holds together as one coherent, premium experience instead of a stitched-together demo.

What we learned

The biggest shift in our thinking was this — in education, collecting work is a solved problem; trusting it is not. The moment AI can produce a convincing artifact on demand, the valuable layer moves from "submit and store" to "verify and understand," and almost nobody is building there yet.

We also re-learned that good products are made of small, consistent decisions. One type scale, one accent, one canonical number per concept — none of those are exciting alone, but together they are the difference between something that feels like a tool and something that feels like a product.

What's next for REPOMIND

Next is depth and reach. We want richer commit forensics and per-repository language modeling to make the authenticity signal even harder to game, integrations with the systems departments already run such as Canvas and Moodle, and a pilot with a real CSE department to pressure-test Repomind against live coursework. In an age where any submission can be AI-generated, every institution is about to need a verification layer it does not have yet — and that is the layer we are building.

Built With

• ai
• better-auth
• biome
• bun
• github-api
• github-oauth
• google-gemini
• google-jules
• next.js
• node.js
• playwright
• postgresql
• prisma
• react
• react-server-components
• tailwindcss
• typescript
• vitest