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

What I Built

I have a cousin. He has been telling me he wants to contribute to open source for about a year. Every month or two he sends me a screenshot of a repo and asks "is this a good one to start with?" I say yes. He opens it, scrolls for twenty minutes, closes the tab. The screenshot never turns into a PR.

I used to tell him "just pick a good first issue." That advice is useless. Good first issues live in repos with four hundred files and eighty open issues each. You still have to pick. He had already been doing that for a year.

So I built OSS Buddy. You point it at any GitHub repo and a local Gemma 3 model tells you three things in about twenty-three seconds:

1. What the project actually does, in two plain sentences
2. Up to three good first issue tickets ranked easiest to hardest, with time estimates
3. Which specific directory to start reading

Nothing leaves his laptop. No account, no API key, no credit card. He downloads Gemma once, forgets about it, the tool works forever.

Demo

One command, no cloud calls. Terminal recording against kiwix/kiwix-android.

Benchmarks on five real repos

Measured end-to-end on an M-series Mac with Gemma 3 4B via Ollama. Each run is one command, no warmup, no cache.

Average: ~23 seconds, zero cloud bytes. The two zeros are honest limits — neovim doesn't use the good first issue label at all, and fastapi had none open when I ran it. OSS Buddy says so plainly rather than hallucinating issues.

Code

# ollama (macOS)
brew install ollama
brew services start ollama

~150 lines of stdlib Python. No pip install. MIT.

How I Built It

Open-source AI used:

• Gemma 3 (4B) — Google's open-weight model, running on my laptop
• Ollama — open-source runtime for the model
• GitHub CLI (gh) for repo data

Pipeline (lazy on purpose):

    gh api  (readme + top-level tree + good-first-issues)
                        │
                        ▼
                 one tuned prompt
                        │
                        ▼
         POST localhost:11434 (ollama)
                        │
                        ▼
                   gemma 3 4b
                        │
                        ▼
         stream the answer to the terminal

Three HTTP calls to GitHub, one HTTP call to a server running on my own laptop. That is the whole pipeline. The Python file is small enough to read in one sitting.

The prompt went through three real iterations in the git history. The first version produced great summaries but ended every answer with "Would you like me to delve deeper?" — chatty, off-brand. The second version started paraphrasing issue titles instead of quoting them, which was worse than useless because then you couldn't grep for the issue on GitHub. The third version pins Gemma: "Quote the issue number and the EXACT title from the data below. Do not paraphrase or invent." That one shipped.

Labels aren't consistent across repos

Early version only looked for the literal good first issue label. Lost half the repos. The fix was a cheap one — try the three common spellings in order:

for label in ("good first issue", "good-first-issue", "beginner"):
    ...

Simple, but it is the difference between the tool working on one repo in two and almost all of them.

Why Does Open Innovation Matter?

He does not need to sign up for anything before he can start contributing to open source. He already has GitHub, git, and a dozen tabs open. A new contributor does not need another sign-up flow before the one he actually came for. Open-source AI removes that friction entirely — he downloads the model once, forgets about it, and the tool just works.

The second thing matters more. His GitHub token and the repos he explores never leave his laptop. Some of those repos are private — half-built side projects, work stuff. A closed API would have meant sending every README and every issue title to a third party's servers. With Gemma running locally that whole class of problem does not exist.

The third thing is practical. It runs on a plane. It runs in a cafe with slow wifi. It runs inside offices that block third-party API calls. It costs zero rupees forever. For someone taking their first step into open source every friction point is a chance to quit — the open stack removes a few of them.

And the whole chain is readable. 150 lines of Python. An open-weight model with public weights. A runtime with public source. If my cousin wants to see what the LLM did with his repo, he can trace it from his terminal all the way down to the weights. That is the open-source story — not just the model, the whole stack.

The hand-over

I sent him the install snippet on WhatsApp. Three commands.

Space for the real reply here — I'll paste his message when I get it.

I will update this section with his actual message after he runs it. The honest version of this story is unfinished until the person it was built for actually uses it.

My Agent Session

Skipping DevRelay sessions on this one. The story is in the git log instead:

• 31b5e08 initial scaffold: fetch readme + good-first-issues via gh
• 4a8dbb5 wire up ollama + first prompt that asks for 3 ranked issues
• ede3d7f tighten prompt (no outro, quote exact issue titles)
• b430d72 add demo gif + vhs tape
• bf1babc readme: link to the dev.to writeup
• 0d26567 readme: proper case + benchmarks table + cover image

Six commits, a few hours of work spread across one evening and the next morning.

What's next

Short list, in the order I'd attack them:

1. Deeper issue analysis. Right now it reads the issue title and body. Next step: fetch linked files and the diff of the last PR to touch them, so "where to start" becomes line-level, not directory-level.
2. Remember what my cousin has already tried. A tiny local SQLite log of attempted issues so OSS Buddy stops suggesting the same ones.
3. A thin web wrapper for people without Ollama. Deployed somewhere small (likely a free Render tier) that calls a hosted Gemma via Groq. The CLI stays local-first; the web version is a convenience.
4. A --contributing flag that reads the project's CONTRIBUTING.md and tells you what tests to run and how to open a PR, so the suggestion ends with "and here is exactly how this project wants it submitted."

None of it changes the shape of the tool. It's all deeper reading of the same three sources.

Prize Categories

Best Use of Gemma — Gemma 3 (4B) via Ollama is the only model used. The entire pipeline depends on it. No fallback, no closed-model path, no "bring your own API key." Just Gemma, local, free.