SlothFix: A Local AI Debugger That Thinks Beyond the Error

Nikitha Bhandari — Sun, 25 Oct 2026 06:38:54 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

Debugging can take longer than fixing the actual bug. First you have to understand the error, figure out why it happened, work out the safest change, and then consider what that change might break elsewhere.

I built SlothFix, a local-first AI debugging assistant that brings those steps together in one place.

You provide a code snippet and an error or unexpected behavior. SlothFix uses a locally running Gemma model to help explain the root cause, suggest a minimal patch, identify possible downstream effects, and generate a regression test suggestion.

The part I wanted to focus on was what happens after the immediate fix. A change might resolve an exception but still affect a caller, an API response, or a data-handling path. SlothFix's “Butterfly Effect” analysis is meant to help developers think about those possibilities before applying a change.

The goal isn't to replace debugging skills or code review. It's to reduce the repetitive work involved in understanding a bug and give developers a useful starting point.

Demo

SlothFix currently runs locally using Streamlit and Ollama.

🎥 Watch the demo: https://screenapp.io/app/share/psRvllgVdgdIQdla12LRKOeY

📸 Screenshots:

Note: The app currently runs locally, so viewers need to follow the setup instructions to run it themselves.

Project repository: SlothFix on GitHub

A screenshot or short recording of the app can be added here to show the debugging workflow in action.

Code

GitHub repository:

https://github.com/nikkisbhandari123-coder/slothfix

The repository includes the application code, setup instructions, and automated tests.

Setup guide: https://github.com/nikkisbhandari123-coder/slothfix#readme

The project is written in Python and organized into separate modules for the interface, model communication, debugging logic, prompts, and response parsing.

The automated test suite currently passes 13 tests covering the debugging service and response parser.

How I Built It

I built SlothFix with Python, Streamlit, Ollama, and Google's Gemma model.

Streamlit provides the interface. The debugging service prepares the request, the Ollama client communicates with the local model, and the response parser organizes the generated result into sections that are easier to review.

I also separated the interface into reusable components instead of keeping everything in one large application file. This makes the project easier to maintain and gives the individual pieces their own tests.

One design decision was to keep the debugging workflow focused on generating suggestions. SlothFix does not automatically execute submitted code or generated tests on the host machine. The proposed patch and regression tests still need to be reviewed and tested separately.

Why Does Open Innovation Matter?

For a debugging tool, the code being analyzed can be the most sensitive part of the request.

Sending source code and stack traces to a hosted AI service may not be appropriate for every developer or organization. Running Gemma through Ollama gives SlothFix a local inference path, so the code sent to the model stays within the local application and Ollama setup rather than being sent to a cloud AI API by SlothFix.

Open-weight models also give developers more control over the model they run and the environment in which they run it. Once the model and dependencies are installed, the core workflow can operate without cloud inference or an internet connection.

That doesn't automatically make every local setup secure, and the quality of the results still depends on the model. But it makes local AI-assisted debugging a practical option for people who want more control over their code and tools.

The Lazy Payoff

The payoff I'm aiming for is less time spent switching between an error message, a debugging explanation, a proposed fix, and a test-writing step.

Instead of starting from scratch for each of those tasks, a developer gets a structured first pass in one place. They can then spend their time checking the reasoning and deciding whether the change is safe.

I haven't measured a reliable time-saving figure yet, so I won't claim a specific number. The next step is to try it against a set of real debugging cases and compare how useful its explanations, patches, and test suggestions are.

Prize Categories

Best Use of Gemma — SlothFix uses Google's Gemma model through Ollama for local debugging assistance.

DEV Community: Nikitha Bhandari