DEV Community: Aakash Mehta

Wraith: a ghost in my zsh that stops your hand before the dangerous command runs

Aakash Mehta — Sun, 01 Nov 2026 06:30:00 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

$ git push --force origin main
╭─ the wraith bars the door ─────────────────────────────────╮
│ git push --force origin main                               │
│                                                            │
│ Force-pushing to a shared branch rewrites history that     │
│ other people already have.                                 │
│                                                            │
│ ☾ I will wait. I have nothing but time.                    │
╰────────────────────────────────────────────────────────────╯
  Let it run? [y/N]

That is a ghost living in my zsh, and it just stopped my hand. I pressed Enter, nothing ran, and the command is still sitting in my line so I can edit it. The ghost is called Wraith. Gemma 3 4B runs on my own laptop through Ollama, and nothing leaves it.

The first idea on this week's prompt list was a haunted terminal that whispers about the commands you run. When I searched DEV I found at least twenty posts about haunted terminals. I had Claude Code read six of them closely. As far as we could tell, all six comment on a command after it has run, and none stops one before. So I made the ghost do the other thing, and then I gave it a silly side.

Wraith does four things:

It steps in before a risky command runs. git push --force, rm -rf outside your folder, git reset --hard, dd onto a disk, curl ... | sh and similar. Enter means no.
It whispers after a command. A failure, the same failure again, a slow build, a risky command that ran. The line appears above your prompt when it is ready, so the model never slows a prompt down.
It builds an ofrenda for dead commands. wraith ofrenda reads your shell history, finds tools you used often and then stopped using, and lights a candle for each one.
It is also very silly. Ten commands, no model and no network needed: a graveyard with epitaphs like "Here lies Internet Explorer", a ghost that floats across your terminal, a spider on a thread, a cauldron with a goofy brew, a ouija board, trick or treat.

How I read the theme: "ghost in the machine" is literal, a ghost in your shell that can reach out and stop your hand. Halloween is the bats, the cauldron and the jump scares. Día de los Muertos is the ofrenda, which says a name out loud once more. A shell history is a record of everything I used to rely on.

Demo

There is no hosted demo on purpose. Wraith lives in your own shell and its model runs on my laptop, so a public URL would defeat the point. You can run it yourself in about two minutes; the steps are right below.

Pictures of the real output (these are the text the commands printed, drawn with their colours, not photos of a terminal window):

The history in the ofrenda picture is made up (demo/history). I did not use anyone's real commands.

And here is the ouija board answering a question, exactly as it printed:

$ wraith ouija "will it ship today?"
  you asked: will it ship today?
   YES                    NO
 A B C D E F G H I J K L M
 N O P Q R S T U V W X Y Z
 1 2 3 4 5 6 7 8 9 0     GOODBYE

  ☾ the planchette moves... 4 0 4   S O U L   N O T   F O U N D

On a terminal the answer is spelled one letter at a time.

Code

aakashamy777 / spooky_october

Wraith

A ghost that possesses your zsh. After a command it may whisper one line. Before a risky command runs, it steps in and asks. And once in a while it builds an ofrenda for the commands you stopped using. The model is Gemma 3 4B, running on your own computer through Ollama. Nothing is uploaded.

Made for the Hacktoberfest Open-Source AI Challenge, Week 4: "Ghost in the Machine". The ghost is literal (it lives in your shell). The Día de los Muertos half is wraith ofrenda, which remembers the tools you used to rely on.

What it does

1. It steps in before a risky command runs. Press Enter on git push --force origin main, rm -rf ~/old, git reset --hard, dd of=/dev/disk2, curl ... | sh and similar, and the wraith shows a card with the reason and asks Let it run? [y/N]…

View on GitHub

Run it in your terminal

You need a Mac with zsh and Node 22 or newer, and nothing else for the silly commands. There is no npm install, because Wraith has no dependencies, and it never edits your files.

The silly commands (no Ollama needed):

git clone https://github.com/aakashamy777/spooky_october.git
cd spooky_october
node bin/wraith help
node bin/wraith haunt            # a random goofy horror picture, different every time
node bin/wraith graveyard        # tombstones with silly epitaphs
node bin/wraith fortune          # a spooky fortune cookie
node bin/wraith say "hello"      # a ghost says it for you
node bin/wraith boo              # a ghost floats across your terminal
node bin/wraith rain             # a rain of 🎃👻🦇🕷️💀
node bin/wraith spider           # a spider lowers itself on a thread
node bin/wraith ouija            # asks you a question, then spells the answer
node bin/wraith trick            # press a key: trick or treat
node bin/wraith surprise         # the wraith picks for you

