I Built AlgoBuddy: An Open-Weight AI DSA Mentor That Teaches, Not Just Solves

This is my submission for the Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle.

What I Built

I built AlgoBuddy, a personal Data Structures and Algorithms (DSA) mentor designed to help students understand how to solve problems instead of simply copying solutions.

The idea came from a familiar frustration: getting stuck on a DSA problem, looking at the solution, understanding it for a moment, and then getting stuck again on the next problem.

I wanted to build something that encourages learners to think independently.

AlgoBuddy follows one simple philosophy:

Think first. Hint second. Solution last.

It offers three learning modes:

• Problem Mode: Work through a DSA problem step by step, from understanding the constraints to exploring an approach.
• Concept Mode: Learn concepts and understand the reasoning behind them.
• Code Mode: Discuss code, review approaches, and understand mistakes instead of blindly accepting corrected code.

Demo

🚀 Live Demo: https://algo-buddy-gamma.vercel.app/

💻 GitHub Repository: https://github.com/hrishu802/AlgoBuddy

You can explore the application and try its different learning modes.

Code

AlgoBuddy is open source, and the source code is available on GitHub:

https://github.com/hrishu802/AlgoBuddy

The project uses React, TypeScript, and Vite for the frontend, with a server-side API layer for AI inference.

The AI provider is configurable, allowing the application to work with hosted inference rather than requiring every user to run a large language model locally.

How I Built It

I built AlgoBuddy using React, TypeScript, Vite, and a server-side API architecture.

One important part was designing an AI service abstraction so that the learning experience would not be tightly coupled to a single model provider.

For hosted inference, I integrated OpenAI's open-weight GPT-OSS-20B model through Groq Cloud. I also preserved Hugging Face support and a deterministic mock provider for development and fallback scenarios.

The integration keeps API credentials on the server instead of exposing them in the frontend bundle.

I also worked on error handling, persistent settings, testing, and deployment so the project could run as a real web application rather than just a local prototype.

Why Does Open Innovation Matter?

Open innovation makes powerful AI models more accessible to independent developers and students.

I wanted to experiment with an AI-powered learning tool without needing to train a model from scratch or operate expensive GPU infrastructure.

Using an open-weight model through a hosted inference provider made it possible to focus on what matters most for AlgoBuddy: the learning experience, the interaction design, and the teaching approach.

It also gave me the flexibility to experiment with different providers without rebuilding the entire application.

For me, open source is not just about publishing code. It is about giving other developers something they can inspect, learn from, adapt, and improve.

My Agent Session

I used an AI-assisted development workflow to build and improve AlgoBuddy, from working on the AI integration to testing and deployment.

Rather than treating AI as a one-shot code generator, I used an iterative process:

1. Inspect the existing code and architecture.
2. Implement changes while preserving the application's learning philosophy.
3. Run TypeScript checks, tests, linting, and production builds.
4. Investigate integration failures and fix their underlying causes.
5. Verify the deployed application with real HTTP requests.

One lesson I learned was that a successful build does not necessarily mean a working application. My Groq integration initially encountered deprecated model IDs, so I updated the model configuration, added migration handling for saved settings, and verified that live inference worked in production.

That process reinforced the importance of testing the entire path from the frontend to the actual AI provider.

Challenges and What I Learned

The biggest challenge was not simply connecting an AI model. It was making the integration reliable without losing the original purpose of the project.

I learned the importance of separating the AI service from the user experience, keeping credentials server-side, handling provider errors clearly, and testing changes before deploying them.

I also learned that an AI learning tool should not optimize only for giving the fastest answer. It should help the learner understand why an approach works.

What's Next?

I want to keep improving AlgoBuddy's teaching quality, make its hints more adaptive, and help learners build stronger problem-solving habits over time.

I'd also love feedback from students and developers who use AI tools to learn DSA.

If you try AlgoBuddy, I'd love to know: would you prefer an AI mentor that gives you the answer immediately, or one that helps you discover the answer yourself?

Thanks for checking out my project! ❤️