DEV Community: RishavRajSingh44

Another week another project. #LateSubmssion 🫪

RishavRajSingh44 — Mon, 26 Oct 2026 13:02:37 +0000

Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady Submission 🦥

RishavRajSingh44

Oct 26

While I Was Away: a local Gemma briefing for the context I forgot

#devchallenge #hf26challenge

3 min read

While I Was Away: a local Gemma briefing for the context I forgot

RishavRajSingh44 — Mon, 26 Oct 2026 13:01:38 +0000

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

What I Built

When I return to a repository after a break, I need to reconstruct more than the latest diff. What was I trying to do? Did a PR merge? What did a reviewer ask for? Where did my coding-agent conversation stop?
While I Was Away turns that scattered context into one briefing. I select a local repository and, optionally, specific agent sessions. The app reads Git history and working-tree changes, syncs my GitHub PRs on request, and uses a local Gemma model to explain the evidence. It puts “Your next step” first, links claims to their sources, and gives me an editable handoff prompt to copy into my coding agent.
The benefit is less manual context reconstruction. I have not measured time saved, so I am not claiming a speedup.

Demo

Watch the 20-second demo. It shows a briefing, source evidence, PR states, an agent conversation, and the editable handoff.
The recording is synthetic and silent. Its briefing is precomputed; watching it does not run Gemma or contact GitHub. The installed local application supports real inference and explicit authenticated GitHub sync.

Code

RishavRajSingh44 / while-i-was-away

Local-first developer briefings from Git, GitHub PRs, selected agent sessions, and Gemma

While I Was Away

Close your laptop. Lose the context. Get it back in one briefing.

While I Was Away is a local developer app that combines read-only Git state, your GitHub PRs, selected coding-agent sessions and a real local Gemma briefing. A briefing shows where you stopped, what changed, what needs attention and one next action. Every source can be opened from its citation. It produces an editable, secret-redacted handoff prompt and Markdown export.

The synthetic demo needs no GitHub account, repository or model. It is explicitly labeled and never substitutes for a real briefing. A separate public static demo contains only synthetic precomputed data and cannot access files, GitHub or Ollama.

Setup (macOS first)

Requirements: Python 3.11+, Node 20.19+ or 22.12+, npm, Git, GitHub CLI for PR sync, and Ollama for real briefing synthesis. The app works offline with local Git and cached GitHub data. GitHub sync and…

View on GitHub

The public repository contains the application, setup instructions, tests, synthetic demo data, and third-party notices. The application code is MIT-licensed; Gemma weights are obtained separately under Gemma’s terms.

How I Built It

The interface uses React, TypeScript, and Vite. A loopback-only FastAPI backend reads local Git state without changing the worktree. GitHub CLI supplies authenticated PR data while retaining its own credentials. SQLite stores snapshots, acknowledged checkpoints, cached PR facts, selected session imports, and a recoverable briefing queue.
The app supports manual transcript imports and selected Codex and Claude sessions. It also has a read-only Entire checkpoint adapter, though compatibility with the current Entire CLI remains experimental: I tested synthetic checkpoint refs, not a checkpoint produced by that tool.
For synthesis, gemma3:4b runs locally through Ollama. The app bounds the evidence, asks for structured output, and validates every cited evidence ID. Deterministic Git and PR facts remain separate from the model’s interpretation. One real inference run over a temporary synthetic repository, four synthetic PRs, and a synthetic conversation took 39.605 seconds on an Apple arm64 machine with 48 GiB RAM. The suggested next action followed the latest user direction. The model also placed a historical goal under “What changed,” showing that a valid citation does not guarantee perfect interpretation.
Local checks passed 73 backend tests, 11 frontend tests, lint, type checks, builds, and browser flows. Authenticated read-only sync handled 23 real merged PRs; open, draft, and closed-without-merge states were fixture-tested. The corrected GitHub Actions run passed its configured checks.

Why Does Open Innovation Matter?

The model is replaceable, and the prompts and evidence rules are inspectable. Local Git and cached GitHub data remain useful offline. With a compatible installed model, briefing synthesis can run without sending code or conversations to a cloud inference API by default.
That does not make the app cost-free or guarantee perfect privacy: local hardware, electricity, redaction limits, and export choices still matter. Gemma is an open-weight model under its own terms; the application is MIT-licensed software.