haunt --list shows the eight scenes, and --seed 7 on any picture makes it repeatable. In a pipe or a log the animations print the finished picture at once.

The real thing: whispers, the gate and the ofrenda (needs Gemma):

ollama pull gemma3:4b            # about 3 GB, once
node bin/wraith doctor           # checks node, Ollama, the model and zsh
node bin/wraith ofrenda --history demo/history
node bin/wraith gate -- git push --force origin main

See the hook live, in a throwaway shell (type exit and it is gone):

mkdir -p /tmp/wraith-try/d && cd /tmp/wraith-try
zsh -f
export WRAITH_LEVEL=chatty
source /path/to/spooky_october/shell/wraith.zsh

Then type gti status and wait a few seconds for a whisper. Type git clean -fdx to see the gate, and press Enter to decline. To keep it in your real shell, wraith init prints the one line to add to ~/.zshrc, and wraith exorcise shows what to delete to be rid of it.

How I Built It

Gemma 3 4B through Ollama, called from plain Node. The hook is about 200 lines of zsh: preexec and precmd note each command, a wrapper around accept-line runs the gate, and zle -F lets a whisper arrive above the prompt while you sit at it.

The model only gets to dress up facts. Code decides the facts. A 4B model will happily invent a number, a name, or a claim, and I do not want a ghost that lies about my shell. So the exit code, the seconds, how many times in a row the same command failed, and whether a command can destroy data are all worked out in code. Gemma gets those facts and is asked for one eerie line. Then a check compares the line with the facts and rejects it if it contains:

a number that is not in the facts (digits or spelled out, so "thirty one" counts)
a name that is not in the facts
a claim that something was run, deleted or fixed
an instruction to type something
unsafe talk aimed at a person

If a line fails twice, a hand-written line is shown instead. Every line is labelled echo (Gemma) or omen (written by hand), so you always know which you are reading. The risky-command warnings never come from the model at all: the reasons are in lib/rules.js.

The silly commands are plain functions with a seeded random source, so the same seed always draws the same picture and I could test them: every scene fits the terminal, every written line is one of mine, and the jokes stay friendly.

What I measured on an Apple M3 with 8 GB, with a script in the repo (npm run measure, ten sample events, three runs each):


Lines that passed the check	29 of 30
Needed a second try	2 of 30
Median time per whisper, with retries	3.7 s (p90 5.3 s)
First request after the model was unloaded	about 10.8 s
Tests	200 passing, about 15 s

A whisper is one model call of about 2.5 seconds, which is too slow to run before a prompt appears. That is why whispers arrive in the background and the first one after a long idle is usually an omen.

Four things that broke, in the order I found them:

My check had a hole. In my first run it accepted "Thirty one seconds" and "Twenty-two seconds" when the real times were 310 and 52, because I only checked spelled-out numbers up to twelve. Now it reads teens, tens and two-part numbers as the numbers they are.
The model fixated. I told it to use "candles, doors, dust, echoes" and nearly every line became "Dust motes dance in the failing light." Now each call gets one random image and one tone, and the model is told to use at most one fact.
A real bug the end-to-end test found. When I drove a real interactive zsh with expect, answering y at the gate was ignored: the key was echoed back but read -k never returned it, so the command was declined. Setting the terminal mode explicitly in the gate fixed it. I do not know exactly which terminal setting differed, only that the test pty had unusual defaults and a real terminal did not show the problem in my runs.
My own bats froze the tests. The first version of the bat scene looped forever because the column never advanced, and the test run ate 2 GB of memory before it died. The loop now tracks how far it has drawn.

I started this week on a different project, a remembrance page builder called Ofrenda, and switched to Wraith on the last day. The earlier work is in the git history.

Why Does Open Innovation Matter?

Commands are some of the most private things on my computer. They hold paths, client names, tokens pasted into the wrong place, and a record of when I am awake. A whisper app built on a hosted model would have to send each of them somewhere, and the one that fails at 3 AM is exactly the one I do not want to send.

