Errly — AI Debugging Companion

Inspiration

As a Computer Science student, I've experienced how frustrating programming errors can be, especially when you're still learning a language or encountering an unfamiliar concept. Error messages often tell you what went wrong, but not necessarily why it happened or how to prevent it in the future.

Searching online for solutions can be time-consuming, and the answers aren't always explained in a way that beginners can easily understand.

That's why I created Errly - AI Debugging Companion: an open-source VS Code extension designed to make debugging less intimidating and more educational for beginner programmers.

My goal is simple: help people understand their mistakes instead of just copying a solution.

What it does

Errly explains programming errors in plain language, directly inside Visual Studio Code.

When VS Code underlines an error, you click the lightbulb and choose Ask Errly about this error. Errly reads the error and sends it, together with the code from your file, to an NVIDIA Nemotron model running on Nebius Token Factory. The answer opens in a side panel with the same simple structure every time. It starts with your original error, then explains what happened in plain words, why it happened in the context of your own code, and how to fix it in one clear step. It finishes with a short corrected example.

Errors that only appear when you run your code in the terminal are covered too: copy the message and ask Errly, and it fills in the error from your clipboard automatically.

Clicking Suggest a fix makes Errly propose a corrected version of the lines around the error. It opens a side-by-side comparison of your code and the suggestion, and nothing changes in your file unless you click Apply fix. Ctrl+Z undoes it.

There are five ways to start Errly: the lightbulb, the right-click menu, a status bar button, the shortcut Ctrl+K Ctrl+E, and the Command Palette.

I tested Python and JavaScript with both lightbulb errors and pasted terminal errors, and Java and C# with pasted errors. The file's language is passed to the model, so other languages should work too, but those are the four I focused on.

Note: I only tested common errors and small programs. I have not tested Errly with bigger classes or functions/methods, so it may be inaccurate on bigger files. Errly sends at most the first 6,000 characters of a file to the model, so in a very long file the part with the error can be cut off.

How I built it

Errly is a TypeScript extension built on the VS Code Extension API. It uses the model nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B, served by Nebius Token Factory through its OpenAI-compatible API. Errly calls it with a plain fetch request, so it needs no SDK and no backend server of its own.

Two prompts drive the experience. One produces the beginner-friendly explanation in a fixed four-section format, and the other returns only the corrected code for a few lines around the error.

On the VS Code side, a code action provider reads the diagnostics VS Code already produces and powers the lightbulb. The answer panel is a webview that renders the explanation and code blocks, and fixes are applied through a side-by-side comparison and a workspace edit.

For security, the user's API key is kept in VS Code's secret storage, never in a file or the repository.

Challenges I ran into

Getting the explanations right for beginners took the most iteration. My first prompt produced answers that repeated the error message under "What happened?", used jargon, and gave an example that wouldn't actually run. Writing explicit rules for each section and lowering the temperature made the answers far clearer and more consistent.

Finding the errors was another challenge. VS Code only knows about some errors before you run the code, and runtime errors appear only in the terminal, so I added the paste route with clipboard prefill alongside the lightbulb.

Keeping fixes safe mattered too, because a wrong suggestion should never silently damage someone's file. I limited fixes to a few lines around the error (or the user's selection), show them in a comparison first, and keep everything undoable.

I also had to work with a reasoning model. Its response includes a separate reasoning field next to the final answer, so Errly shows only the final content.

Finally, I started this project with almost no experience working with APIs and none at all with making a VS Code extension. I spent some time learning how to set up Git and GitHub, but most of my time went on learning how to make an extension, launch it and package it properly.

Accomplishments that I'm proud of

I'm proud of a working end-to-end flow, from a red underline to an explanation to a reviewed, reversible fix. I built it solo, starting with very little experience of extension development or AI engineering, and it's an open-source, MIT-licensed project that anyone can install from a GitHub release and try. I'm also glad that it keeps the focus on learning: every answer explains why, and the user always stays in control of their code.

What I learned

I learned that a useful AI feature is much more than a model call. The prompt rules, the context sent with the error, the interface and the review step all shaped how helpful Errly actually was.

I also learned that a small model follows explicit instructions well and vague ones less so, and that its output always needs checking before it's used. Errly can be wrong, because the model only reads text and never runs the code, which is why every fix is shown in a comparison first.

On the technical side, I learned how VS Code extensions work: commands, code actions, webviews, secret storage and comparison views.

What's next for Errly

Right now, each user brings their own Nebius Token Factory API key. I'd like Errly to work without one, but that would need a small server in between that holds a shared key, because a key bundled inside the extension could be extracted by anyone. Running that server would cost money, so for now I've kept the bring-your-own-key design.

Beyond that, I'd like Errly to capture terminal errors automatically, let people ask follow-up questions about an error, handle longer files and fixes that span more than a few lines, and be published on the VS Code Marketplace so it can be installed from the Extensions tab.

Built With

• css
• github
• html
• nebiustokenfactory
• node.js
• nvidia-nemotron
• typescript
• vscode