My Agent Session

The Lazy Payoff

Prize Categories

Best Use of Gemma
Best Use of GitHub Copilot

I Built BountyPilot: An Open-Weight AI That Helps Developers Find Coding Opportunities Worth Their Time

RishavRajSingh44 — Fri, 16 Oct 2026 21:24:15 +0000

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

What I Built

A GitHub issue with “$400” in its title looks like an opportunity. It still leaves the questions that determine whether I should spend a weekend on it: Is the work available? What counts as acceptance? Do I have the skills? Who can authorize payment?

I built BountyPilot around that gap between finding a lead and deciding it deserves my time.

It searches real public GitHub issues, retrieves their sources, and puts reward evidence beside the technical task. Local Gemma analysis adds a scope summary, relevant skills, estimated difficulty, suggestions, risks and unanswered questions. I can inspect the quoted sources, save an opportunity, and return to a persistent local pipeline.

The distinction I kept coming back to was a reward claim versus verified funding. An amount, a label or a maintainer-associated comment cannot establish that money is available or that my contribution would qualify. BountyPilot exposes that uncertainty instead of presenting a list of promised earnings.

The intended customer is an independent developer or freelancer who repeatedly evaluates paid coding leads. The practical value would be less time piecing together scattered threads and fewer decisions made from a bounty title alone.

Possible businesses around that workflow include managed setup and support, opt-in notifications, or paid hosting. Those are future possibilities, not implemented services or existing revenue. Hosted operation would need authentication, privacy boundaries and operating-cost work. I have no external-user or willingness-to-pay evidence yet.

These are genuine October 16 application screenshots. The video below was recorded October 17 using another real issue; screenshot amounts and timings belong to their original captures. Every pictured reward remains an unverified source claim.

Demo

Watch the completed 88-second BountyPilot demo. The public player opens without sign-in. Select full screen for the interface text; the video is captioned and silent.

It shows real GitHub discovery, opening oll4com/spaceapp#60, reviewing source/payment evidence, selecting local Gemma 3 4B, generating an analysis, inspecting difficulty and citations, saving, and reloading Pipeline.

The recorded request performed new inference, measured at 14.537 seconds by the application. I removed 8.4 seconds of waiting and added reading holds; the edit discloses the shortened wait. This is recorded footage, not live playback, a cached response or a general latency promise. The browser reload demonstrates saved-data retention; it is not a filmed process restart.

Code

Source and setup: RishavRajSingh44/BountyPilot. The repository is public; the verified code baseline is 85d57a4.

Local browser → Next.js / TypeScript → GitHub REST API
                         ├── local SQLite
                         └── local Ollama → Gemma 3 4B

Original application code is AGPL-3.0-only. You can inspect, run, modify and redistribute it under that license, including its source-sharing obligations. Ollama is separately MIT licensed; Gemma weights have Google's separate model terms. Fonts, icons, adapted components and source excerpts retain their own rights. Third-party notices explain those boundaries; no model weights are bundled.

After installing compatible Node 24 and Ollama, clone the repository and follow its platform-specific README configuration. The core commands are:

npm ci
ollama pull gemma3:4b
npm run dev

Start the Ollama runtime separately. The app runs on loopback for one trusted local user. Contributors can run deterministic tests without downloading a model, inspect the small server modules, and submit focused changes through CONTRIBUTING.md.

How I Built It

I initially considered a separate Python API. For this workload, another backend would mostly forward HTTP to Ollama while duplicating contracts. One Next.js/TypeScript application kept UI, validation and server-side integration together. SQLite provides local snapshots, analyses and saved statuses without a database service.

GitHub REST supplies the real issues and bounded discussion excerpts. Search does not run a model for every result. A deterministic score combines evidence signals, explicit skill matches, recency, availability and scope signals. Its breakdown is inspectable, applies to the fetched page, and is neither a payment probability nor expected earnings. Gemma cannot change that score or the payment-evidence state.

