I Built IssueWise: Let AI Do the GitHub Issue Detective Work So You Can Focus on Contributing

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

Have you ever opened a GitHub issue that looked interesting, read through the description, and then realized you had absolutely no idea where to start?

I have.

One minute, you're excited about contributing to an open-source project. The next, you're jumping between the issue description, comments, documentation, and repository files, trying to understand what the problem actually is.

Sometimes, the issue mentions a function you've never seen. Other times, it references a part of the codebase you know nothing about.

And before you've written a single line of code, you've already spent a considerable amount of time investigating.

I've contributed to open-source projects, including Signal Android and Lawnchair, and one thing I've learned is that finding an issue and understanding an issue are two very different things.

GitHub makes it easy to discover issues. Understanding enough about an unfamiliar project to work on one is where things get difficult.

That experience gave me an idea:

What if I could paste a GitHub issue URL into a tool and get a clear explanation of the problem, what I need to understand, and where I should start investigating?

Not something that writes the solution for me, but something that helps me understand the problem before I start writing code.

That's how IssueWise came about.

For this year's Hacktoberfest Slow and Steady challenge, I built IssueWise to handle some of the repetitive investigation involved in understanding GitHub issues, so developers can focus more on contributing.

What I Built

IssueWise is an AI-powered GitHub issue explorer that helps developers understand unfamiliar issues and figure out how to approach them.

The idea is simple.

You paste a public GitHub issue URL, IssueWise retrieves information about the issue and its repository, and Google's Gemma 4 model helps turn that information into a structured explanation.

Instead of getting one long AI-generated response, you get four sections that guide you through the issue.

1. Understand — What exactly is the problem?

Some GitHub issues are written with the assumption that whoever reads them already understands the project.

But what if you don't?

The Understand section breaks down the issue into simpler terms, helping you understand what's happening and why it matters.

It's the first thing I would want to know before attempting any fix.

2. Explore — Where should I start looking?

Understanding the problem is one thing. Knowing where to investigate is another.

The Explore section helps you think through the issue in the context of the project.

IssueWise also provides additional information through expandable sections such as Advanced Analysis, Discussion, and Repository Snapshot.

I wanted this information to be available without overwhelming someone who just wants to understand the basics first.

3. Learn — What should I know before working on this?

Sometimes, an issue introduces concepts you've never encountered.

You might understand what needs to change but still need to learn how a particular framework, component, or programming concept works.

The Learn section explains relevant concepts to help you build that understanding.

This is especially useful for developers who are still learning or contributing to a particular project for the first time.

4. Contribute — How do I get started?

This is where everything starts coming together.

The Contribute section helps you approach the issue with a clearer idea of what to investigate and how to proceed.

It doesn't replace reading the code, testing your changes, or following the project's contribution guidelines.

It simply helps you get past that initial feeling of being lost.

IssueWise doesn't write the contribution for you. It helps you understand what you're contributing to.

And that was exactly what I wanted to build.

Demo

IssueWise is live, and you can try it yourself.

🚀 Try IssueWise

Here's how it works:

1. Open the IssueWise website.
2. Paste a public GitHub issue URL.
3. Click Explore Issue to retrieve the issue details.
4. Click Explain This Issue to generate an explanation using Gemma 4.
5. Explore the Understand, Explore, Learn, and Contribute sections.

That's all you need to get started.

I tested IssueWise using real issues from open-source repositories, including Signal Android and Flask.

Here's a look at the application.

The homepage

Everything starts with a GitHub issue URL. No complicated setup or lengthy instructions.

Exploring an issue

IssueWise retrieves the issue details and presents them in a way that's easier to explore.

Understanding the issue with AI

This is my favorite part.

Instead of reading an issue and wondering what to do next, you have a structured explanation to help you understand the problem and begin investigating.

The application is hosted on Render's free services, so the first request may take a little longer if the server has been inactive.

Code

IssueWise is open source, and the complete source code is available on GitHub.

💻 View IssueWise on GitHub

I organized the project as a monorepo, with the frontend and backend in separate applications.

