GapFinder

GapFinder looks beyond right and wrong I built it to analyze how a student arrived at an answer, uncover the point where their understanding breaks and turn that gap into a personalized learning path.

Comment

Inspiration

A student's final answer tells you what happened.

Their work can tell you why.

Most learning systems stop at correct or incorrect. But when a student makes one conceptual mistake early in a solution, the steps that follow may simply be consequences of that first mistake.

The learner is then left with a question that ordinary answer checking cannot answer:

Where did my reasoning first break?

That became GapFinder.

GapFinder treats student work as evidence of thinking. It analyzes the reasoning represented in a solution, verifies what can be verified, identifies the first meaningful divergence, connects that evidence to an underlying learning gap, and turns the diagnosis into a targeted next step.

The difference is fundamental.

Instead of treating every wrong line as another failure, GapFinder tries to find the earliest point where understanding stopped holding.

Don't just find the wrong answer.

Find where understanding broke.

What it does

GapFinder turns a student's work into a reasoning diagnosis.

A student submits their work and GapFinder analyzes the solution step by step rather than judging only the final answer.

The reasoning audit can distinguish between:

Correct reasoning

First divergence

Downstream consequence

Independent error

Uncertain

This matters because a wrong step does not always represent a new misunderstanding.

If one conceptual mistake causes several later steps to fail, GapFinder identifies the earliest meaningful break and treats later errors as consequences when the evidence supports that interpretation.

The diagnosed gap then becomes the context for the learning experience.

GapFinder can identify the underlying learning gap, explain it using the student's own work, provide targeted guidance instead of immediately revealing the answer, generate focused learning paths, create contextual visual explanations, guide targeted practice, recheck understanding after intervention, connect learners with free learning resources, surface real academic research and technical resources, discover relevant open-source projects, and track unresolved gaps and progress.

The traditional loop is:

Answer → Feedback

GapFinder turns it into:

Evidence → Diagnosis → Repair → Practice → Verification

The product does not end when the mistake is identified.

That is where the learning begins.

Why GapFinder is different

The core insight is simple:

Grading an outcome is not the same as diagnosing understanding.

Consider a student who makes a sign error early in an algebraic solution.

Several later lines may be wrong, but those lines can still be perfectly consistent with the original mistake.

A conventional checker may report several errors.

GapFinder asks a different question:

Where did the reasoning first stop following?

That lets the system distinguish the root cause from its downstream consequences and focus the learner on the concept that actually needs repair.

GapFinder also treats uncertainty as a legitimate result.

When evidence is insufficient, the system can return Uncertain rather than manufacture confidence.

This matters because a confident but incorrect diagnosis can teach the learner something they never needed to learn.

The result is a system designed around evidence, verification, and actionable intervention rather than simply producing more feedback.

How we built it

GapFinder is built around a continuous learning intelligence loop:

Student Work → Reasoning Interpretation → Verification → Gap Detection → Personalized Intervention → Practice → Recheck

The core engineering principle is:

AI interprets.

Deterministic systems verify.

The learning system uses the evidence to determine what happens next.

AI is used where interpretation and personalization are valuable, including understanding student work, extracting reasoning context, generating explanations, and adapting instructional language.

Where a result can be computationally verified, GapFinder uses deterministic logic rather than asking a language model to make the final call.

This separation is especially important in education. A model can produce a convincing explanation while being wrong about the underlying mathematics. Verification provides a stronger foundation for decisions that can actually be computed.

The architecture connects reasoning evidence, verification, gap diagnosis, learner state, intervention selection, practice, reassessment, and progress.

The student's previous work remains part of the context so later decisions can build on observed evidence instead of treating every interaction as a blank slate.

Trust is a feature

GapFinder deliberately supports an Uncertain outcome.

If the available evidence is not strong enough to make a reliable judgment, the system does not need to guess.

The reasoning audit can distinguish between:

Correct

First Divergence

Downstream Consequence

Independent Error

Uncertain

The same philosophy applies to learning resources and research discovery.