For analysis, I send bounded excerpts and skills to Gemma 3 4B, the open-weight model. Ollama is the inference runtime that loads and serves it. BountyPilot is the application orchestrating sources, validation, presentation and storage. This integration does not use the Gemini API.

The model must return structured JSON. The application checks the schema, source identifiers, unique citation identifiers, exact quote membership and risk-to-citation references. It records omitted or shortened context. Substantive input requires a valid citation, and malformed output gets at most one validation retry within the overall deadline.

I learned to draw a precise boundary around “grounded”: a quote can exist in a source while poorly supporting a conclusion. These checks establish quotation fidelity, not truth, semantic entailment or payment. Human source review remains part of the workflow.

Failure recovery mattered as much as the prompt. A failed analysis preserves the last successful result. Successful writes are transactional; a source refresh racing an analysis cannot silently attach an old answer to changed evidence. Cached results retain their original generation time. Timeouts and cancellation give the user a recovery path.

GitHub quotas produced another concrete lesson: an exhausted detail quota originally blocked searches even when search budget remained. Separating those cooldowns fixed unnecessary waiting, with a regression test protecting the distinction.

Here is the verified evidence, rather than a claim that every future issue will work:

Check	Recorded result
Deterministic tests	79 passed; 12 opt-in model cases skipped in ordinary runs
Chromium checks	7 passed; synthetic HTTP boundaries, separate from live inference
Clean source installation	Fresh dependencies/browser installation and production build passed on macOS
Real-issue Gemma 4B analysis	11.394 seconds on an M4 Pro Mac with 48 GiB RAM; one observed request
Gemma 1B grounding evaluation	All 12 cases failed validation; experimental only
Updated live discussion	Two 4B requests failed validation; neither was persisted as a successful analysis
Durability/recovery	Process-restart persistence and separate backup restoration passed integrity and content checks

Published CI passed six Linux/macOS/Windows jobs across Node 24.14.0 and 24.21.0; each current-Node job also passed the seven browser checks. These automated runners do not establish Gemma performance on those operating systems. Release verification records commands, failures and limits.

The separate 12-case 4B prompt-v4 evaluation produced 12 valid outputs; manual assessment judged 11 useful. That small result did not prevent later live failures. I kept rejection as product behavior rather than weakening validation for a cleaner demo.

Codex helped with planning, implementation and checks. Ponytail FULL guided small changes and reviews of connected code. Neither replaced actual model runs, database checks or inspecting the resulting interface.

Why Does Open Innovation Matter?

The strongest reason for this architecture is control over the decision-making process. A developer can inspect the ranking weights, see which excerpts reached the model, challenge an evidence heuristic, and change validation without waiting for a hosted vendor to expose an internal feature.

Local Gemma also makes the core analysis available without a mandatory paid LLM API or commercial AI subscription. With Ollama local, selected skills and excerpts go to a process on the user's machine. Personal snapshots and the pipeline stay in local SQLite by default. That database is plaintext, protected by operating-system permissions, not a promise of isolation from other software running as the same user.

Live GitHub discovery and refresh require internet. Once dependencies, weights and a snapshot are available, inference over retained content can run locally; the saved pipeline does not need GitHub to answer another request. Users can explicitly configure a secured remote Ollama endpoint, but that sends analysis input to its operator and changes the privacy assumptions. It is not an automatic fallback.

The 1B experiment made the value of inspectability concrete. A smaller download returned responses, yet failed all twelve grounding checks. I could preserve that evidence, label the option experimental and keep 4B primary. A successful local installation alone would have hidden the quality problem.

The tradeoffs remain real. My measured machine has 48 GiB RAM; I have not established a lower-memory minimum. Installing Node, Ollama and model weights takes effort and storage. Inference takes noticeable time. Models can echo supplied skills, omit important context or fail validation. Schema-valid results still need judgment. Local operation costs electricity and hardware even when no API invoice arrives.

I kept one small provider interface for future work, while deferring Gemini, OpenAI and other cloud adapters until after submission. That preserves room to extend the project without making a proprietary service a prerequisite. AGPL source access lets contributors reproduce failures, propose better evidence rules and improve the same local tool they run themselves.

