Lumente

Lumente helps programming students develop questioning through the concepts in their AI-built code they can't explain, then gets them explaining those concepts themselves.

Comment

Inspiration

AI coding agents can produce working code faster than students can understand the ideas underneath it. The code runs, so it feels understood. Then a professor, teammate or interviewer asks, "Why does this work?" and the answer disappears.

Psychologists call this the illusion of explanatory depth: we think we understand something until we try to explain it. AI can make that gap larger. In Anthropic's study, developers learning with AI scored 50% on a concepts quiz, compared with 67% for those who coded by hand. Aalto University found that people using ChatGPT overestimated their performance by about four points.

Lumente starts with programming students because they face this moment constantly. It helps them explain the concepts behind their own projects. But concepts are the anchor, not the final goal. The skill underneath is questioning: noticing what you do not understand, asking what you need to know and building the answer yourself. We see that as a foundational habit of critical thinking.

What it does

A learner chooses a concept from their project, such as API or CORS, and predicts their score before seeing a question. The prediction is not a grade. It captures their confidence at the start.

They then build a conceptual mentefact, a specialized visual map from Conceptual Pedagogy. It places one concept in four areas: the bigger group it belongs to, what it is often confused with, what must be true for it to count as one, and the types that exist. The firefly asks questions and checks each answer, while the learner builds the map in their own words. Help is always available. The score shows how much the learner could explain independently and how much they built with guidance, which fades as they become more independent.

At the end, Lumente shows the predicted score beside the score they proved. That gap makes confidence visible: how well what they felt they knew matches what they could actually explain.

The guidance stages track independence in the four map areas across concepts; they are not scores for API, CORS or another individual concept. Once guidance has faded across all four areas, the roles flip. The learner builds the whole map, decides what they need to know and asks a fact desk for facts. That is where Lumente moves from helping with one concept to practicing how to unravel the next one.

How we built it

Lumente is a TypeScript monorepo with three parts: the Expo app, an Express API and a guided-thinking engine.

  • One app, two platforms: Expo SDK 58 and Expo Router power the Android and responsive web apps. EAS Build creates the APK, EAS Update sends fixes to installed phones and EAS Hosting serves lumente.expo.app, which can also be installed as a web app.
  • A controlled agent flow: a deterministic state machine decides what happens next. It calls six Claude agents, each with one job: ask a question, evaluate one answer, evaluate the whole map, answer facts, offer guidance or coach the result. Zod validates every structured input and output.
  • Numbers in code, words in the model: Claude writes questions, evaluates the meaning of answers and words the feedback. Plain code applies the rubric and computes every score, guidance stage and how guidance affects the score, so the model does not control the scoring rules or progression.
  • Backend and memory: Express 5 runs on Node 24 and Render. SurrealDB Cloud stores sessions, complete conversation transcripts, guidance stages and agent logs. SurrealDB Agent Memory holds small progress facts that the guidance and coaching agents can cite. Clerk handles sign-in.

Each answer and step is saved as it happens. If a request is repeated or the learner closes the app, they can continue without duplicating a step or losing their conversation.

Responsible by design

Because Lumente measures learning, we separated what the model can judge from what it can control. Claude evaluates an answer against a rubric, but plain code assigns the points and advances the guidance. Any defensible answer can pass; the learner does not have to match one expected phrase. The AI asks, checks and responds, but the learner writes the map.

The Anthropic key stays on the server, every private route requires a Clerk session token and the API verifies that token locally. Our database uses the Clerk user ID and stores no name or email. Learner text is fenced as untrusted data inside every agent prompt.

Agent Memory never receives the learner's answers. It stores only progress facts written from code templates under a salted pseudonym, and it cannot change a score or guidance stage. Agents may cite only facts the server gave them. If memory is unavailable or takes more than 1.5 seconds, the session continues without it.

Lumente never receives a voice recording: the device or browser's speech provider processes it, and only the editable transcript reaches us when the learner submits it. "Your data" explains what we keep, and "Delete my data" purges the learner's memory, sessions, agent logs and guidance stages before signing them out.

Challenges we ran into

  • A blank first screen looked like a broken link. Local WebKit cold starts waited roughly 12 seconds for seven custom fonts before showing the interface. On the web, we now render readable fallback text first and load the brand fonts after the first frame with FontDisplay.SWAP. Android keeps its native font-loading gate.
  • Static web authentication broke multi-step sign-in. Clerk's form moved to nested paths that a static export could not serve on reload, and hosted sign-up could leave learners in Clerk's account portal. We added app-owned sign-in and sign-up pages with hash routing and explicit return paths; Android keeps Clerk's hosted flow.
  • Multiple agents made latency a workflow problem. Some transitions waited for one agent and then another; evaluation followed by final coaching took 9.2 seconds. We now prepare the next question in parallel with evaluation and show the code-computed result before requesting the coach.
  • Agent Memory rejected parallel writes on one concept record. We changed its progress-fact writes to run sequentially and off the request path. A slow or failed memory operation never blocks the learning session.

Accomplishments that we're proud of

  • We shipped a working product on Android and the web from one Expo codebase. A learner can complete the full experience, leave, return to the conversation and reopen finished maps.
  • Six specialized agents work inside one predictable flow while plain code owns every score and guidance-stage change. Flexible answers can be accepted without giving the model control of the rules.

What we learned

  • Performance, confidence and independence are different signals. The map score measures what someone explained in one session, the prediction gap compares that with their confidence, and the guidance stages track how independently they work across concepts.
  • Designing the agents meant designing a handoff of responsibility, not a chatbot. Each agent needed one role in a flow that moves the learner from explaining, to answering guided questions, to forming their own questions.
  • In a thinking tool, reliability affects the thinking itself. Losing a session on reload or waiting on non-essential coaching interrupts the work, so recovery and progressive results became part of the experience.

What's next for Lumente

Critical thinking is the larger goal, and concepts are the first anchor. Next, Check the AI will help learners practice judgment: examine whether an agent's answer holds up, uncover its assumptions, identify what kind of claim it makes and notice possible bias. Later phases will apply shared skills such as questioning, explaining and noticing uncertainty to perspectives and decisions.

The nearest product steps strengthen the concepts experience: show where each fact came from, connect to a learner's repository to suggest concepts from their code, compare one concept across examples and add Spanish. We begin with programming students and expand to other groups through the thinking skills they need, rather than turning Lumente into a collection of unrelated courses.

The business model should match the cost of AI without turning learning into a meter. Learners can try a small number of complete concept sessions free, then buy packs of additional sessions. Instructors, bootcamps and colleges can fund access per active learner for a term, with a shared session allowance and a class view of what students could explain, where they needed guidance and where their confidence differed from what they could demonstrate. Exact prices will be set after we know how often people use Lumente and what learners and schools find valuable.

Team

  • Cynthia Salazar
  • Leo Atienza
  • Kyle Argallon

Built With

  • claude-(anthropic)
  • clerk
  • eas-build
  • eas-hosting
  • eas-update
  • eas-workflows
  • expo-observe
  • expo-router
  • expo-sdk-58
  • expo-speech-recognition
  • express-5
  • node-24
  • react-native
  • react-native-reanimated
  • react-native-svg
  • render
  • surrealdb-agent-memory
  • surrealdb-cloud
  • typescript
  • zod
Share this project:

Updates

Submission history