HackStack

Project Info

Mirror

Devpost

Inspiration

I'm a Lead Controls Operator at a hospital. I run the building automation systems that keep patient floors safe. In that world, "the student got the right answer" isn't good enough. I need to know why they got it right, because when a chilled water plant fails at 2 AM, the person on call has to understand the system, not just recall a checklist. I'm also a Human-Centered AI student at Texas Tech, and I watched classmates use ChatGPT the way you'd use a vending machine: insert prompt, receive answer, feel smart, fail the exam. Every AI education tool on the market pushes explanations at students. They all optimize for the moment the answer appears on screen, and none of them measure the moment the concept actually lands in the student's head. So I asked a stupid, obvious question: what if the AI never gave an answer? What if it only asked questions — really good ones, in the specific pattern a great teacher uses — and the student had to think for themselves? That question wouldn't leave me alone. Mirror is what it turned into.

What it does

Mirror is a reverse-Socratic learning platform. The student explains a topic to GPT-5.6, and GPT interviews them — probing what they know, what they think they know, and what they've quietly skipped. For students: Join a class, pick a topic, start a session. GPT-5.6 streams Socratic questions that climb Bloom's taxonomy: recall → comprehension → application → analysis It never gives you the answer. If you're wrong, it asks a question that exposes the gap. If you're right, it pushes deeper — "how does that connect to X?", "what breaks if you change Y?" When the session ends, GPT produces a structured comprehension assessment: a ReactFlow knowledge map where each concept node is color-coded by depth (deep / surface / misconception / unexplored), with every node linking back to the exact message where that judgment was made For teachers: A class-wide heatmap showing aggregate comprehension per concept Misconception alerts, grouped by concept, so you can see which wrong beliefs are spreading Drill down into any student's individual map with their Bloom's profile and evidence-linked exchanges The knowledge map isn't just a picture. It's an audit trail from visualization back to evidence.

How we built it

Solo build, on top of my Human-Centered AI coursework and a full-time controls job. Stack: Frontend: React + Vite + ReactFlow for the interactive knowledge map Backend: Node.js + Express + SQLite (better-sqlite3) AI: OpenAI GPT-5.6 Socratic dialogue via SSE streaming, topic-concept structure generation, and structured JSON assessment Voice: gpt-4o-mini-transcribe and gpt-4o-mini-tts for optional voice sessions (some students explain better out loud than in writing) Auth: JWT + bcrypt, role-based (student/teacher) Built with Codex for scaffolding, component iteration, and prompt engineering The system prompt is the actual product. It went through I don't know how many revisions to reach the version that reliably never gives answers. Early versions collapsed into helpful mode the second a student said, "I don't know." The working version tells GPT to treat "I don't know" as a signal, not a stop sign — reframe smaller, probe an adjacent concept, but never lecture. The comprehension assessment is a structured JSON schema — concept nodes, edges, depth ratings, misconceptions, Bloom's profile, and evidence linked by message index. That last piece is what makes the map trustworthy: click any node, see the exact exchange it came from.

Challenges we ran into

Getting GPT to refuse to help. This was the hard problem. Language models are trained to be helpful, and Socratic teaching looks unhelpful from the outside. Early versions of the prompt would ask two questions, then cave in and explain. Fixing this required explicit rules ("acknowledgment is one sentence, then the next question — never a paragraph"), examples of the failure mode ("don't do this"), and post hoc validators on the streaming output. Structured output under a streaming dialogue. SSE streaming for the chat, then a separate structured-output call to generate the assessment JSON — with the assessment referencing the streamed conversation by message index. Getting message indices to stay consistent across reconnects was uglier than it sounds. Depth over correctness. Traditional edtech grades right/wrong. Mirror had to grade depth — surface recall vs. transferable understanding — and represent that in a way a teacher could scan in three seconds. That's where the color-coded map came from: yellow-green (surface) vs. solid green (deep) is a distinction teachers already make intuitively; the map makes it visible. Solo scope discipline. I had a list of twelve features I wanted. I shipped six. Cutting adaptive difficulty, longitudinal tracking, and LMS export hurt, but shipping the six that make the core loop work was the right call.

Accomplishments we're proud of

The refusal actually holds. In demo sessions, GPT-5.6 has remained in Socratic mode across 20+ exchanges without collapsing into explanation mode. The constraint is the feature. Evidence-linking works. Every node on the knowledge map is one click from the exact message that produced it. That transforms the map from "interesting visualization" into "defensible assessment" — a teacher can justify a rating to a parent by showing the transcript. Bloom's progression is visible in the transcripts. You can literally watch a student climb from recall to application inside a single session. That's the moment I knew this wasn't just a hackathon demo — it was measuring something real. The class heatmap surfaces group-level misconceptions. Teachers have never had this. It's the aggregate view of "which wrong ideas are spreading in my class right now." I shipped it solo, on nights and weekends, while working a critical-infrastructure job.

What we learned

Students learn more when the AI refuses to help. The constraint isn't a limitation — it's the pedagogy. Every "I don't know" that GPT-5.6 doesn't rescue is a moment when the student actually has to think. Structured output beats free text for education. A JSON schema with typed fields (depth, misconception, evidence_message_idx) is dramatically more useful than a paragraph summary — for visualization, for aggregation, and for teacher trust. Evidence is what turns AI assessment from a toy into a tool. The message-index link between assessment and transcript is the single change that made teachers I demoed to lean forward instead of nodding politely. My controls-operator instincts transferred. In critical infrastructure, you don't trust a sensor reading you can't trace to a physical point. Same rule here: don't trust an assessment you can't trace to an exchange. Formally, Mirror measures comprehension along two axes: $$ \text{Understanding}(c) = f(\text{Bloom-level}(c),\ \text{Depth}(c)) $$ where $c$ is a concept node, $\text{Bloom-level} \in {1,2,3,4}$ (recall → analysis), and $\text{Depth} \in {\text{unexplored}, \text{misconception}, \text{surface}, \text{deep}}$. The right answer on Bloom-1 with surface depth is not the same as the right answer on Bloom-4 with deep depth — and Mirror is the first tool I've used that treats them differently.

What's next

Longitudinal tracking — how does a student's knowledge map evolve across three sessions on the same topic? That's the real learning curve, not the test score. Adaptive difficulty — GPT-5.6 adjusts questioning based on the student's demonstrated Bloom's level in real time, so strong students get pushed and struggling students get scaffolded. Multi-modal Socratic sessions — diagram drawing, equation input, and voice — so students can explain how their brains actually work. LMS integration — knowledge maps as gradebook entries with the evidence trail intact. Longer-term: publish the pedagogy. The refusal pattern, the Bloom's climb, the evidence-linked assessment — those generalize beyond any one app. I want the paper to exist so other builders can steal the idea and improve education faster than I can alone. Mirror is the AI that learns from you — so you learn about yourself.

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only
  • CSSIn code
  • ExpressIn code
  • HTMLIn code
  • JavaScriptIn code
  • OpenAIIn code
  • ReactIn code
  • Node.jsClaimed

6 of 7 appear in the indexed code. 1 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

  • CodexCommits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

178 KB

Source files

42

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.

0 stars