LabDefense

LabDefense - Turn your thesis into a knockout argument.

Comment

About LabDefense

Inspiration

LabDefense came from a problem I have run into a lot in technical classes and research projects: finishing the report does not always mean you are ready to explain it.

A lab report can look polished. A code project can run. A research poster can have clean figures. But the moment someone asks, “Why did you choose that method?” or “How do you know this result is not just an artifact?” it becomes clear whether you actually understand the reasoning underneath the work.

That is the gap LabDefense is meant to address.

Most study tools help people memorize information or summarize notes. LabDefense focuses on something more uncomfortable but more useful: preparing to defend technical decisions. It helps users find the weak parts of their reasoning before a professor, TA, mentor, or judge does.

The goal is simple:

Don’t just submit it. Defend it.

What LabDefense does

LabDefense turns a lab report, research writeup, code explanation, or engineering design summary into an oral-defense practice session.

The user starts by pasting in their project. The app then analyzes the text and identifies the parts that matter most in a technical defense:

  • key claims
  • methods
  • assumptions
  • missing evidence
  • unclear explanations
  • possible sources of error
  • likely professor questions

From there, LabDefense creates a structured defense simulation. It asks one question at a time, waits for the user’s answer, then evaluates the response based on correctness, specificity, evidence, limitations, and clarity.

The app does not just say whether an answer is good or bad. It explains what worked, what was missing, and how to make the answer stronger.

The core feature: Socratic Attack Tree

The most important feature is the Socratic Attack Tree.

For each major claim in the user’s project, LabDefense maps out the different ways that claim could be challenged. A technical claim is rarely weak for only one reason. It might depend on an assumption, a method choice, a threshold, an equation, a data-processing step, or a missing uncertainty estimate.

The Socratic Attack Tree breaks this down into challenge branches:

  • evidence challenge
  • method challenge
  • assumption challenge
  • edge-case challenge
  • limitation challenge
  • alternative-explanation challenge

For example, if a project claims that a detected trend is meaningful, LabDefense might ask:

  • How did you quantify uncertainty?
  • Could preprocessing have created this trend?
  • What assumptions does your model depend on?
  • What would happen if the threshold changed?
  • Is there another explanation for the same result?

The idea is that a strong technical claim is not just a conclusion. It is a structure:

$$ \text{Claim} = \text{Evidence} + \text{Method} + \text{Assumptions} + \text{Limitations} $$

LabDefense helps users see where that structure is strong and where it might collapse under questioning.

How I built it

I built LabDefense with MeDo as a full-stack web app.

I structured the build process in stages. First, I created the main app flow: a landing page, project intake page, analysis dashboard, oral-defense simulator, and final prep packet. Then I focused on the analysis logic, making sure the app could organize a project into claims, methods, assumptions, weak spots, and likely questions.

After that, I built the oral-defense loop. This became the main interaction of the app: the user gets a question, answers it, receives a score, sees what was missing, and gets a stronger version of the answer.

The most interesting part to build was the Socratic Attack Tree because it had to feel more useful than a list of AI-generated questions. I wanted it to show the logic behind the questioning. Instead of only asking “What are your limitations?”, the app shows how limitations connect to specific claims and why those limitations matter.

I also added demo presets so someone can test the app immediately without needing their own report. The presets include examples like a chemistry titration lab, a sea ice code report, a drone propeller design project, an engineering joint review, and a research poster defense.

Challenges

One challenge was making the project feel unique. A simple chatbot that asks study questions would not be very interesting. I wanted LabDefense to feel like a tool for technical reasoning.

Another challenge was answer evaluation. In an oral defense, an answer can be technically correct but still weak. For example, a student might state the right equation but fail to explain why it applies. Or they might describe a result without mentioning uncertainty. To handle that, I designed the feedback around multiple criteria:

  • correctness
  • specificity
  • use of evidence
  • awareness of limitations
  • clarity

This made the evaluation more realistic because it reflects how technical answers are actually judged.

The design was also a challenge. There is a lot of information in a project analysis, and it can easily become overwhelming. I split the app into stages so the user does not see everything at once. First they get the analysis, then they inspect weak spots, then they practice questions, and finally they export a prep packet.

What I learned

Building LabDefense made me think more carefully about what it means to understand a project.

It is easy to feel confident when the final report looks finished. But real understanding shows up when someone asks you to explain a method choice, defend an assumption, or admit where the result is limited.

I also learned that useful educational tools do not always need to give users answers immediately. Sometimes the better tool is the one that asks the question the user was hoping no one would ask.

That is what LabDefense is trying to do: make technical preparation more honest, more active, and more useful.

What is next

Future versions of LabDefense could include:

  • CSV-based data analysis
  • automatic figure interpretation
  • citation checking
  • voice-based oral defense practice
  • course-specific rubrics
  • collaborative peer review mode

The long-term goal is to make LabDefense useful for anyone who needs to explain technical work under pressure, whether that is a lab report, research poster, code project, or engineering design review.

Built With

Share this project:

Updates

Submission history