DEV Community: Golor Abraham AjiriOghene

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

Golor Abraham AjiriOghene — Mon, 26 Oct 2026 06:50:50 +0000

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:

Open the IssueWise website.
Paste a public GitHub issue URL.
Click Explore Issue to retrieve the issue details.
Click Explain This Issue to generate an explanation using Gemma 4.
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! 🎃

I built an offline AI that warns my mum about scam messages.

Golor Abraham AjiriOghene — Mon, 05 Oct 2026 05:51:37 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

My mum is a trader. She owns a shop where she sells food items.

On her birthday, my siblings surprised her with a brand new smartphone. Her first ever smartphone. She never really liked smartphones. She complained that it would take her a long time to get used to one, and that she preferred her button phone. But button phones don't have social media, calls on social media are cheaper, and we wanted her to enjoy the fun that comes with it. So we ignored her complaints and got her the smartphone anyway.

Then I noticed a problem. She started getting so many fake messages, especially forwarded messages on WhatsApp. She would even forward them to me and ask if MTN was really doing a promo, or if MTN was really giving out freebies for its anniversary. Every time, I told her it was a scam. But after a while I got tired, because I can't check every single message she gets.

That's where the idea came from. What if she had a buddy on her phone that could tell her, "This SMS is a scam, don't do it"? Or, "Be careful with this WhatsApp message from Amaka. Don't do anything until you ask your son."

That buddy is what I built this weekend. I called it ScamGuard.

It isn't just my mum

I wanted to know if other families had the same problem, so I made a short survey and shared it on LinkedIn. Eleven people answered for their parents (you can see the responses here). That's not a lot of people, but the answers said a lot.

All eleven said their parents use an Android phone. Eight said their parents had clicked a fake link before, the "MTN 50th anniversary, click here to redeem" kind. Five said their parents had already been scammed. Only two said their parents check whether what they see online is true, and only one was sure their parents could tell an AI-made picture or video from a real one.

So two things were clear. It had to be an Android app. And it had to warn them the moment the message arrives, because most of them won't stop to check. Most of those scams happened on Facebook. My mum's come through WhatsApp and SMS, so that's where I started. Facebook is next.

What ScamGuard does

ScamGuard is an Android app that quietly looks at every SMS and WhatsApp message that comes into a parent's phone. It uses Gemma, an open AI model made by Google, and the AI runs on the phone itself. Nothing is sent over the internet.

When a scam comes in, this is what my mum sees and hears:

Her screen turns red, even if she's in the middle of a WhatsApp chat.
A Nigerian voice says, "Mummy, wait o! Dis message na scam. No send money, no press any link, no give anybody any code. Call your family first."
She can see who sent the message and what it says, with the dangerous parts marked, like the link or "your BVN is blocked". The link can't be opened from there.
She gets one short reason, like "It has a link and says your account is blocked", and a big button to call me.

Not every message is that serious. If something just looks a bit off, she gets a quiet notification telling her to be careful and to call the family before she replies or pays anything. When a real code from her bank comes in, ScamGuard reminds her never to give it to anyone. Normal messages, like the church group or the family chat, get nothing at all.

She can also check any message herself by sharing it to ScamGuard. And if family alerts are on, I get a short text when she receives a likely scam, so I can call her. That text never says what the message was or who sent it.

It works in English and Pidgin. Setting it up takes about ten minutes, and it's made for a son or daughter to do on their parent's phone.

The part I'm proudest of is this: ScamGuard doesn't have permission to use the internet at all. Even if it wanted to, it couldn't send her messages anywhere.

What my mum said

My mum was very happy with it. She even told me her neighbour is going to use it too. Her neighbour can't read, and scammers once tricked her with a phone call, pretending to be from her bank, and got her to send them a code.

That's exactly why ScamGuard says its warnings out loud.

Why this matters to me

Every day on the internet, people attach the word "scam" to Nigerians, and that really makes me sad. I have always hated scammers, and I've spent my five-year career building security-focused applications.

Many elderly people can't really tell what is a scam and what isn't. ScamGuard tells them, and it speaks to them in English and in Pidgin, a language understood across Nigeria, including by many people who never had much formal education.

Demo

A full walkthrough of ScamGuard on my phone: scams arriving on WhatsApp and SMS, the red warning taking over the screen, normal messages staying quiet, the phone locked, airplane mode on, and the Pidgin voice.

You can install it yourself from the v1.0.0 release. It needs Android 8 or newer, a 64-bit phone and about 2.3 GB of free space during setup (about 1.7 GB after).

Code

abgolor / ScamGuard

ScamGuard

An offline AI scam guard for your parents' Android phone.

ScamGuard reads every incoming text message (SMS) and WhatsApp message, checks it with Gemma, an AI model by Google that runs on the phone itself, and warns loudly, with a red screen and a spoken warning, before your mum or dad clicks a link, sends money or shares a code.

It is built for parents and grandparents who use Android, WhatsApp and SMS every day, aren't technical, and will never open an app to "check" a message. Their son or daughter installs it once, in about ten minutes, and it then works on its own.

It catches the scams Nigerian families actually get: "your BVN is blocked, click this link", fake POS reversals, "send me the OTP", prizes that need a delivery fee, and "Mummy, this is my new number, please send money". It speaks English and Nigerian…

View on GitHub

How I Built It