Those freedoms apply to BountyPilot's software. Gemma remains an open-weight model under Google's separate terms, not an AGPL-licensed or OSI-approved model. Keeping that distinction visible is part of making an honest open project.

My Agent Session

My First User

Prize Categories

Best Use of Gemma
Gemma 3 4B performs the opportunity analysis at the center of BountyPilot, served locally through Ollama. I am also entering the overall Side Hustle challenge. The aim is a useful decision aid developers can run, inspect and improve while deciding which coding opportunity deserves their time.

StudyForge — I Built an AI Study Assistant for a Friend Too Lazy to Type Prompts

RishavRajSingh44 — Mon, 05 Oct 2026 12:10:50 +0000

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

What I Built

I built StudyForge, an open-source AI study assistant for my friend, who was struggling with one surprisingly simple problem: he was too lazy to even type prompts into an AI tool to get notes, explanations, and quizzes.
So instead of asking him to figure out the right prompt every time, I built a study workflow around the task itself.
StudyForge lets a student upload course material such as PDFs, PowerPoint presentations, and Word documents and turn that material into structured study content including topic explanations, expected questions, and quizzes.
Core features:

Upload PDF, PPTX, or DOCX lecture slides and past exam papers (up to 20 files)
Enter your university name and course code — the AI calibrates everything to your institution's exam format
Web search augmentation: searches for your syllabus and exam format when a Tavily API key is configured
Streaming UI: results appear in real time as the model generates
PDF export: download notes, questions, or quiz as a branded PDF
No account required — anonymous sessions work out of the box

Demo

Live app: https://studyforge-8cdo.onrender.com

Code

RishavRajSingh44 / StudyForge

Open-source AI study assistant — upload lecture slides, get exam-ready notes, expected questions & quiz tailored to your institution

StudyForge

Open-source AI study assistant — upload your lecture slides and get exam-ready notes, expected questions, and an interactive quiz tailored to your university and course.

No account required. Works offline with a local Ollama model. Self-hostable.

Live Deployment

The public StudyForge demo is deployed on Render:

https://studyforge-8cdo.onrender.com

The hosted deployment uses Google Gemini 3.8 Flash (gemini-3.8-flash) for AI generation.

StudyForge also supports Ollama with configurable local models for self-hosted and offline use.

Why StudyForge?

Every student uploads lecture slides to ChatGPT and asks "make me notes". StudyForge does what that prompt can't.

Tool	Problem
ChatGPT / Gemini (raw)	Generic output — knows nothing about your university, syllabus, or exam style
Notability AI, Adobe AI	Requires an account and subscription; sends your documents to a third-party cloud
Manual prompt engineering	Produces notes, questions, or a quiz — never all three in one structured pass

StudyForge is different…

View on GitHub

How I Built It

StudyForge is built on Next.js 16 + React 19, with Supabase for persistence and
a multi-provider AI waterfall at its core. The open-source AI stack is what makes the
whole thing work:

The AI provider waterfall

Universal (Groq) → OpenAI → Ollama → Gemini → Claude
The first working provider wins. The key open-source piece is Ollama — it runs entirely on the user's machine, with no internet required after the model is downloaded.
The default local model is Qwen3:30B — an open-weight model that produces genuinely academic-quality output for this task.

Why Does Open Innovation Matter?

Open innovation makes StudyForge much more flexible than building the entire application around one closed AI API.
With Ollama and open-weight models, users can run models locally, choose models that fit their hardware and requirements, and experiment with different models without rebuilding the application.
It also means the AI layer can evolve independently of the rest of the product. A student can use a local model, while a hosted deployment can use a compatible cloud provider.
For a tool built around education, that flexibility matters: the goal is to make AI-assisted studying more accessible and adaptable rather than tying the entire experience to one proprietary model.

My Agent Session

The full development history is transparent via the commit log:github.com/RishavRajSingh44/StudyForge/commits

Prize Categories

Ollama — local open-weight inference (Qwen3:30B default, fully configurable)
Open Source AI — built around open-weight models and open-source frameworks
Render — application is deployed on Render, using it to host the Next.js app and make the AI-powered study workflow publicly accessible.
GitHub — Best Use of GitHub Copilot.