DEV Community: Tanisha Naruka

Hammock Report

Tanisha Naruka — Sun, 25 Oct 2026 13:49:11 +0000

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

What I Built

You come back from a week offline and your group chat has 1,400 unread messages. Most of it is memes. Somewhere inside is the one question that was waiting for you.

Hammock Report reads an exported WhatsApp chat and sorts every conversation into three piles:

Needs you: you were asked directly, or a decision is still waiting on you.
Already resolved: someone raised it and a later message settled it.
Safe to ignore: banter and small talk that asked nothing of you.

Every verdict comes with a one-line reason, so you can check the model instead of trusting it. The report also shows the reading time you save, a timeline of the conversations, and who talked most. You can move any conversation to a different pile and download the result as Markdown.

The lazy part: you export the chat, press one button, and read only the pile that needs you.

It comes in two forms: a single-file web app with a mission-control look (radar scan, gauge, star map), and a Python command-line script that uses only the standard library.

Demo

https://drive.google.com/file/d/1sod2JuwYfVdYHk55ZsIpvuCXw8vjdA5u/view?usp=sharing

Code

https://github.com/tanisha-naruka/Hammock-Report.git

How I Built It

The open-source AI is Ollama running Qwen2.5 3B on the user's own machine. The model name is one setting, so you can swap in Llama 3.2 3B or Gemma.

A 3B model reads a short conversation far better than a week of chat, so the app:

Parses the WhatsApp export (Android and iPhone formats), skipping system lines and media placeholders.
Splits the messages into conversations wherever there is a quiet gap, 30 minutes by default.
Asks the model, for each conversation, three yes/no questions plus a one-line summary and reason. It uses Ollama's JSON mode at temperature 0, so the same chat gives the same answers.
Sorts the answers: Needs you wins first. Otherwise a raised-and-resolved conversation is Resolved, and the rest is Safe to ignore.

The prompt, sent for every conversation:

You triage a group chat for {name}, who was away. Read this conversation.
Reply with JSON only, with keys:
"request_raised": true/false (was a question, request or decision raised?)
"resolved": true/false (was it answered or settled later in this same conversation?)
"needs_me": true/false (does it still need {name} to act or decide, or was {name} directly asked?)
"summary": one short sentence
"reason": one short sentence explaining the verdict

Small models are unreliable, so I added some safety nets:

If a model call fails, the conversation is filed under Needs you, so a failure never hides something.
Small models sometimes answer "false" as text instead of a real boolean. The code reads both correctly, and I have a test for it.
Very long conversations are trimmed to their start and end so they fit the model.

The web app is one HTML file with vanilla JavaScript and no build step.

Why Does Open Innovation Matter?

A group chat is not only my data. It holds my friends' messages too, and they never agreed to have them sent to a cloud API. Running an open-weight model locally means the whole chat stays on my machine, which a closed API could not offer.

Private: nothing is uploaded.
Offline: it works on a train once the model is downloaded.
Free at any size: a bigger backlog costs time, not money, so I never have to think about per-message cost.
Swappable: --model lets me try another model on the same chat and compare.

Where a closed model would likely be more accurate, I say so plainly in the next section. For this job, privacy mattered more to me than the last few points of accuracy.

The Lazy Payoff