ScamGuard is written in Kotlin with Jetpack Compose. The AI is Gemma 3 1B, a 584 MB open-weight model that runs on the phone's processor through Google's LiteRT-LM. The warning voice was made with ElevenLabs. I tested it with 281 automated tests, plus a test screen on the phone that runs sample messages through the real AI and shows me the results and timings.

How a message is checked

When a message comes in, ScamGuard does a few things in order.

First, it ignores messages that are obviously fine, like "Ok", "Amen" or a row of emojis. This saves battery in busy group chats.

Next, it looks for patterns that are always a scam. A link together with "your BVN is blocked". Someone asking for a code or a PIN. A prize you have to pay a fee to collect. Someone asking for money from a "new number". These are caught almost instantly, and the red screen shows up about two seconds after the message arrives.

That last one is an old trick. Someone pretends to be a person you know, uses a number you don't recognise, and asks for money urgently. It used to come as a phone call. Now it comes on WhatsApp.

Everything else goes to Gemma, which decides if the message is a scam, something to be careful about, or fine. For example, a fake "POS reversal" message didn't match any of my rules. Gemma caught it.

Finally, ScamGuard double-checks Gemma's answer. If Gemma says "scam", there has to be something real in the message to back it up, like a link, a phone number, or a request for money or a code. If there isn't, the warning is turned down.

The part where my AI called everything a scam

Getting the AI to run on a phone took one evening. Getting it to make good decisions took most of the weekend.

I wrote 20 test messages, 10 scams and 10 normal ones, and kept testing against them.

My first try was simple. I described the kinds of scams Nigerian parents get, then asked Gemma whether each message was one. It caught 9 of the 10 scams. It also said 9 of the 10 normal messages were scams. A family greeting was flagged as "Mummy's request for money". A normal bank alert was "suspicious due to an unusual amount". If my mum got warnings like that, she would stop trusting the app in one day.

Next, I tried asking Gemma simple yes or no questions, like "Does this message ask for a code?", and letting my own code make the final decision. That went worse. When I gave it an example answer, it copied the example for almost every message. When I asked one question at a time, it said "no" to nearly everything, even to a message that plainly said "forward me the OTP".

What finally worked was letting Gemma make the call, but not trusting it blindly. The clear scams are caught by rules before Gemma even sees them. For everything else, Gemma's "scam" only counts if the rules can find something real in the message. And the warning my mum reads is written by me, in English and Pidgin, based on what was actually found. Gemma's own explanations were often made up, so I don't show them.

With that, all 10 test scams were caught, and no normal message set off the loud alarm. One normal message, a friend asking for a contribution, got the quiet "be careful" note. I think that's fair, because it does ask her to send money.

Then I tested it on 20 new messages it had never seen before. It missed 3 scams: a fake "fraud desk" asking her to call a number, an "invest ₦50,000 and get ₦150,000 back" scheme, and a message asking her to "reply with the 6-digit code". I fixed those by adding rules for each kind of scam, not just for those exact messages.

On my Pixel 8, a check by Gemma takes about 5 to 8 seconds, and the clear scams show up in about 2. The first check right after the phone restarted was very slow, over 40 seconds, so ScamGuard now gets the AI ready a couple of minutes after the phone turns on.

What it can't do yet

It doesn't check phone calls, only SMS and WhatsApp messages.
It doesn't check photos or voice notes, only text.
If she has a WhatsApp chat open on her screen, WhatsApp doesn't show a notification, so ScamGuard doesn't see the messages in that chat.
On Android 15 and newer, the phone may hide one-time codes from apps like ScamGuard.
It isn't on the Play Store yet, so Android asks for an extra step during setup, and Play Protect may show a warning. The setup screens explain what to do.
It needs a 64-bit phone with about 2.3 GB of free space during setup. Some very cheap phones can't run it, and the app tells them so.
The download is big, 612 MB, because the AI is inside it.

What's next

Igbo, Yoruba and Hausa, the three most spoken languages in Nigeria, so every parent can hear the warning in their own language.
Facebook, TikTok and Instagram. People in my survey asked for these, and most of their parents' scams happened on Facebook.
A WhatsApp number people can forward suspicious messages to, for family members whose phones can't run the AI.
A Play Store release, which would also make the app take up less space on the phone.
A lighter version for older phones.
Training a small Gemma model on real Nigerian scam messages, so it gets better at catching them on its own.

Why Does Open Innovation Matter?

If I had used a paid AI service in the cloud, every message my mum gets would have to be sent to someone else's computer to be checked. Her bank alerts, her family chats, everything. I wasn't going to do that. Because Gemma is open and runs on the phone, ScamGuard doesn't need the internet at all, and anyone can check that in the app's permissions.

It also works without data. Data isn't cheap in Nigeria, and the network isn't always there. ScamGuard works in airplane mode, and checking a message costs nothing.

The AI comes inside the app, so a family can share ScamGuard from one phone to another with Xender or WhatsApp. No account, no sign-up, nothing extra to download.

And I'm in control. I tried running the AI on the phone's graphics chip and on its main processor, and picked what worked best. When the AI made bad calls, I could put rules around it and test it as much as I wanted, with no limits and no bills. If a better model comes out, I can swap it in.

The only part where I used an online service was the voice. I made 24 short warning clips with ElevenLabs, using a Nigerian voice, and put them inside the app. The app plays them offline.

Prize Categories

Best Use of Gemma
Best Use of ElevenLabs