💡 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_transformuses 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.quaddirectly. 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
- angular.js
- animejs
- buf
- connectrpc
- deep-agents
- docker
- github-actions
- go
- grpc
- katex
- langchain
- mpmath
- openrouter
- playwright
- postgresql
- protobuf
- python
- sympy
- typescript
- vercel
- wolfram-technologies