💡 Inspiration

Every signals-and-systems student knows this feeling: you turn in two pages of math, get it back with a red ✗ next to the final answer, and have no idea where it went wrong. Was it the partial fractions? The inverse transform? A sign somewhere on line three?

Now flip it around. An instructor with 60 students and 8 problems has 480 derivations to read. Nobody can trace every one line by line, so feedback shrinks to "final answer wrong, −3."

I wanted a tool that reads every line, finds the exact step where each student first slipped, and then tells the instructor what the whole class is stuck on. Not "Problem 5 was hard." More like: 23 students flipped the sign on the time-shift exponential.

This is also my first solo hackathon project, start to finish: engine, backend, frontend, and the demo video.

🔍 What it does

Here's a real derivation. Try to spot the mistake before you scroll:

$$ F(s) = \frac{s}{(s+1)(s+2)} \quad \longrightarrow \quad \frac{2}{s+2} - \frac{1}{s+1} \quad \longrightarrow \quad 2e^{-2t} - e^{-t} $$

Step 1 is fine. Step 2 drops the unit step: it should be (2e⁻²ᵗ − e⁻ᵗ)·u(t). ConXept flags step 2 as the first wrong step, names the misconception (dropped u(t), causality), and shows what the student should have written from their own previous line.

Do that for a whole class and you get:

  • 🔥 A heatmap of where students first go wrong, problem by problem and step by step
  • 🧩 Named misconception clusters with counts, plus an honest "Other" bucket for errors outside my catalog (the tool never invents a name)
  • 🎯 Targeted practice problems for each misconception, each built so that mistake gives a wrong answer, with answer keys checked independently
  • 📝 An instructor brief written by an AI agent, where every number has to come from a tool

👉 Click around the demo: conxept.vercel.app is a read-only snapshot of a processed demo class (synthetic data). The video shows the full system running live.

🛠️ How I built it

The one rule I refused to break: a language model never decides what's correct. Math does.

Step i is valid ⇔ it equals the correct operation applied to step i − 1. First wrong step = the smallest i where that fails.

Checking against the student's previous line (not the answer key) means one early mistake doesn't get charged again at every later step.

  • Engine (Python): SymPy parses each step through my own small math syntax, and mpmath checks equivalence by sampling 6 seeded points: |a − b| ≤ 10⁻⁶ · (1 + |a| + |b|). The seed is fixed, so the same derivation always gets the same verdict.
  • Gateway (Go + connect-go): the only service the browser talks to. It owns the database and streams progress while a class processes.
  • Web (Angular): heatmap, clusters, submission view, practice, evaluation, and a live "try a derivation" page. KaTeX renders the math, anime.js animates the landing page.
  • Contracts: Protobuf with buf, so Go, Python and TypeScript all share one schema.
  • Agent: Deep Agents with four tools (heatmap, clusters, examples, practice), running on a free OpenRouter model. If the brief contains a number no tool returned, I reject it.
  • Extra check: practice answer keys can be cross-checked against Wolfram|Alpha as a third route.

📊 How I know it works (and what that does and doesn't mean)

On a synthetic class of 60 students × 8 problems = 480 derivations:

Result
Correct derivations wrongly flagged 0 / 167
First wrong step found 313 / 313
Catalog misconception named correctly 235 / 235
Errors outside the catalog caught (and left unnamed) 78 / 78

Processing all 480 takes about 2 seconds locally, and a single diagnosis takes 0.37 s even in slow cases (the 95th percentile).

Honest caveat: my own generator made those mistakes, so this proves the system is consistent, not that it matches real students. Real classmate derivations are next.

🧗 Challenges

  • The Fourier convention trap. SymPy's fourier_transform uses e^(−2πikx), and it returns 0 for cos t. My course uses X(jω) = ∫ x(t)·e^(−jωt) dt. Which tool you copy from literally changes the "right" answer, so "copied a tool's default convention" became one of my catalog misconceptions.
  • Integrals made checking slow. Sampling expressions with integrals in them crawled until I evaluated them with mpmath.quad directly. Every diagnosis now finishes well under half a second.
  • Even Wolfram can be wrong. When I added the Wolfram cross-check, its short-answer API returned e⁻²ˢ/s instead of e⁻²ˢ/(s+2) for a delayed exponential. Its own integral was right, so I query the defining integrals instead. Good thing it's a cross-check.
  • The AI kept doing math. A free model added counts together and wrote totals no tool returned. My number check caught it every time. I added one retry where the agent is told exactly which numbers were invented, and also stopped flagging the class ID (a UUID full of digits) as a "made-up number."
  • A race condition on the Try page. If you typed fast, an old verdict could arrive after a newer edit and show the wrong result. I fixed it, then wrote a browser test that controls the clock to prove it stays fixed.
  • Doing it all solo. Every layer was mine to build and debug, from the math engine to the gateway to the UI, so I kept the scope to four problem types and made each one actually work.

📚 What I learned

  • Grade the step, not the answer. Comparing each line to the student's own previous line is what makes the feedback fair.
  • LLMs are great writers and unreliable accountants. Give them tools for the facts, and check their numbers.
  • "100%" on synthetic data is a sanity check, not a victory lap. I say that in the app, in the video, and here.
  • Scope is a superpower on a solo hack. Four problem types done properly beat twenty half-working ones.

🚀 What's next

  • Collect real (anonymized) classmate derivations and measure accuracy honestly, with half held out.
  • Add more courses. Any step-by-step derivation course (circuits, controls, calculus, physics) works the same way once someone writes its problem types and misconception catalog.
  • A real always-on deployment, so instructors can upload their own class.

Built With

Share this project:

Updates

Submission history