[Run it on a real chat export and fill this in with real numbers: messages, conversations, how many needed you, how long the run took, and how many mistakes you found when you spot-checked the Safe to ignore pile. If you can't, delete this section.]

Honest limits

A 3B model can miss a request buried in a long thread. That is why every verdict shows its reason.
Dry run mode is only a keyword check for testing the page. Do not judge accuracy from it.
The "minutes saved" figure assumes about 5 seconds per message, so it is an estimate.
The numbers on the home page (1,400 messages, 11 that need you) are example figures. The report screen shows real counts.

CULL

Tanisha Naruka — Sun, 18 Oct 2026 17:49:16 +0000

This is my submission for the Hacktoberfest Open-Source AI challenge, Side Hustle week.

Three thousand photos, one weekend

After a wedding, a photographer has around 3,000 frames and needs to throw away two-thirds of them before editing can begin. That means squinting at near-identical bursts, hunting for blinks, and zooming in to check focus, one photo at a time. It takes hours. It is also the one step of the job that clients never see and never want to pay for.

AI cullers exist, but they ask for the one thing a photographer can't hand over: the whole shoot, uploaded to a server they don't control. Wedding, family and school photos come with privacy promises. For many photographers, that rules those tools out.

That gap is the idea behind Cull.

What Cull does

Cull sorts a shoot into keepers and rejects, and every step runs on the photographer's own machine. It is plain HTML, CSS and JavaScript, with no backend and no build step.

Step 1: a fast first pass, in the browser. Each photo is scored on sharpness and exposure, and a perceptual hash groups bursts so only the best frame of each one survives. The sharpness score is the variance of a Laplacian filter over a downscaled copy, which is cheap and works well for catching blur:

const l = 4*Y[i] - Y[i-1] - Y[i+1] - Y[i-w] - Y[i+w]; // Laplacian at each pixel
s += l; s2 += l*l; n++;
const sharpness = s2/n - (s/n)**2;                    // variance = how sharp

Step 2: Gemma makes the hard calls. The photos that land close to the keep threshold are exactly the ones maths can't judge: is that a blink, is the face soft or the background? After upload, Cull sends each borderline photo to Gemma 3 running in the photographer's own Ollama and asks whether the eyes are open, the subject is sharp and the composition is worth keeping. Gemma answers KEEP or REJECT, and that verdict overrides the score.

fetch(`${ollamaUrl}/api/generate`, {
  method: 'POST',
  body: JSON.stringify({ model: 'gemma3:4b', stream: false, prompt, images: [jpegBase64] })
});

Step 3: the AI is visible, and the human stays in charge. The workspace has a Gemma panel that shows the model, the score, Gemma's reasoning and how many photos the AI has judged. Photos Gemma decided carry an AI badge. K and X keep or reject, and any photo can be compared with the best frame of its burst.

Step 4: real output. Export a ZIP of the kept originals, or a CSV of every decision with its reason.

Around that are the practical pieces: adjustable thresholds and weights, saved shoots, a Models page that lists what your Ollama has installed, and a local-only account so settings persist. Nothing leaves the machine except requests to localhost.

Why open innovation matters for what I built

Privacy is the product. With a hosted vision API, my pitch would be "trust us with your clients' faces". With open weights it becomes "there is nothing to trust: open the network tab and look." For wedding, family and school photographers, that is the reason to buy.

The economics only work with a local model. Hosted vision APIs charge per image, and a single wedding is thousands of images. Local inference costs nothing per photo, so I can charge a flat price and never meter a customer's usage.

I can swap and tune the model. The model is one setting in the app. When a better open vision model appears, I change one string. The critique prompt is editable too, so a portrait photographer and a wildlife photographer can ask Gemma different questions. A closed API would leave me with whatever the provider decides to ship, at whatever price they decide to charge.

Where the open approach fell short. A 4B-parameter model is weaker than the largest closed models, and each Gemma call takes a few seconds on a laptop. That is why Gemma only sees the borderline photos and the cheap maths handles the rest. I haven't benchmarked Cull against a professional culler, so I won't quote an accuracy number. RAW files aren't read directly yet, so photographers export JPG previews first.

Try it

https://github.com/tanisha-naruka/Cull-project.git
https://drive.google.com/file/d/1J6mHriBak1qwHotPanyfiztWmIZcqEB3/view?usp=sharing

ollama pull gemma3:4b
OLLAMA_ORIGINS=* ollama serve    # Windows PowerShell: $env:OLLAMA_ORIGINS="*"; ollama serve

Open index.html (or run npm start), create a local account, upload a folder of JPGs and watch Gemma review the borderline ones. If Ollama isn't running, Cull still works using the maths-only first pass.

The side hustle

Cull is free for local use. The paid version I'd sell is a one-off licence for XMP sidecars, so every keep and reject lands directly in Lightroom. I haven't built that part yet. Because there are no servers to run, almost all of the price is margin.

Prize categories

Best Use of Gemma: Gemma 3 is the judge in the pipeline, running locally through Ollama.

Nature Bingo

Tanisha Naruka — Sun, 11 Oct 2026 14:56:16 +0000

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

What I Built

Nature Bingo is a web app designed so that the best session is the shortest one: open it, get a quest, put the phone in your pocket, and go outside.

You tell the app what you like (birds, plants, photography, hiking, mindfulness), how much time you have (5 to 60 minutes), and whether you're indoors or out. Gemma, an open-weight model, writes one short, safe nature quest for you, like "Listen and Count: stand still and note every different bird call you hear."

Then you play in the real world:

3x3 Nature Bingo: tick off real finds like a bird, a feather or running water. Completing a line earns bonus XP.
Nature Journal: record what you noticed.
Nature Passport: collect twelve stamps as you play.
Screen-time page: log your minutes against a daily goal.

It's for anyone who wants a gentle nudge outside without another app competing for their attention: students, desk workers, families, and beginner birders or hikers.

Demo

https://drive.google.com/file/d/1Tu0LLBFrjHmqe3Ih2ZnQOzDoN33-pzN7/view?usp=sharing

Code

https://github.com/tanisha-naruka/Nature-Bingo.git

How I Built It

Model: Gemma, Google's open-weight model, running locally through Ollama (gemma3:1b while developing, configurable up to gemma3:4b or larger).
Stack: Next.js 14 (App Router), TypeScript and Tailwind CSS.
Server route: Gemma is only ever called from a server route. It validates input, caps lengths, rate limits requests, and asks the model

Panel Prep

Tanisha Naruka — Mon, 05 Oct 2026 06:57:06 +0000

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

What I Built

I built PanelPrep, a local AI interview-practice coach designed to help someone prepare for important interviews.

The problem wasn't finding another list of interview questions. The difficult part was actually practicing out loud.

PanelPrep turns the user's own study material into an interactive mock interview. Users can upload PDFs, DOCX files, text files, images, or scanned documents, and PanelPrep generates questions based on that material.

Users can answer by speaking or typing, receive follow-up questions, and review measurable feedback such as speaking speed, filler words, answer length, and important terms used.

It supports both English and Hindi, making interview practice more comfortable and accessible.

Demo

https://drive.google.com/file/d/148w7j5kkjxSWfAF4OC9RqslQQr40H3aJ/view?usp=sharing

Code

https://github.com/tanisha-naruka/Panelprep.git

How I Built It

The core of PanelPrep is Gemma, Google's open-weight model, running locally through Ollama.

The user provides their own preparation material, which is processed by the application and used to generate interview questions through the local Gemma model.

The application is built with JavaScript and Node.js. It also includes document extraction, OCR, voice interaction, interview metrics, profiles, history, backups, and progress tracking.

The AI generates the interview questions, while normal application code calculates measurable results such as speaking speed, filler words, answer length, and important terms used.

If the model produces invalid output or Ollama is unavailable, PanelPrep can fall back to a built-in question bank instead of simply breaking.

Why Does Open Innovation Matter?

Interview preparation can involve personal information, resumes, academic records, and private preparation material.

Using an open-weight model locally means the core AI experience can run directly on the user's computer instead of requiring their personal preparation material to be sent to a closed AI service.

This gives PanelPrep:

Privacy for personal preparation material
No per-session cloud AI cost
The ability to change or compare local models
More control over how AI output is handled
An AI experience that can work locally without depending on a paid API

For this project, open innovation wasn't just a technical choice.

It made it possible to build a more private and controllable interview coach for a real person.

Prize Categories

Best Use of Gemma

PanelPrep uses Gemma 3 locally through Ollama as the core AI model for generating interview questions from the user's own material.This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

DEV Community: Tanisha Naruka

Hammock Report

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

The Lazy Payoff

Honest limits

CULL

Three thousand photos, one weekend

What Cull does

Why open innovation matters for what I built

Try it

The side hustle

Prize categories

Nature Bingo

What I Built

Demo

Code

How I Built It

Panel Prep

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Best Use of Gemma

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories