I Built StackTrace Sloth: A Calmer Way to Understand Programming Errors 🦥

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

What I Built

I built StackTrace Sloth 🦥, a beginner-friendly AI debugging assistant that helps developers understand confusing error messages without spending too much time searching for explanations.

You can paste a Python error or traceback, and the application generates a plain-English explanation, identifies the likely cause, and suggests practical debugging steps.

I wanted to make debugging feel less frustrating, especially for beginners who are still learning how to interpret errors.

The idea behind the project is simple: spend less time struggling to understand an error and more time learning how to fix it.

Demo

Local demo: The application currently runs on my computer.

I'll include a screenshot or short screen recording showing how StackTrace Sloth analyzes an error .

Demo link: https://drive.google.com/file/d/18p2HuNBh7gKllrKSCIH8XKpjD6NWrocJ/view?usp=sharing

Code

GitHub repository: https://github.com/Shreyansh2025/stacktrace-sloth

The repository contains the FastAPI backend, frontend, setup instructions, and the code that connects the application to the local AI model.

How I Built It

I built StackTrace Sloth using:

• Python for the backend.
• FastAPI for the API.
• Ollama to run the model locally.
• Gemma 3 1B to generate debugging explanations.
• HTML, CSS, and JavaScript for the frontend.

The workflow is straightforward:

1. The user pastes an error message into the web interface.
2. FastAPI receives the error text.
3. The backend sends it to Ollama running locally.
4. Gemma generates an explanation and suggested debugging steps.
5. The frontend displays the result.

The application analyzes error text rather than executing the submitted code.

Why Does Open Innovation Matter?

I chose an open-weight model because I wanted to explore AI without depending on a third-party AI API for every request.

Running Gemma locally through Ollama gives this project several advantages.

Privacy: Error logs can contain file paths, code snippets, and other sensitive information. Local inference allows analysis without sending those logs to an external AI API.

Control: Developers can choose which compatible model to run and experiment with different models as the project evolves.

Offline use: Once the model and required dependencies are installed, the application can perform inference without an internet connection, provided the local services are running.

Learning: Using a local model helped me understand how an AI model, backend API, and frontend work together.

Local inference also has trade-offs. It consumes memory and processing power, and the model may generate incorrect suggestions. Its explanations should be treated as guidance, not guaranteed fixes.

For me, open innovation means having more control over how AI tools work, where data goes, and how they can be improved.

Prize Categories

• Best Use of Gemma — $200

I'm entering this category because Gemma is the core model used to generate the debugging explanations in StackTrace Sloth.

devchallenge #hf26challenge