With an open-weight model I can make "nothing leaves your machine" a thing the code enforces and a test checks, not a sentence in a README. Wraith refuses to open a connection unless OLLAMA_URL is a loopback address. It hides secrets before anything reaches even the local model. The ofrenda only ever shows the model a program name, a count and a quiet time, never an argument, and a test feeds it a history full of credentials to prove it.

Open weights also let me measure the model instead of trusting it. I ran ten sample events three times each and counted what the check rejected. That is how I found the hole in my own check. And I can swap the model with one environment variable.

I did not benchmark a hosted model, so I will not claim Gemma writes better lines than one. What I can say is that the part I care about, a ghost that cannot leak your shell and cannot act on its own, only works because the model is mine.

The Spirit of It

An ofrenda is where you say a name out loud again. I wanted a small place to do that for the tools I stopped using: gulp, grunt, bower, python2, heroku. Each one was the centre of someone's workflow once, and each one is still in the history file with a count next to it.

The line under each candle is written by Gemma and is sometimes wrong in a way that fits. For heroku, used six times and quiet for 565 days, it wrote "Six deployments watched over a dark, silent window." The six is real. The deployments are a guess, and I think that is fine for an epitaph. It is also exactly the kind of invented meaning my check cannot catch, and I say so below.

The other half of the spirit is play. Halloween is allowed to be goofy. A terminal is a place where a spider can lower itself on a thread, a ghost can say "hello from the machine" in a speech bubble, and a ouija board can tell you "404 SOUL NOT FOUND". I wanted both the quiet candle and the cheap jump scare in the same tool.

What It Does Not Do

It is only tested on macOS with zsh 5.9. Not bash, fish, Linux or Windows, and not with real accept-line plugins (it chains to an existing widget, which a test checks). The silly commands are plain Node 22, so they should run elsewhere, but I have not tried.
It is not a security boundary. The gate only sees the line you press Enter on in an interactive zsh with the hook loaded. It does not see scripts, eval, aliases that expand later, bash -c "..." strings, or other terminals. It knows the patterns in lib/rules.js, not every dangerous thing, and wraith off turns it off.
The check does not catch every invented detail. It catches numbers, names, claims of action, instructions and unsafe talk. A line can still be wrong in meaning ("seven installations" for a tool called bower). Treat whispers as flavour, never as information.
Redaction works by pattern. An odd-shaped secret would reach the local model. It also hides full git commit ids, because it cannot tell them from keys.
After a long idle the first whisper is usually an omen, because Gemma needs about ten seconds to load.
macOS zsh keeps no dates by default, so wraith ofrenda counts "quiet" in commands unless you add setopt EXTENDED_HISTORY.
The animations are tested with a fake terminal, not by hand in every terminal app, and emoji width varies between fonts.
No one but me has used it, and I have not run it with the network switched off. The claim I can make is narrower: the code will only talk to a loopback address.

AI Disclosure

I used Claude Code to help build this project and to help write this post. Gemma 3 4B writes the whispers and epitaphs when Wraith runs; the lines labelled omen, the fortunes, the epitaphs on the tombstones and the ouija answers are hand-written. The tests and the measurements in this post were run on my own laptop.

Prize Categories

Best Use of Gemma. Gemma 3 4B, run locally through Ollama, writes every whisper and every ofrenda epitaph, and the rest of the design exists to make a small Gemma safe to use: code works out the facts, a check rejects lines that go beyond them, and a hand-written omen takes over when it does. I measured how often that happens (1 in 30 lines ended as an omen in the final run) and I list where it still fails.

DownloadsSloth: a local Gemma tool that tidies messy folders so you don't have to

Aakash Mehta — Sat, 24 Oct 2026 19:43:05 +0000

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

What I Built

My Downloads folder is a pile of IMG_20260720_214610.jpg, Screenshot 2025-09-04 at 23.11.13.png and scan0003.pdf. I never sort it, because renaming and filing files by hand is boring and slow.

DownloadsSloth does the boring part. You point it at a folder, and Gemma 3 looks at each file and suggests a clearer name and a folder (Photos, Screenshots, Documents and so on). You see the whole plan, tick what you agree with, edit any name, and press one button. It copies the approved files into a new folder. Nothing is moved, renamed, overwritten or deleted, and there is an Undo button.

It runs entirely on my laptop. My files never leave the computer.

Demo

Screenshots from a real run on a copy of my Downloads folder:

Code

aakashamy777 / downloads-sloth

