Back to Being: go outside, write it yourself, then let a local AI name what you noticed

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

What I Built

Back to Being is a small digital detox ritual with a web app wrapped around it. Its tagline is remembered, not recorded.

The ritual has a few steps:

1. Go out and notice things. No photos, no notes, no AI.
2. Remember. Let it settle for a while.
3. Write it down in your own words. No polishing, no rewriting tools.
4. Share it with someone, who then writes four or five lines of their own about what they noticed.
5. Seal it. Only now does a small AI model read what you wrote and name your badges.

What bugged me enough to build this: a lot of us photograph a moment before we've actually felt it, and more and more we ask AI to find the words for us. I wanted something where the experience, the memory and the words all stay yours.

Then I read the challenge prompt, "build with open-source AI at its core", and realised my idea bans AI from the walk and the writing. For a while I thought I'd picked the wrong project.

The way out was to let the AI speak last. It never writes for you, edits you, or suggests anything. After you and your listener are completely done, a model running on your own computer reads your words and names a few small things you noticed, like "Wet Earth Smell" or "Crow Calling Sound". Each badge has to quote your exact words as proof.

A few details that matter:

• The app is the shortest part of the experience. It has no camera, no photo upload and no audio. The Write page is a plain box with spell-check off, because red squiggles are quiet pressure to be "correct".
• The listener's box blocks pasting, so nobody can paste an old WhatsApp message to earn a badge.
• A separate "Shared and Heard" badge is given for the act of sharing, whatever the listener wrote. It's given by plain code, not by the model, so it can't be fooled by flattery.
• Badges are private keepsakes, not something to post or compare. (I'm showing one below on purpose.)

It's for anyone who wants an excuse to look up from their phone, and honestly, for me.

Demo

Live site: https://back-to-being.onrender.com

The live site has a "See a saved example" page, so you can see a full ritual and its badges without installing anything. Making your own badges needs Ollama and a Gemma model on your computer.

I actually took it outside

I went to a nearby park and spent around an hour there. Watching children play the games I used to play as a kid felt strangely nostalgic. I saw the swings, rides, and seesaw, and for a while, it felt like time had stopped. I was away from the usual chaos of life, just sitting there and observing things without rushing anywhere.

I waited for 1 day before writing about the experience.I shared my experience with a friend, and she said she wanted to experience something similar too. It made me realise that sometimes, we don't realise how much we miss the little things until we experience them again.

Code

https://github.com/ShreyashiGupta2310/Back-to-Being

How I Built It

The open-source AI: I used Gemma (gemma4:e2b) running locally through Ollama. The app calls Ollama on localhost, so the model runs on the user's own machine. I ask for a structured JSON answer using Ollama's schema option, use a low temperature (0.3) to keep it careful, and give it a short system prompt with rules and one example.

The stack: React, TypeScript and Vite, Tailwind CSS v4, React Router, Vitest. No backend and no database. Everything is saved in the browser's own storage. It's hosted as a static site on Render.

I started thinking in MERN, since that's what I know, and then deleted the "M" and the "E". A server and database would have broken the one promise the app makes: nothing leaves your device.

The part I care about most: not trusting the model. A small model will sometimes pad its answer, repeat itself, or quote words you never wrote. So the model only suggests, and plain code decides. The core of the checker is small:

const haystack = ` ${normalize(writing)} `
if (!haystack.includes(` ${quote} `)) {
  // refuse this badge: the quote is not in the writing
}

A badge survives only if its quote really appears in your writing, word for word (ignoring capitals and punctuation, and matching whole words only, so "cro" can't sneak in from "crows"). It also rejects unknown categories and duplicate quotes, and keeps at most three badges. Whatever it refuses is shown in a "suggestions left out" box, with the reason. I wrote tests for the checker, for the Social Badge, and for the demo data.

Other decisions:

• Sealing saves your words first. If Ollama is off, you still get a sealed ritual and the Social Badge, and an "ask the model again" button.
• The model's answer is typed as unknown until it has been checked field by field.
• Badges are React components, not SVG strings, so text from a model never gets pasted into raw markup.
• No web fonts. Headings use fonts already on your computer, so the page never contacts a third party.
• Demo mode is its own page, not an "is this a demo?" flag spread through the app.

What went wrong (the useful part):

1. The model gave me nothing. I tested it with an account about doing something (a small resale hustle) instead of noticing something, and it returned zero badges. My prompt was written around the senses (sound, smell, sight), so it had nothing to point at. I added a "moment" category for actions, put a worked example in the prompt, and added the retry button.
2. The model padded. In another test it gave me two badges that quoted the very same sentence. My duplicate check refused the second. That's exactly the kind of thing I built the checker for.
3. Vague writing gives vague badges. "I felt calm and happy" produced an accurate but generic badge. I think that's fair: a model can only name what you gave it.

How I used AI to build it: I used Claude as an assistant while building this. The idea, the ritual and how the app should feel are mine, and so were the engineering decisions: I chose what to keep, what to drop (like the backend), and how things should fit together. I ran and tested everything, debugged the problems as they came up, deployed it, and committed it myself. Claude explained the steps as I went, suggested approaches and files, and wrote or drafted a good part of the code, which I typed in and changed where needed.

Why Does Open Innovation Matter?

A journal entry is about as personal as text gets. Running an open-weight model locally gave me things a closed API wouldn't:

• Privacy that's real, not promised. Your words never leave your device. There's no server to trust, because there is no server.
• No cost and no key. Nothing to sign up for, nothing to pay per request.
• It works offline once the model is downloaded.
• I control the model and the rules. I can change the prompt, pull a different model, and put my own checker between the model and the user.

I want to be honest about the trade-off. A larger closed model would probably name more vivid, more accurate badges. But it would mean sending people's private memories to someone else's server, which contradicts the whole point of the ritual. For this app, a smaller model I can fully control, surrounded by code that doesn't trust it, was the better design.

Some limits, too:

• "Sealed" is a design promise, not encryption. The app gives no way to edit a sealed ritual, but it's stored as plain text in your browser.
• I can't prove your listener wrote their own words. Blocking paste is a speed bump. The ritual runs on trust.
• The hosted site can't make badges for you unless your own Ollama is running and allows that address. That's why the demo page exists.

Go. Observe. Remember. Write. Share. Keep it for yourself.

Prize Categories

• Best Use of Gemma: Gemma, running locally through Ollama, names the badges, and the whole design is built around that model's limits.
• Best Use of Render: the front end is hosted as a Render static site. This is a light use of Render, since the model deliberately runs on the user's own machine.