This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady
What I Built
BugLens AI — See the Bug. Understand the Cause. Fix with Confidence.
Debugging is one of the most time-consuming parts of programming. A small mistake in a loop, an incorrect condition, or a confusing compiler error can leave developers staring at the same code for hours.
That's why I built BugLens AI, an AI-powered debugging assistant designed to make debugging simpler, faster, and more educational.
With BugLens AI, users can select C++ or Python, enter a problem statement and their code, and optionally provide compiler errors, actual output, and expected output. The application sends this information to an AI-powered backend that analyzes the code, identifies potential bugs, explains possible causes, and suggests corrections.
Instead of repeatedly searching the internet or guessing what went wrong, users can get a structured analysis that helps them understand their mistakes and learn how to fix them.
Who gets to be lazier? Students, competitive programmers, beginners, and developers who want to spend less time hunting for bugs and more time learning and building.
The goal isn't to encourage blindly copying AI-generated solutions. It's to make debugging less frustrating while helping developers understand the reasoning behind a potential fix.
Demo
Live Demo:
Video Demo:
2026-10-25 14-25-16.mp4 - Google Drive
drive.google.com
The demo introduces the BugLens AI interface and shows how users can submit their debugging information and explore the AI-generated analysis.
Code
GitHub Repository:
BugLens AI 🔍🐞
See the Bug. Understand the Cause. Fix with Confidence.
BugLens AI is a complete, modern, open-source AI debugging workbench built for software engineers, students, and competitive programmers. It transforms opaque runtime exceptions, syntax errors, and "Wrong Answer" verdicts into structured, beginner-friendly diagnostic reports with surgical code corrections and sandboxed execution verification.
Developed for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady, BugLens AI uses 100% local open-weight coding models via Ollama (e.g., qwen2.5-coder:7b, deepseek-coder:6.7b, codellama:7b). Your source code and problem statements never leave your machine—no paid cloud AI API keys required.
📑 Table of Contents
The repository contains the source code for the frontend and backend, along with the configuration needed to run and deploy the application.
How I Built It
I built BugLens AI to explore how AI can solve a practical programming problem while making the debugging process more approachable for learners.
Technology Stack
- Frontend: React, Vite, TypeScript, and Tailwind CSS.
- Backend: Python and FastAPI.
- AI integration: Groq API using the official Python SDK.
-
AI model:
openai/gpt-oss-120b. - Deployment: Vercel for the frontend and Render for the backend.
How It Works
- Enter the problem: The user selects a programming language and provides the problem statement and source code.
- Add debugging details: The user can include compiler errors, actual output, and expected output to give the analysis more context.
- Analyze the code: The FastAPI backend communicates with the configured AI model through the Groq API.
- Understand the issue: The application presents the generated analysis, including potential bugs, explanations, and suggested corrections.
One of my goals was to make the application available through a live website rather than leaving it as a project that only runs on my computer.
Deploying the frontend and backend separately also gave me practical experience with environment variables, API communication, CORS configuration, deployment settings, and troubleshooting production issues.
Getting the application deployed was an important part of the journey. I had to identify and fix a frontend API configuration issue before the deployed website could communicate correctly with the backend.
That experience reminded me that building an application involves more than writing code. It also requires testing, debugging, configuration, and persistence.
Why Does Open Innovation Matter?
Open innovation allows developers to learn from existing tools, experiment with new technologies, and build solutions that others can inspect, improve, and adapt.
For a project like BugLens AI, open-source development makes it possible for other developers to explore the application architecture, understand how the frontend communicates with the backend, and experiment with different AI integrations.
AI tools can help accelerate development, but the real value comes from understanding how the pieces work together and turning an idea into a usable application.
As a student and developer, building BugLens AI has given me an opportunity to explore AI integration, backend development, deployment, and the practical challenges involved in bringing a project online.
I hope the project can help make debugging less intimidating for beginners and inspire other developers to experiment with AI-powered tools of their own.
The Lazy Payoff
Imagine spending 20 minutes checking the same loop, searching for an off-by-one error, or trying to understand a confusing compiler message.
BugLens AI aims to shorten that frustrating process by bringing code analysis, possible explanations, and suggested fixes together in one place.
Of course, AI-generated suggestions are not guaranteed to be correct. Developers should review the explanations, verify the proposed changes, and test their code before relying on a fix.
The real payoff isn't avoiding the learning process. It's spending less time stuck on the same problem and more time understanding algorithms, solving programming challenges, and building projects.
BugLens AI is built around one simple idea: spend less time hunting for bugs and more time becoming a better developer.
Top comments (0)