Still Good — four steps from what is left in the fridge

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

What I Built

I'm Anand Biju. I built Still Good for my friend Sathguru.

He lives on his own. He buys groceries with good intentions, then a weeknight shows up, he is short on time, and he ends up staring into the fridge and ordering takeout while the spinach quietly goes bad. He is vegetarian. I wanted one page for that moment: tap what is actually there, star up to three things that should be eaten soon, and get a yellow sticky note. A title, one sentence of why, and four short steps.

The profile stays in this browser. No account. Diet can be vegan, vegetarian, eggetarian, or eats everything. Allergies are hard stops. A few "won't eat" foods, 15 or 30 minutes, and a skill setting (boil water, follow steps, or improvise) sit beside that. A pantry staple counts only if you tap it. "What's still good?" writes the note. "Another" walks to the next match. Python chooses the dish. A small model on the same machine only writes the words.

When I showed it to him, he said:

"lol nice this is great, i think I might just use it everyday thank you so much"

Demo

There is no hosted demo. It listens on 127.0.0.1:8765 and talks to Ollama on that same machine. The demo profile is set up for Sathguru: vegetarian, 15 minutes, follow steps. It includes a nut allergy so the hard-stop filter is visible. The header says "Four steps for Sathguru will actually cook." His name is in Who is cooking.

Empty fridge. The note is still waiting.

Rice, oil, garlic, yogurt, spinach, tomato, and lemon are tapped. Spinach and yogurt are starred to use soon.

Gemma wrote this note. The badge says From Gemma. The title is "Quick Spinach & Rice," and the why line is "A simple, nourishing meal." The steps rinse the spinach thoroughly and roughly chop it, heat the oil and sauté the minced garlic until fragrant, add the spinach with a pinch of salt and let it wilt slightly, then pour in the yogurt and stir. Spinach and yogurt, the two starred foods, are both used in the steps. The card shows the server-measured time, gemma3:1b · 10.6s.

Code

Anandb71 / still-good

Still Good: one dinner from what's left in the fridge, written by Gemma 3 1B running locally via Ollama. Hacktoberfest 2026 DEV weekend challenge.

Still Good

Still Good turns what is left in Sathguru's fridge into one dinner he will actually cook tonight: a four-step sticky note that obeys his diet, allergies, time, and skill.

It is for Sathguru, who shops with good intentions and then stares at the crisper around 8pm. One profile, stored in the browser. No account.

Screenshots

Friend card: vegetarian, nut allergy, 15 minutes, skill "follow steps."

Fridge: chips selected, spinach and yogurt starred "use soon."

The note after a real Gemma reply on this machine. The card says whether the words came from Gemma or from the fallback, and it shows the model name plus the generation time the server measured.

Setup

Install Ollama, then pull the small model:

ollama pull gemma3:1b

From this directory, use the existing virtualenv and install the app plus the test tools:

./.venv/bin/pip install -r requirements.txt -r requirements-dev.txt

Playwright is listed in requirements-dev.txt…

View on GitHub

ollama pull gemma3:1b
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
uvicorn app.main:app --host 127.0.0.1 --port 8765

The tests never call Ollama. python -m pytest tests -q runs 29 tests on the filter, the ranker, and the note parser.

How I Built It

Code picks the dish. Gemma only writes the note.

Gemma 3 1B (gemma3:1b) runs through Ollama on a CPU-only box. I have 38 handwritten skeletons, each with a fallback note. Python filters by diet, allergies, won't-eat foods, time, skill, and ingredients on hand. Stars change the ranking.

I send Gemma the chosen skeleton and an allow-list, and ask for a title, a why, and four steps. The call streams at temperature 0.2 with num_predict 90, and I stop it early. A step that names a disallowed food or an allergen gets dropped. Starred use-soon foods have to appear in the steps. If they do not, I retry once, then show the handwritten note: "Gemma skipped the yogurt; here's the sure version." A malformed reply says "Gemma mumbled; here's the sure version." No answer says "Gemma didn't answer; here's the sure version." The card shows the time the server measured.

On an idle CPU one note took about 6.7 seconds. Another, while the shared machine was heavily loaded, took 213.3 seconds. I wait five minutes before that fallback, so a slow run can still finish. No build step. The profile lives in localStorage.

Why Does Open Innovation Matter?

Sathguru's diet stays on the laptop. The app runs offline on localhost, the prompt never leaves the machine, and a note has zero per-request cost. OLLAMA_MODEL swaps the weight when a bigger local model fits. Gemma 3 1B was small enough for the only box I had.

The trade-off is right there in the timings. A loaded CPU is slow, and a 1B model sometimes writes a flat sentence, which is why the card shows the real server time and the handwritten note is ready when the wording fails.

I built the app with the Cursor agent, using Grok 4.7 High as a coding assistant. The app itself runs on open pieces: Gemma 3 1B through Ollama for the note, FastAPI for the server.

Prize Categories

Best Use of Gemma. Gemma 3 1B is the only writer of the sticky note, running locally through Ollama. The prompt, the stream cutoff, the allow-list, and the handwritten fallback exist so a 1B model can title the dish and write four short steps, while Python keeps the diet, the allergy, and the fridge honest.