issuewise/
├── apps/
│   ├── api/       # FastAPI backend
│   └── web/       # Next.js frontend
├── docs/          # Documentation
└── README.md

The repository includes the application code, tests, and documentation.

You can explore how it works, run it locally, or contribute improvements.

Since IssueWise is designed to help people contribute to open source, I felt it was important to make the project open source too.

How I Built It

I wanted IssueWise to feel simple to use, even though there's quite a bit happening behind the scenes.

I used Next.js for the frontend, FastAPI for the backend, PostgreSQL for storing application data, and Gemma 4 for the AI explanations.

Here's the stack:

Technology	What I used it for
Next.js + TypeScript	Frontend application
Tailwind CSS	Styling and responsive interface
Python + FastAPI	Backend API
PostgreSQL	Database
Alembic	Database migrations
Gemma 4 26B A4B IT	AI-powered issue explanations
Google AI Studio	Hosted model inference
GitHub API	Retrieving issue and repository information
Render	Hosting the application

Why I chose Gemma 4

I wanted to build something where open-weight AI was an important part of the product, not just an extra feature.

IssueWise uses Google's Gemma 4 26B A4B IT model to generate explanations from GitHub issue context.

The GitHub API provides the issue information, but that information alone isn't always enough to help a newcomer understand what to do.

Gemma helps turn it into something more useful: an explanation of the problem, relevant concepts, possible investigation directions, and guidance for getting started.

Without that AI layer, IssueWise would mostly be another interface for reading GitHub issues.

The explanation is what makes the experience different.

How it works behind the scenes

When someone submits a GitHub issue URL, the frontend sends the request to the FastAPI backend.

The backend retrieves the issue and relevant repository context from GitHub.

That context is then used by the AI explanation pipeline, which generates the information displayed in the four main sections.

The process looks like this:

        GitHub Issue URL
               |
               v
     Fetch Issue Information
               |
               v
        FastAPI Backend
               |
               v
      Gemma 4 AI Model
               |
               v
      Structured Explanation
               |
               v
    Understand | Explore
      Learn | Contribute

I also implemented caching.

When an explanation has already been generated and stored, IssueWise can reuse it instead of making another unnecessary AI request.

This helps avoid repeating work and makes previously analyzed issues quicker to revisit.

I think that's a good fit for the Slow and Steady theme: if you've already done the work once, why do it all over again?

Making the interface easy to use

One thing I wanted to avoid was building an application that gives you another wall of technical information to read.

That would defeat the purpose.

So I organized the explanation into four sections and kept more detailed information inside expandable panels.

You can start with the basics and explore further when you're ready.

The goal was to make the experience useful without making it feel complicated.

Testing and deployment

I also spent time testing the frontend and backend to make sure the different parts worked together.

Once the application was ready locally, I deployed it using Render.

The frontend, backend, and PostgreSQL database are hosted as separate services.

Getting everything working in production took some effort, especially configuring environment variables, connecting the database, running migrations, and making sure the frontend could communicate with the API.

At one point, the backend wouldn't start because the production database didn't have the required tables.

I had to run the Alembic migrations against the hosted database before the application could start successfully.

It was a useful reminder that an application working locally doesn't automatically mean it's ready for production.

Eventually, everything came together.

Seeing IssueWise retrieve a real GitHub issue and generate an explanation from the live website made the work worthwhile.

Why Does Open Innovation Matter?

One of the reasons I enjoy open-source development is that it gives people the opportunity to learn from real projects.

You can read the code, understand how something works, suggest improvements, and contribute to software that other people use.

But there's a difference between having access to source code and understanding it.

That's part of what inspired IssueWise.

I wanted to build something that could make open-source projects a little more approachable, especially for developers who are still gaining experience.

Using Gemma also fits into that idea.

More freedom to experiment

Gemma is an open-weight model family, which means developers have options beyond relying exclusively on a closed model API.

With suitable hardware and infrastructure, open-weight models can be deployed and experimented with in different environments.

For a project like IssueWise, that opens up interesting possibilities.

