CodeSense

An adaptive AI examiner that analyzes your code, tests your understanding, challenges you with bugs, and creates a personalized improvement report

Comment

Inspiration

Many students can write, copy, or memorize a program for a lab examination, but they struggle when asked to explain how the code actually works. They may know the expected output without clearly understanding the variables, loops, conditions, functions, edge cases, or bugs inside the program.

We built CodeSense to solve this problem. It turns a student’s own code into an interactive practical assessment that checks real understanding instead of memorization.

What it does

CodeSense allows a student to select a programming language and difficulty level, then paste a complete program or load a sample.

The platform analyzes the submitted code without executing it and identifies concepts such as:

  • Functions and parameters
  • Variables and collections
  • Loops and conditional statements
  • Return values
  • Input and output
  • Code flow and state changes
  • Concrete edge cases

It then generates five questions based on the actual function names, variables, code lines, and snippets in the submitted program.

Each answer is evaluated using an explainable scoring system that considers:

  • Relevance to the question
  • Expected programming concepts
  • References to actual identifiers and code behaviour
  • Clarity of explanation
  • Examples or execution traces

Weak answers receive one targeted follow-up question. The original answer, follow-up answer, and improved effective score are all preserved.

After the understanding assessment, the student completes a debugging challenge and receives a personalized report containing:

  • Overall CodeSense score
  • Code-understanding score
  • Logic and tracing score
  • Debugging score
  • Explanation-quality score
  • Strengths and weak concepts
  • Question-by-question review
  • Personalized seven-day improvement plan
  • Short concept lesson
  • Recommended practice challenge

How we built it

CodeSense was built with Next.js, React, TypeScript, and Tailwind CSS.

OpenAI Codex with GPT-5.6 was used throughout development for:

  • Planning the architecture
  • Building the responsive interface
  • Implementing code-analysis logic
  • Creating code-specific question-generation rules
  • Developing adaptive scoring
  • Building persistent follow-up evaluation
  • Debugging runtime and state issues
  • Refactoring components
  • Running lint and production-build verification
  • Preparing the GitHub repository and deployment

The deployed MVP currently uses a deterministic local assessment engine. This keeps the application free, reliable, explainable, and usable without exposing an API key. Submitted code is not executed or uploaded to an external AI API.

Assessment progress is stored temporarily in the browser using sessionStorage, allowing students to refresh the page without losing their current progress.

Challenges we faced

One major challenge was generating useful questions from many different styles of code without executing the student’s program.

We also had to prevent false detections—for example, distinguishing a normal function call from actual recursion and identifying edge cases only when supported by concrete evidence in the code.

Another challenge was designing fair scoring. Early versions rewarded answer length too heavily. We replaced this with a multi-dimensional system that rewards accurate, code-specific explanations and rejects irrelevant or keyword-stuffed answers.

We also improved the follow-up system so weak answers cannot silently skip remediation. The original score, follow-up score, and effective improved score are now preserved in the final report.

What we learned

We learned that an educational assessment platform needs more than correct questions. It also needs transparent scoring, meaningful feedback, recovery from weak answers, accurate state management, privacy safeguards, and a clear learning path after the assessment.

Codex helped us move from an initial idea to a complete deployed product while continuously testing, debugging, and improving the implementation.

What's next

Future versions of CodeSense could include:

  • Optional GPT-powered semantic evaluation
  • Learn Mode for programming languages
  • Voice-based practical examinations
  • Multi-file project analysis
  • Teacher dashboards
  • Student progress tracking
  • Downloadable reports
  • Classroom assessment management

Built With

Share this project:

Updates