Sit Spot: a local journal for ten minutes outside

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

What I Built

Sit Spot is a small journal for short sit-outside sessions. You pick how long you'll be out (5, 10, 20 minutes, or your own number). The app gives you one short prompt and then gets out of the way: the next screen says "phone away" and has a single button, "I'm back".

When you return, you type rough notes. A few lines, typos and fragments are fine. A local model tidies them into a short journal entry. Your raw notes and the tidy version sit side by side, and you can edit either one or keep only the raw notes.

The screen is meant to be the shortest part of the experience, so the app measures it. Every entry shows how long you were outside and roughly how long you spent on screen. That comparison is the number I care about.

It's for anyone who wants a small, repeatable reason to go outside and pay attention, without an app competing for that attention. There are no accounts, no streaks and no notifications.

There's also a "What keeps showing up" button. It asks the model to look across recent entries for patterns and to cite the date of every entry it draws on.

Demo

The video shows one full session, from picking a length to a saved entry. it's in the repo

Code

madhav-1204 / Sit-Spot

Sit Spot

A local-first journal for short sit-outside sessions. An open-weight Gemma model running locally through Ollama gives you one brief prompt before you step outside, and tidies your rough notes when you return.

Built during Hacktoberfest Week 1 (Oct 5–11, 2026) for the "Touch Grass" challenge. The screen is designed to be the shortest part of the experience.

---

Setup in 4 Commands

git clone https://github.com/madhav-1204/Sit-Spot.git
cd sit-spot
pip install -r requirements.txt
python app.py

Then open your browser to http://127.0.0.1:5000.

(To populate sample entries for demonstration, run: python app.py --demo)

---

Local AI Model Configuration

Sit Spot uses an open-weight model running entirely on your local machine via Ollama. No cloud APIs, no tracking, and no internet access required at runtime.

1. Install Ollama from ollama.ai.
2. Pull the default Gemma model

   ollama pull gemma3:1b
   (Or use gemma3:4b / gemma2:2b by setting the environment variable SITSPOT_MODEL).
3. If…

View on GitHub

How I Built It

The app is Python, Flask, SQLite (standard library) and requests. The pages are server-rendered HTML with one CSS file. There's no JavaScript framework, no CDN and no web fonts. The only network calls go to localhost:11434.

The AI is Gemma 3 1B (gemma3:1b, about 806 MB) running locally through Ollama. The model name comes from an environment variable, so swapping models is a one-line change.

The model does three jobs, and each has its own prompt file in prompts/:

1. Session prompt: one instruction, 25 words at most, based on the time of day, the month and the last entry.
2. Tidy: 3 to 4 first-person sentences from the rough notes, plus one follow-up question for next time.
3. Look back: patterns across recent entries, with dates cited.

If Ollama isn't running, or a call takes longer than 60 seconds, the app saves the raw notes and uses prompts from a fallback file. It's still useful without the model.

What went wrong. My first run of the tidy step used five test entries. The 1B model made up sensory details that nobody had written (it added "felt cool beneath my fingertips" and "lilac flowers"). It also folded the follow-up question into the body paragraph. I fixed this by adding a one-shot example and explicit negative constraints to the prompt, and code that pulls the question out separately.

The second round was better but still wrong in a funny way. A note that said "Rain stopped about 10 minutes ago" came back as "I stopped the rain about ten minutes ago." I added a rule that natural events must never be attributed to the observer.

The results improved a lot but are not perfect. That's why the raw notes always appear next to the tidy version, with a line telling you to check one against the other. Every break and fix is in the dated log in NOTES.md.

I used Antigravity as the coding agent.

Taking It Outside

account:

• where you sat, and for how many minutes
• the exact prompt the app gave you
• your raw notes, and what the tidy version kept or got wrong
• the outside and screen times the app recorded
• one honest thing you noticed, good or bad]]

Why Does Open Innovation Matter?

A journal is personal. It records where you sit, what you notice and when you go out, which adds up to a picture of someone's routine. With a local open-weight model, that data never leaves the laptop. I didn't have to choose between a useful tidy-up step and keeping my notes private.

Cost was the second thing. Rewriting a note costs nothing per call, so I could keep running the same entries through the model while I fixed the prompts, without watching a bill.

Control was the third. The model is one environment variable, and the prompts are plain text files. When the model wrote "I stopped the rain," the fix was an edit to a text file and a re-run.

It also needs no internet at all, so the whole thing works with Wi-Fi off.

The trade-off is real. A larger hosted model would almost certainly have made fewer of the mistakes in my log. I accepted weaker output in exchange for privacy, zero cost and no dependence on a connection, and for a personal journal I think that's the right choice. The raw-notes-first design is what makes it safe to accept.

Prize Categories

Best Use of Gemma: Gemma 3 1B, run locally through Ollama, is the only AI in the project. It writes the session prompts, tidies the notes and summarises patterns, with no cloud API involved.