Different programming languages, repositories, and technical problems may benefit from different models or specialized approaches.

I like the idea of being able to experiment with the AI layer as the project grows.

Being realistic about the current implementation

The deployed version of IssueWise uses Google AI Studio for inference.

So, while Gemma is an open-weight model, IssueWise currently relies on a hosted service to run it.

It doesn't run entirely offline, and I'm not claiming that it does.

However, using an open-weight model means there are other deployment possibilities worth exploring in the future, including self-hosted inference.

For me, that's one of the practical benefits of open innovation: having more choices about how a project can evolve.

Helping more developers participate

I also believe that open source becomes more valuable when more people can participate.

Not everyone has years of experience working with large codebases.

Sometimes, all someone needs is a clearer explanation or a better starting point.

If IssueWise helps even a few developers feel more confident exploring unfamiliar issues, then it's solving a problem I care about.

Making code public is important. Helping people understand that code matters too.

The Lazy Payoff

The theme for this challenge is Slow and Steady, and I think IssueWise fits it quite well.

Because sometimes being productive isn't about working harder.

It's about finding ways to avoid unnecessary work.

Before building IssueWise, understanding an unfamiliar GitHub issue could involve reading the description several times, checking the comments, exploring the repository, searching unfamiliar concepts, and trying to connect everything together.

None of those activities is necessarily difficult on its own.

But together, they can take a lot of time, especially when you're new to a project.

With IssueWise, the process becomes:

Paste the issue URL → Explore → Explain → Start investigating.

The application brings the initial information-gathering and explanation process into one workflow.

I've tested it with real GitHub issues and verified that the deployed application can retrieve issue information and generate explanations.

I haven't conducted a formal study to measure exactly how much time it saves, so I won't make up a number.

But the practical benefit is clear: instead of repeatedly collecting context and asking separate questions, you get a structured starting point in one place.

And for me, that's the kind of laziness worth encouraging.

Let the tool handle some of the repetitive investigation.

Save your energy for understanding the code, testing your ideas, and making a useful contribution.

What I Learned

Building IssueWise taught me a few things.

First, integrating an AI model is only one part of building a useful AI application.

You also need to think about the information the model receives, how the output is organized, what happens when requests fail, and how people will actually use the result.

Second, a good interface can make a big difference.

Even a useful explanation becomes difficult to follow if everything is presented at once.

Breaking the experience into smaller sections helped me keep the application focused on what the developer needs at each stage.

And finally, I was reminded that it's better to solve one real problem properly than to build a long list of features that don't necessarily help anyone.

There are plenty of things I'd like to improve in IssueWise over time.

But for this challenge, I wanted to focus on one question:

Can I make it easier for someone to go from finding an unfamiliar GitHub issue to understanding how to approach it?

That's the problem IssueWise is built around.

Prize Categories

I'm submitting IssueWise for two partner categories.

Best Use of Gemma

IssueWise uses Gemma 4 26B A4B IT to generate structured explanations of GitHub issues.

The model powers the main experience, helping developers understand problems, learn relevant concepts, and identify where to begin investigating.

Best Use of Render

I used Render to deploy the complete application, including the Next.js frontend, FastAPI backend, and PostgreSQL database.

Render makes IssueWise publicly accessible so other developers can try it without setting up the project locally.

Final Thoughts

I don't think AI should do all the thinking for developers.

And I don't think contributing to open source should mean asking an AI model to generate code you don't understand.

But I do think AI can help remove some of the unnecessary friction that makes contributing feel difficult.

Sometimes, the hardest part of fixing an issue isn't writing the code.

It's understanding the problem well enough to know where to begin.

That's what I'm trying to make easier with IssueWise.

If you've ever opened a GitHub issue and wondered where to start, give it a try.

🚀 Try IssueWise

💻 Explore the source code on GitHub

I'd love to hear what you think, especially if you've experienced the same challenges while contributing to open source.

And if you find something that could be improved, the repository is open for contributions too.

Happy Hacktoberfest! 🎃