DownloadsSloth

What it is

DownloadsSloth is a local folder organizer that runs on your computer and helps tidy messy folders like Downloads or Desktop. It uses an open-weight local vision-language model (Gemma 3 4B via Ollama) to inspect messy filenames and image contents, proposes clear file names and categorized folders in a review table, and lets you safely copy approved items into an organized output directory with full undo capability.

The problem

Most people have folders packed with hundreds of files named IMG_1234.jpg, Screenshot 2026-03-01 at 10.30.00.png, doc.pdf, scan0003.pdf, and download (2).jpg. Sorting them manually is tedious: you have to open each file, figure out what it is, invent a sensible date and descriptive name, create category folders, and drag files one by one. Because it takes too much time, messy folders stay unsorted.

How it works

Scan: You provide an absolute path to…

View on GitHub

Setup: install Ollama, run ollama pull gemma3:4b, then npm install and npm start, and open http://127.0.0.1:3000.

The Lazy Payoff

What I measured, on a test folder of 44 files (images, PDFs, documents and spreadsheets copied from my own Downloads):

Gemma produced suggestions for all 44 files in 141 seconds, unattended.
After that, applying the approved changes took under a second for a batch.

What I did not measure: how long the same folder takes to sort by hand. I didn't time a manual run, so I won't claim a number. The saving is the typing and the opening of every file, and I can't say how big it is for you.

How I Built It

Model: Gemma 3 4B through Ollama. For images it sees a small preview; for PDFs, documents and spreadsheets it uses only the file name, type and date, because the tool does not read their contents.
Server: Node.js and Express, bound to 127.0.0.1 only. A background job processes files one at a time, with a progress bar and a Cancel button.
Structured output: Gemma returns JSON (new name, folder, reason, confidence), validated and retried once.
Built in stages: health check, read-only scan, suggestions, then apply and undo, testing each stage on a copy of my files before the next.

Safety Is Enforced in Code, Not Just the Prompt

A tool that touches your files has to be boring and careful, so these rules are in code:

The scan is read-only, only works inside my home folder, and refuses system folders, ~/Library and hidden folders. I tested /, /etc, ~/.ssh, a relative path, and a ../../.. escape, and all were refused.
The server re-scans the folder itself and never trusts file names sent from the browser. A path-traversal attempt (../../etc/passwd) is skipped as "not found".
Apply only copies into a new output folder, never overwrites (a repeated name becomes -2), checks the size of every copy, and refuses an output folder that is the source or inside it.
Undo removes only the copies the tool made, and only if their size still matches its log.
The model never picks the extension or the final folder. Code keeps the original extension, cleans the name, and forces the folder to a fixed list.
Low-confidence rows are unchecked by default.

What Went Wrong, and How I Fixed It

Everything came back "High" confidence, even PDFs the tool had judged only by name. I capped confidence in code: non-images are never above "medium".
It renamed files that were already clearly named. Now only meaningless names (IMG_..., Screenshot ..., scan0003, WhatsApp Image ...) are renamed. Clear names are kept and marked "kept".
Wrong dates: a file from the evening of Oct 18 was labelled Oct 17, because the date came from UTC. It now uses the date in the file name, or the local date.
Screenshots were called "portrait". They now go to a Screenshots folder.
doc.pdf became 2025-12-07-pdf.pdf. When the tool can't read a file's content, it now keeps the name and sends the file to Review instead of inventing one.

Why Does Open Innovation Matter?

Privacy. These are the files people don't want to upload: bills, screenshots, résumés and photos. A hosted model would receive every one of them.
Cost. There is no per-file fee, so you can run it on a folder with thousands of files.
Control. I could wrap the model in checks and swap it later. Several of the fixes above exist because the 4B model ignored rules written in the prompt, so I enforced them in code.

What It Does Not Do

The suggestions are guesses. A human reviews every change before anything is copied. One image was labelled "gangsters" with high confidence from the clothing in a still, which is not something a photo can prove.
Documents are judged by name only. The tool does not read the inside of PDFs, documents or spreadsheets.
It describes a picture, but doesn't know who is in it. I told it not to name people or characters.
Image analysis is macOS only, because the preview uses the built-in sips tool.
Small rough edges: an apply that copies zero files still creates an empty output folder, and characters like % in a name are turned into -.
I did not time a manual run, I have no first user yet, and I have not tested it on Windows or Linux.