Where provenance matters, GapFinder can use real academic and technical sources rather than relying on a model to invent references.

The principle is simple:

When something can be verified, verify it.

When there is not enough evidence, do not pretend.

From a mistake to a learning journey

Finding a gap is only half the job.

GapFinder turns diagnosis into action:

Gap Detected → Understand Why → Repair → Practice → Recheck → Mastery or Reinforcement

The intervention is informed by the evidence in the learner's work.

A prerequisite problem can lead back to the missing foundation.

A recurring misconception can trigger deeper conceptual work.

A smaller procedural error can receive a targeted hint rather than an unnecessary lesson.

Successful practice can lead to a more independent or unfamiliar problem.

The goal is not to explain everything.

It is to choose the most useful next learning action.

One connected learning workspace

GapFinder connects diagnosis, learning, exploration, and progress in one workspace.

A diagnosed gap can lead to targeted learning paths, free resources, academic research, technical resources, open-source projects, focused learning experiences, progress tracking, reassessment, and optional Spotify-powered Focus Mode.

These capabilities are connected to the learning journey rather than presented as unrelated AI features.

Understand → Repair → Practice → Explore → Verify

The goal is not to give learners more information.

It is to make every piece of information serve the next learning decision.

The AI is part of the product, not a chatbot

GapFinder was not designed as a conventional education dashboard with a chatbot attached afterward.

AI participates in the core transformation:

Raw Student Work → Reasoning Interpretation → Verified Evidence → Learning Gap Diagnosis → Personalized Intervention → Reassessment

The important question is therefore not:

What answer should AI generate?

It is:

Given the evidence in this learner's work, what should happen next?

That makes AI part of the learning decision loop rather than a decorative conversational layer.

Challenges

The difficult part was not generating an impressive AI response.

It was making the response genuinely useful.

We had to solve questions such as:

Where did reasoning first diverge?

Is a later error independent or a consequence?

How much help should the learner receive?

When should the system explain, hint, or return to a prerequisite?

What can actually be verified?

What evidence shows that the learner improved?

These questions shaped the architecture itself.

The resulting workflow is:

Diagnose → Explain → Guide → Practice → Recheck

The biggest lesson was that educational AI becomes more useful when the model is not responsible for every decision simply because it can generate an answer.

Accomplishments we're proud of

We are proud that GapFinder moves beyond final-answer checking and treats reasoning as the primary evidence.

The strongest parts of the system are:

Root-cause reasoning analysis instead of simply counting wrong answers

Separation of first divergence from downstream consequences

An Uncertain outcome instead of forced confidence

Deterministic verification where computation can establish the result

AI used for interpretation and personalization rather than as the sole source of truth

A connected path from diagnosis to intervention, practice, and reassessment

Real research, learning resources, and open-source discovery connected to learning gaps

A complete deployed product rather than a static prototype

Most importantly, GapFinder turns a mistake into a learning loop instead of ending at feedback.

What I learned

GapFinder changed how I think about educational AI.

The difficult question is not:

Can AI explain this?

It is:

Can the system understand what this learner needs next?

That requires evidence, context, verification, intervention, and reassessment.

I also learned that more features do not automatically create a better product.

Every capability should earn its place by improving the learner's next decision.

That became our design principle:

Don't generate more information.

Make the next learning decision better.

What's next

GapFinder can evolve from diagnosing individual problems into a broader learning intelligence system.

The next step is stronger longitudinal learning profiles that preserve meaningful evidence across sessions.

This could allow the system to recognize recurring misconceptions, understand relationships between connected concepts, distinguish short-term performance from durable understanding, and personalize interventions using the learner's history.

A major direction is measuring whether an intervention actually worked:

Gap detected → Intervention → Independent practice → Transfer problem → Reassessment → Retention evidence

That shifts the goal from generating better explanations to demonstrating better learning outcomes.

The long-term vision is simple:

Remember where understanding broke.

Understand why.

Help repair it.

Check whether the repair worked.

Then use that evidence to make the learner's next step better than the last.

Built With

Share this project:

Updates

Submission history