IssuePilot: Local AI-Powered Bug Triage | Hacktoberfest Week 2

Chaitanya Patil — Sat, 17 Oct 2026 08:14:48 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Bug reports are often incomplete, unclear, or missing the steps needed to reproduce a problem. Developers spend valuable time turning these reports into something actionable before they can even begin debugging.

IssuePilot is a bug-triage tool that uses locally running AI models to turn bug descriptions, screenshots, and logs into structured reports.

It generates:

A clear bug title and severity
A concise issue summary
Steps to reproduce the problem
Expected and actual behavior
Missing information that could help investigate the issue
Suggested next steps

Developers can also use IssuePilot to create GitHub issues from the generated reports.

I built it for individual developers and small development teams who want to reduce repetitive bug-triage work without depending on a paid, hosted AI inference API.

The long-term idea is simple: spend less time formatting bug reports and more time fixing bugs.

Demo

Video demo: [Watch IssuePilot in action]

The demo walks through the application's bug-analysis workflow and shows how the generated report can be used.

Code

GitHub repository: [See IssuePilot Source Code]

The repository contains the application source code and setup instructions.

How I Built It

IssuePilot combines a Java backend, a React frontend, and locally running open-weight AI models.

Technology stack:

Java and Spring Boot : backend API and application logic
React and Vite : frontend interface
Ollama : running the AI models locally
Qwen2.5:1.5B : text-based bug analysis
Qwen2.5-VL:3B : analysis involving screenshots and visual evidence
Docker Compose : running the application's services
GitHub REST API : creating GitHub issues

The frontend sends bug descriptions or supporting evidence to the Spring Boot backend. The backend uses the appropriate local model through Ollama and returns a structured triage report. Users can review that report and create a GitHub issue when they're ready.

The AI output is intended to assist developers, not replace their judgment. Generated severity levels, reproduction steps, and recommendations should be reviewed before being used.

Why Does Open Innovation Matter?

For a tool that analyzes potentially sensitive bug reports, I wanted local AI inference to be a real option rather than an afterthought.

Open-weight models made it possible to experiment with text and vision capabilities without making a paid, hosted inference API a requirement. With the models downloaded, IssuePilot can perform its AI analysis locally, without sending the analysis request to an external AI inference provider.

Open innovation also gives developers more control over which models they run, how they configure the application, and how they adapt it to their workflows.

This matters especially for smaller teams and independent developers who may not have the budget for another recurring AI service.

Local inference does not automatically make an entire application offline: GitHub issue creation still requires network access, and users should be careful about the evidence they submit. But having the AI analysis run locally is a meaningful step toward giving developers more control over their tools and data.

IssuePilot is my attempt to explore how open AI models can solve a practical software-development problem, rather than being used just for a demonstration.

My Agent Session

I haven't included a DevRelay agent-session link in this submission.

Prize Categories

Hacktoberfest Open-Source AI Challenge : Week 2: Side Hustle

Reality Remix : Turn Your Surroundings Into a Real-World Challenge

Chaitanya Patil — Thu, 08 Oct 2026 06:59:06 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Reality Remix is an open-source AI app that turns a photo of your surroundings into a short real-world challenge.

Take a photo of what's around you, and Reality Remix uses a local vision model to understand the environment and create a physical-world challenge based only on what it can actually see.

Instead of giving you another screen-based activity, it gives you a reason to look up, move around, explore, and interact with the world around you.

The idea is simple:

Take a photo → Get a challenge → Put the phone down → Touch grass.

The project is designed for anyone who wants a small reason to step away from their screen and interact with their physical surroundings.

Demo

Watch the demo on YouTube

The demo shows the complete flow:

Upload a photo → AI analyzes the surroundings → Receive a real-world challenge → Ask follow-up questions through the challenge chat.

Code

The complete source code is available on GitHub:

https://github.com/chaitanya2850/Reality-Remix

The repository also includes the setup instructions for running the local AI model with Docker and Ollama.

How I Built It

Reality Remix is built with:

React for the frontend
Spring Boot for the backend
Ollama for local AI inference
Gemma 3 4B for vision and challenge generation
Docker to run Ollama

The frontend sends an image to the Spring Boot backend.

The backend sends the image to Gemma through Ollama. Gemma analyzes the visible environment and generates a challenge based only on what it can see.

The generated challenge is then returned to the React frontend.

I also built a persistent chat for each challenge. Users can ask questions about the current challenge and continue the conversation without losing previous messages.

The core AI inference happens locally rather than relying on a proprietary cloud AI API.

Why Does Open Innovation Matter?

Open innovation is important to Reality Remix because the project is built around local AI.

Using an open-weight model and an open-source inference runtime means the user's image can be processed on their own machine instead of being sent to a proprietary AI service.

That matters for Reality Remix because the input is a photo of someone's physical surroundings. Keeping that image under the user's control is a much better fit for the idea.

It also makes experimentation easier. The model, prompts, and AI behavior can be inspected and changed, and different models can be tested through Ollama without redesigning the application.

A closed AI API could provide similar vision capabilities, but the open approach gives the project more control over how the AI runs, how the model is used, and where the user's data goes.

Most importantly, the open components aren't just an implementation detail. Local AI is what makes the core experience possible without depending on a proprietary AI service.

Prize Categories

Best Use of Gemma

Reality Remix uses Gemma 3 4B as the core vision model that analyzes the user's surroundings and turns what it sees into real-world challenges.

Gemma runs locally through Ollama, making the model an integral part of the application's core experience.

DEV Community: Chaitanya Patil

IssuePilot: Local AI-Powered Bug Triage | Hacktoberfest Week 2

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

Reality Remix : Turn Your Surroundings Into a Real-World Challenge

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Best Use of Gemma