AI Disclosure

I used Antigravity to help write the code, and a Claude assistant helped me plan the build, test it and write this post. The app itself runs on Gemma locally.

Prize Categories

Best Use of Gemma: Gemma 3 4B suggests names and folders from image previews and file names, entirely on the user's own computer.

[Boost]

Aakash Mehta — Sun, 18 Oct 2026 05:34:57 +0000

Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle Submission 💸

Aakash Mehta

Oct 18

ListingForge: a local Gemma tool that drafts shop listings from product photos

#hf26challenge #devchallenge #ai #opensource

4 min read

ListingForge: a local Gemma tool that drafts shop listings from product photos

Aakash Mehta — Sun, 18 Oct 2026 05:34:33 +0000

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

What I Built

ListingForge helps a small online seller turn photos of one product into a first draft of a shop listing. You add 1 to 4 photos, choose Etsy or eBay, and optionally add a one-line note. Gemma 3 looks at the photos and drafts a title, a description of about 100 words, tags and a condition note. It also gives you a box called "Things only you can fill in", which lists everything a photo can't tell: size, material, price, shipping, and whether the item is handmade, vintage or mass-produced.

Who would pay for it: a small seller who lists a few items a week and finds writing listings tedious. I have not validated pricing with anyone, so I can't say what they would pay. I built the version that is cheap enough to run for free on a laptop.

It runs entirely on my computer. No account, no cloud, and the photos never leave the machine.

Demo

I don't have a hosted demo on purpose. The model runs locally through Ollama, so a public URL would defeat the point.

Screenshots from real runs on my laptop:

Code

aakashamy777 / listingforge

ListingForge

What it is

ListingForge is a local-first web application that turns product photos into draft shop listings for online marketplaces. It runs entirely on your own computer using a local Ollama server and the Gemma 3 4B vision model. It uses standard Node.js and vanilla browser technologies, with no client-side frameworks, no build step, and no cloud API dependencies.

Who it is for

ListingForge is designed for small sellers on Etsy or eBay who find writing product listings tedious and repetitive, but who still want an honest, factual starting draft based strictly on what their photos show.

How it works

Browser photo preparation: When you select or drop up to 4 product photos, the browser resizes them client-side using an HTML canvas to a maximum of 1024px on the longest side (JPEG at 0.8 quality). This keeps base64 payload sizes small and fast to process.
Local server handling…

View on GitHub

Setup: install Ollama, run ollama pull gemma3:4b, then npm install and npm start, and open http://localhost:3000.

How I Built It

Model: Gemma 3 4B (vision) through Ollama. It does two jobs: a quick "are these all the same product?" check, then the listing draft.
Server: Node.js and Express, with a small API for the health check, the same-product check and the listing.
Client: one plain HTML page. Photos are resized to 1024px JPEG in the browser before they are sent.
Structured output: every call asks Gemma for JSON, validates it, and retries once if it is invalid.
Built in stages: health check, photo upload, listing generation, then safety fixes, testing each stage before starting the next.

What Went Wrong, and How I Fixed It

My first test uploaded four different products at once. Gemma wrote one listing about two of them and dropped the other two. It also used words like "handmade", "hand-thrown" and "luxurious", which a photo can't prove. And the to-do box said "All essential details appear covered", which was false, because size, material and price never show in a photo.

I added instructions to the prompt, and the small model ignored the "detect mixed photos" rule. What worked was moving the rules into code:

A separate yes/no check ("do all photos show the same product?") before any listing is written. With four different products it now names them and stops. With three different mugs it correctly says they are separate items.
A list of words the draft may not use unless the seller's note says so, enforced in the prompt and again in code.
A to-do list that is always added by the server: size, material, price, shipping, and whether the item is handmade, vintage or mass-produced.
A last fix after a test on my own mouse: the draft said "wireless", but one photo can't show that, so features that can't be seen now go to the seller as questions.

What I Tested

One real product, one photo (my mouse, photographed by me): a plain, accurate draft that described only what was visible and used "appears to be" wording.
Four different products together (mug, wallet, earrings, candle): rejected, with the products named.
Three different mugs together: rejected as separate items.

Why Does Open Innovation Matter?

