Bug2Skill

About Bug2Skill

Learning DSA is rarely difficult because students cannot access explanations or practice problems. The harder problem is knowing what to learn when you get stuck.

Platforms can tell a student that their solution is wrong, but a wrong answer can have many causes. A student failing a Two Sum problem might not actually have a problem with Two Sum—they may be struggling with hash maps, time complexity, array traversal, or even a prerequisite concept they have not mastered yet.

This inspired Bug2Skill: a conversational learning system that treats coding mistakes as learning signals rather than failures.

Instead of simply giving students the correct solution, Bug2Skill analyzes their coding attempts and questions, identifies the underlying concept associated with the mistake, traces it through prerequisite skills, and adapts what the student sees next.

For example:

Student fails → Two Sum
        ↓
Detected difficulty → HashMap lookup
        ↓
Prerequisite check → Key-value mapping
        ↓
Targeted explanation + micro-exercise
        ↓
New problem
        ↓
Mastery updated

The goal is to create a dynamic skill map for every learner rather than forcing every student through the same DSA roadmap.

What We Learned

While researching the project, we found that programming chatbots and AI coding tutors already exist. This changed our approach: the innovation could not simply be “an AI tutor for DSA.”

Research around knowledge tracing and adaptive programming education showed us that a learner's interactions, questions, and performance can provide signals about their evolving knowledge state. We therefore focused Bug2Skill on the gap between detecting an incorrect answer and understanding the reason behind it.

How We Built It

Bug2Skill is designed as a conversational learning experience through Telegram, making the system accessible without requiring students to learn another complicated platform.

The system consists of:

• Problem Engine — delivers DSA problems at different difficulty levels.
• Error Analyzer — examines incorrect attempts and identifies likely concepts involved.
• Skill Graph — represents DSA concepts and their prerequisite relationships.
• Learner Model — maintains an evolving estimate of the student's mastery.
• Adaptive Tutor — chooses whether the student needs a hint, prerequisite explanation, micro-exercise, or another problem.
• Progress Tracker — records skill progression rather than simply counting solved problems.

The core loop is:

Attempt → Diagnose → Remediate → Reattempt → Update Skill Model

Challenges

One of the biggest challenges was avoiding the temptation to let an LLM simply generate an explanation for every mistake. That approach can make students dependent on the system instead of helping them develop problem-solving ability.

We therefore designed Bug2Skill around progressive assistance: identify the likely gap, provide the smallest useful intervention, test whether the student understood it, and only then move forward.

Another challenge was distinguishing a genuine knowledge gap from a simple implementation mistake. A syntax error, an incorrect algorithm, and a missing prerequisite should not produce the same learning response. This led us to treat errors as evidence that needs to be interpreted in context rather than as simple right/wrong labels.

Our Vision

Bug2Skill is built around a simple idea:

A wrong answer should not end the learning process. It should start the diagnosis.

Instead of asking students to solve more and more problems, Bug2Skill aims to help them understand why they cannot solve the problem yet—and what skill they need to develop next.

Every bug becomes a signal. Every signal becomes a skill.

Built With

• cursor
• emergent
• react
• telegram-bot