CodeBuddy: An AI That Helps You Solve Coding Problems Without Spoiling Them

What I Built

I built CodeBuddy, a Socratic competitive-programming practice partner powered by open-weight AI.

I built it around a problem I've experienced while practicing competitive programming: when you get stuck on a problem, asking an AI for the complete solution is often the easiest option.

You get the answer, but you don't necessarily get better at solving the next problem.

CodeBuddy takes a different approach.

Instead of immediately revealing the solution, it helps the learner reason through the problem using progressively stronger hints:

Problem → Think → Small Hint → Stronger Hint → Key Idea → Solution

The learner can provide a problem and describe their current approach. CodeBuddy then acts as a practice partner rather than simply providing an answer.

I also built a C++ code-review mode that analyzes submitted code for correctness, potential issues, edge cases, and time and space complexity.

The goal is simple:

Help someone learn how to solve the problem instead of solving the problem for them.

Demo

The project is currently available as a working local MVP.

Repository: https://github.com/ayushtripathi15567/CodeBuddy

The repository contains the complete frontend, backend, model integration, setup instructions, and deployment configuration.

Code

GitHub: https://github.com/ayushtripathi15567/CodeBuddy

The project is built with React/Vite on the frontend and Flask on the backend.

How I Built It

The core AI component is designed around Gemma, Google's open-weight model.

The application is structured as:

User
  ↓
React / Vite Frontend
  ↓
Flask Backend
  ↓
Gemma
  ↓
Hint / Code Review

I designed the prompting behavior around a Socratic tutoring approach.

For example, instead of asking the model to simply solve a problem, CodeBuddy can ask it to provide a single subtle hint without revealing the complete algorithm.

The user can then request a stronger hint or the key idea when they need more help.

The code-review workflow asks the model to analyze C++ submissions for:

• Correctness
• Potential bugs
• Edge cases
• Time complexity
• Space complexity
• Possible improvements

The project also keeps the model layer replaceable, allowing the inference setup to evolve as different open-weight models become available.

Why Does Open Innovation Matter?

For CodeBuddy, the AI model is not just a black-box API.

The behavior of the tutor is the product.

I want to be able to control how the AI teaches, how much information it reveals, how it gives hints, and how it reviews a learner's reasoning.

Using an open-weight model makes that much more flexible.

It gives me the ability to:

• Experiment with different open models.
• Change the tutoring behavior and prompts.
• Move toward local inference.
• Reduce dependence on a single closed AI provider.
• Potentially keep a learner's code and practice data local.

That flexibility is especially useful for a project like CodeBuddy because it is designed around a very specific person and their learning style rather than a generic AI chatbot.

Open innovation makes it possible to keep adapting the tool around the learner.

My Agent Session

Not included in this submission.

Prize Categories

Gemma — Best Use of Gemma

CodeBuddy uses Gemma as the open-weight AI model at the core of its tutoring and code-review workflows.

---

Building CodeBuddy made me think differently about what an AI coding assistant should do.

The fastest assistant isn't always the best teacher.

Sometimes the better assistant is the one that gives you just enough of a hint to make you solve the problem yourself.