Privacy. A seller's photos and product details stay on their own computer. A hosted API would receive every photo.
Cost. There is no per-listing fee, so listing 500 items costs nothing beyond electricity. For a side hustle with thin margins, that decides whether the tool is worth using at all.
Control. I could add checks around the model and swap it later without being locked into someone else's pricing or rules.

What It Does Not Do

It is a draft, not a finished listing. A seller must review every word. It never generates prices or sizes.
I have not had a first user yet, so I can't tell you what a real seller would pay or ask for next.
I tested one real product with real photos. The rest of my tests used other images, so the results are early.
A 4B model is imperfect. It can miss details, and the same-product check can be wrong on unusual photos. I tell the user when it can't decide.
I have not tested it on a phone.

AI Disclosure

I used Antigravity to help write the code, and a Claude assistant helped plan the build and write this post. The app itself runs on Gemma locally.

Prize Categories

Best Use of Gemma: Gemma 3 4B does the same-product check and the listing draft, entirely on the seller's own machine.

GrassQuest: a local Gemma scavenger hunt that sends you outside

Aakash Mehta — Sat, 10 Oct 2026 15:47:12 +0000

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

What I Built

GrassQuest turns a short walk into a photo scavenger hunt. You type where you're going, the season and how long you have. Gemma writes five things to find: a leaf shape, bark, a flower, a puddle reflection, a small insect. You snap a photo of each, and Gemma checks it. At the end it writes a short field journal from only what you actually found.

The idea is simple: the screen should be the shortest part of the walk. You plan in about 20 seconds, then put the phone away.

It runs entirely on my laptop. No cloud, no account, and no photo ever leaves my machine.

Demo

There is no live URL on purpose. The model runs locally through Ollama, so a hosted copy would defeat the point.

Screenshots from the demo:

Code

aakashamy777 / Touch_Grass

GrassQuest

A local-first app for the Hacktoberfest "Touch Grass" challenge.

Prerequisites

Node.js installed
Ollama installed and running locally
The gemma3:4b model pulled in Ollama

Setup

Install dependencies:
```
npm install
```
Pull the required model if you haven't already:
```
ollama run gemma3:4b
```
Start the server:
```
npm start
```
Open your browser and go to http://localhost:3000

View on GitHub

Setup: install Ollama, run ollama pull gemma3:4b, then npm install and npm start, and open http://localhost:3000.

How I Built It

Model: Gemma 3 4B (vision) through Ollama. It writes the quest, judges each photo and writes the journal.
Server: Node.js and Express, with small endpoints for quests, photo checks and the journal.
Client: one plain HTML page. Photos are resized to 1024px in the browser before upload, and progress is saved in localStorage so a refresh doesn't lose the quest.
Structured output: every call asks Gemma for JSON, validates it, and retries once if the output is bad.
Built in stages: skeleton and health check first, then the quest generator, the photo check and the journal, testing each stage before starting the next.

Why Does Open Innovation Matter?

Privacy. Your photos and your area stay on your own machine. A closed API would receive every photo you take.
No signal needed. Once the model is downloaded, the whole app works without internet, which is what you want on a trail.
Cost. It is free to run, however many walks you take.
Swappable. Changing one model name lets me try another open vision model without rewriting the app.

What I Tested

I tested the photo check with real photos on my laptop. Five matching photos passed their tasks, and mismatched photos were rejected. A photo of roses was correctly rejected on a different flower task.

Task	Photo	Result
Leaf with five lobes	maple leaf	pass
Close-up of rough bark	tree bark	pass
Cluster of pink flowers	flowers	pass
Building reflection in a puddle	puddle	pass
Small insect on a leaf	stink bug	pass
Any task	unrelated photo	rejected

What It Does Not Do

Look-alikes can slip through. A chrysanthemum passed on a task that asked for a similar pink flower. A 4B model recognises "flower" better than an exact species. I added a "Gemma is not sure" note for low confidence, but it is not perfect.
Quests aren't always local. Gemma sometimes suggests things that don't grow near you, such as maple leaves in Bengaluru.
I have not done a full outdoor field test or a phone test yet. Testing so far was on my laptop, using saved photos.
The journal needed a fix. The first version invented dates and details that were not in the input, so I changed it to use only the photo notes.

AI Disclosure

I used Antigravity to help write the code, and a Claude assistant helped me plan the build and write this post. The app itself runs on Gemma locally.

Prize Categories

Best Use of Gemma: Gemma 3 4B does all three jobs (planning, vision and writing) locally.