DEV Community: fatik07

I let Gemma 4 name 198 screenshots I was never going to rename

fatik07 — Tue, 20 Oct 2026 09:19:19 +0000

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

What I Built

My screenshot folder has 226 files in it. 198 of them are called something like this:

Screenshot from 2022-11-15 10-01-34.png

193 are from my old Ubuntu laptop, moved over to my Mac and never touched again. Every time I need "that Laravel error from last year", I open them one by one. I have never renamed a screenshot by hand, and I'm not going to start now.

So I built sloth-shots, a small command-line tool that looks at each screenshot with an open-weight vision model (Gemma 4) and renames it after what's actually in it:

Screenshot from 2022-11-15 10-01-34.png  ->  2022-11-15_laravel-postgresql-role-does-not-exist.png
Screenshot from 2022-12-14 10-33-31.png  ->  2022-12-14_php-undefined-type-pdf-error.png
Screenshot from 2022-03-29 10-09-20.png  ->  2022-03-29_jsfiddle-javascript-matrix-code-snippet.png

The date stays at the front, so the folder still sorts by time. The rest of the name is something Spotlight can actually find.

It has two modes:

tidy renames the backlog you already have.
watch stays running in the background. Take a screenshot, and about a second later it has a real name. You don't do anything.

Demo

This is a real dry run on 20 copies of screenshots from my folder (Gemma 4 31B through OpenRouter). The whole run took 22 seconds:

$ sloth-shots tidy ~/demo
Dry run (nothing is renamed; add --apply): 20 screenshot(s)

Screenshot from 2022-08-25 09-20-51.png
  ~> 2022-08-25_vscode-file-explorer-project-structure.png  (1.3s)
Screenshot from 2022-09-13 14-34-26.png
  ~> 2022-09-13_comparison-shared-vs-cloud-hosting.png  (1.2s)
Screenshot from 2022-09-21 14-20-35.png
  ~> 2022-09-21_dicoding-computer-knowledge-quiz.png  (0.9s)
Screenshot from 2022-10-06 10-52-21.png
  ~> 2022-10-06_vscode-css-flexbox-container-settings.png  (0.9s)
Screenshot from 2022-11-15 10-01-34.png
  ~> 2022-11-15_laravel-postgresql-role-does-not-exist.png  (0.9s)
Screenshot from 2022-12-05 09-42-39.png
  ~> 2022-12-05_petanikode-programming-loop-flowchart.png  (0.9s)
Screenshot from 2022-12-14 10-33-31.png
  ~> 2022-12-14_php-undefined-type-pdf-error.png  (2.7s)
Screenshot from 2023-02-04 11-51-35.png
  ~> 2023-02-04_phpmyadmin-rajaongkir-province-table.png  (0.9s)
Screenshot from 2023-05-08 14-31-20.png
  ~> 2023-05-08_vscode-json-api-response-data.png  (1.0s)
...

You may notice there are no screenshots in this post, only filenames. That's on purpose. When I checked the results, the Laravel error contained a company database hostname, its IP address and an employee ID, and the JSFiddle one was taken during a Google Meet call with other people's names and faces in it. Screenshots are full of things you'd never post. That's also why I care about the model being open, more on that below.

I checked several of the names against the actual images. Most were spot on. One was wrong: terminal-update-alternatives-command is really a Telegram chat preview that happens to show a sudo update-alternatives command. That's a reasonable mistake, and the name is still more findable than Screenshot 2023-06-17 at 14.13.24.png.

Code

fatik07 / lazy-screenshoot-renamer

sloth-shots 🦥

Your screenshot folder is full of files called Screenshot 2023-06-17 at 14.11.12.png. You will never find the one you need.

sloth-shots looks at each screenshot with an open-weight vision model (Gemma 4) and renames it after what's in it. Real output from my own screenshot folder:

Screenshot from 2022-11-15 10-01-34.png  ->  2022-11-15_laravel-postgresql-role-does-not-exist.png
Screenshot from 2022-12-14 10-33-31.png  ->  2022-12-14_php-undefined-type-pdf-error.png
Screenshot from 2022-03-29 10-09-20.png  ->  2022-03-29_jsfiddle-javascript-matrix-code-snippet.png

Leave watch running and you never think about it again. Take a screenshot and about a second later it has a name you can search for in Spotlight.

Setup

Get an API key at https://openrouter.ai/keys. A few dollars of credit goes a long way: each screenshot costs about $0.00003.
Export it:
```
export OPENROUTER_API_KEY=sk-or-...
```

Run the tool. It has no dependencies beyond Python 3.10+:

uvx --from . sloth-shots --help
# or simply
python3 sloth_shots.py --help

Usage

If you don't pass a folder, sloth-shots…

View on GitHub

It's one Python file with no third-party dependencies:

export OPENROUTER_API_KEY=sk-or-...
python3 sloth_shots.py tidy --limit 5          # dry run, renames nothing
python3 sloth_shots.py tidy --limit 5 --apply  # apply (reuses the dry-run answers)
python3 sloth_shots.py watch                   # rename new screenshots as you take them
python3 sloth_shots.py stats                   # how much effort you've saved
python3 sloth_shots.py undo                    # put every original name back

How I Built It

The pipeline for each screenshot is short:

Find it. Only image files whose names start with Screenshot or Screen Shot are touched. A renamed file no longer matches, so nothing gets processed twice. Other locales work with --prefix.
Shrink it. macOS's built-in sips downscales the image to 1024px before upload. A 965 KB retina PNG becomes about 80 KB. If the original is already smaller, it sends the original.
Ask Gemma. The image goes to Gemma 4 with a short prompt: 3 to 6 words, lowercase, hyphenated, name the app first, be specific ("vscode-python-import-error" beats "code-editor").
Clean the answer. Models sometimes get chatty ("Sure! Here's a name: …"), so the tool pulls the hyphenated part out of the reply. If there's nothing usable, the file is skipped rather than renamed to junk.
Rename safely. It never overwrites a file (collisions get -2), logs every rename to a .jsonl file so undo works, and tidy is a dry run until you add --apply. Dry-run answers are cached, so applying them doesn't call the model again.

watch is a plain polling loop: it checks the folder every 2 seconds and waits until a file's size stops changing, because macOS writes screenshots in steps.

The hardest part wasn't the code, it was getting a response at all. I started on the free Gemma 4 endpoints, and this week they were swamped. Every request came back 429: temporarily rate-limited upstream, and the few that got through took 70 to 90 seconds. So the tool now tries a list of models in order: Gemma 4 31B, then Gemma 4 26B-A4B, then the free tier. If one is busy or out of credit, it moves to the next instead of sitting in a retry loop.

Why Does Open Innovation Matter?

Gemma 4's weights are public, and that changed how this project turned out in two ways.

It made it almost free. Because anyone can host the weights, about a dozen providers serve Gemma 4 on OpenRouter and compete on price. Naming my 20 test screenshots cost $0.0008. The full backlog of 198 comes to under one cent. When the free pool was overloaded, I could simply switch to a paid provider running the exact same model. With a closed model, I'd have one vendor and one price.

It means the model is mine to keep. The model naming my screenshots today will behave the same way next year. Nobody can deprecate it or quietly retrain it, which matters for a tool whose whole job is to be consistent across thousands of files.

And there's the privacy problem I hit in the demo: my screenshots contain hostnames, IDs and other people's faces. Right now they go through OpenRouter. Because the weights are open, the same model can also run fully offline on my own laptop, and a local backend is the next thing I want to add. That's only an option because the model is open.

The Lazy Payoff

198 screenshots in my folder with no real name.
Renaming one by hand means opening it, looking at it, thinking of a name and typing it. Call it 20 seconds. That's about 66 minutes I was never going to spend.
sloth-shots did 20 of them in 22 seconds for $0.0008, and in watch mode it takes zero effort from me from now on.

The best part is that I don't have to remember to run it. That's the whole point.

Prize Categories

Best Use of Gemma: Gemma 4 (31B and 26B-A4B) is the only model the project uses. It does all the vision work.

Strukku: Receipt Bookkeeping for Freelancers, Built on an Open-Weight Model

fatik07 — Thu, 15 Oct 2026 06:05:58 +0000

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

What I Built

Strukku: upload a photo of a receipt, and an open-weight vision model reads it — vendor, date, amount, currency, and expense category — straight into a running bookkeeping ledger you can export as a CSV.

The target user is a freelancer or small shop owner who currently does one of two things every month: pays a bookkeeper to manually retype a shoebox of receipts, or loses an evening doing it themselves. Strukku turns that into "take a photo, done."

It's specifically tuned for a case most bookkeeping tools handle badly: messy, mixed-language, informal local receipts — a handwritten note from a small Indonesian warung, a Gojek/Grab ride receipt, a market vendor's scrawled total. General-purpose OCR and bookkeeping SaaS are trained mostly on tidy, printed, English-first receipts, and fumble exactly this case.

Who would pay for this

Anyone currently paying a bookkeeper, or burning an afternoon a month doing their own books by hand. A tool that's faster than both and cheap enough to run for free is worth a small monthly fee on its own merits.

Demo

Not deployed yet — I built and verified this entirely within the challenge window (typecheck and production build both pass), but haven't yet run it against real photographed receipts with a live Supabase + OpenRouter setup, so I'm not going to claim a polished demo I haven't actually seen work. The honest next step, before I'd trust this with real bookkeeping, is exactly that: clone it, wire up a free Supabase project and OpenRouter key (both free), and feed it a stack of real receipts.

Code

github.com/fatik07/strukku — MIT-style setup instructions in the README, including the SQL to set up Supabase.

How I Built It

Stack: TanStack Start, TypeScript, TanStack Router, TanStack Query, TanStack AI (@tanstack/ai + @tanstack/ai-openrouter), Supabase (Postgres + Storage), OpenRouter, Tailwind CSS.

The flow:

Receipt photo → base64 → Supabase Storage (saved) → vision model (OpenRouter) → structured JSON → Zod validation → receipts table → ledger + CSV export

The AI call sends the photo as an image content part alongside a prompt tuned for the messy-receipt case:

function imageMessage(base64: string, mimeType: string) {
  return {
    role: 'user' as const,
    content: [
      { type: 'text' as const, content: RECEIPT_EXTRACTION_PROMPT },
      { type: 'image' as const, source: { type: 'data' as const, value: base64, mimeType } },
    ],
  }
}

The prompt itself explicitly tells the model what it's looking at:

"The receipt may be in Indonesian, English, or a mix of both, and may be a neat printed receipt, a crumpled handwritten note from a small local shop (warung), or a ride-hailing receipt (e.g. Gojek, Grab)."

The model's output is validated against a Zod schema before it ever touches the database — if the model doesn't support strict structured output, there's a plain-JSON fallback that re-parses its response, same defensive pattern I'd use for any untrusted model output.

The entire AI call is isolated in one module (src/server/ai/adapter.ts), so swapping models — or providers — is a one-line change, not a rewrite.

Why Does Open Innovation Matter?

Three concrete reasons I picked an explicit open-weight model (Google's Gemma, via OpenRouter's free tier — google/gemma-4-31b-it:free, not the openrouter/free router, which could silently pick a non-open model for a given request) over a closed API:

Cost. The whole pitch is "cheaper than a bookkeeper." An AI step that costs nothing to run is what makes that arithmetic actually work at a small monthly price.
No lock-in. If a different open-weight model turns out to read Indonesian handwritten receipts better, swapping it in is a one-line change in adapter.ts, not a renegotiated API contract with a single vendor.
Financial data privacy. Receipts are financial records. Keeping the AI layer open-weight keeps the door open to eventually pointing this at a self-hosted model instead of permanently renting inference from one closed provider — a real option for a tool that handles someone's money.

My First User

Not yet — this is fresh code built during the challenge window, not yet handed to a real freelancer. The honest next step is exactly that: get it in front of someone who actually has a shoebox of receipts, and find out where the extraction breaks on their specific mess of paper.

AI Disclosure

Built with heavy assistance from an AI coding agent (Claude Code) — architecture, implementation, and this write-up. I reviewed the code and the claims above myself; nothing here claims to be tested beyond what's stated (typecheck + production build pass; live extraction accuracy against real receipts is the next thing to verify, not something I'm claiming already works).

What's in My Fridge? — An Open-Source AI Cooking Assistant I Built for a Friend

fatik07 — Mon, 05 Oct 2026 04:59:31 +0000

The problem

A friend of mine has a habit: they open the fridge, stare at a handful of random ingredients — some eggs, half a chicken, a bag of rice — and just... close it again. Not because there's nothing to cook, but because turning "what I have" into "what I could make" takes a kind of mental effort that's easy to skip when you're tired.

So for this weekend's Hacktoberfest challenge — Build for a Friend — I built them exactly that: What's in My Fridge?

Tell me what you have. I'll tell you what you can cook.

You add the ingredients sitting in your kitchen, optionally tell it something like "no spicy food" or "only 15 minutes," hit one button, and get back a handful of realistic meal ideas — each one clearly split into what you already have and what you'd still need to buy.

No chat window. No meal-planning dashboard. Just: ingredients in, meal ideas out.

Demo & code

Code: github.com/fatik07/my-frigde
Live demo: not deployed yet — this was built and tested locally during the challenge window. The README has full setup instructions if you want to run it yourself.

Why open matters here

The AI model is the core feature of this app — not a bolt-on. It runs through OpenRouter, defaulting to openrouter/free, OpenRouter's router that automatically picks a free, open model for each request.

Why that choice specifically, and not a single proprietary model locked behind one vendor's API:

It costs nothing to run. A friend using this shouldn't need me to keep a paid API key topped up. openrouter/free means the running cost is zero.
It isn't locked to one model. The entire AI call is isolated behind one small module (src/server/ai/adapter.ts). Swapping to a different open model — or a different provider entirely — is a one-line change, not a rewrite.
The rest of the app doesn't know or care which model answered. Everything downstream just sees validated, typed JSON.

To be precise about what "open" means in this build: inference doesn't run locally on my friend's laptop — it still happens on OpenRouter's infrastructure. What open buys here is choice and cost, not offline/local inference. I think that's a legitimate and underrated version of "open matters": it's the difference between a project my friend can actually keep running for free, versus one that quietly stops working the day my API credits run out.

How it works

Stack: TanStack Start, TypeScript, TanStack Router, TanStack Query, TanStack AI (@tanstack/ai + @tanstack/ai-openrouter), Supabase (Postgres), OpenRouter, Tailwind CSS.

The flow is deliberately boring and linear:

Ingredients (Supabase) → AI call (server-only) → OpenRouter → structured JSON → reconciled against pantry → rendered meal cards

A few pieces worth calling out:

1. The AI call never touches the browser. It's a TanStack Start server function, and the OpenRouter key only ever lives in process.env on the server:

export function getMealSuggestionAdapter(): OpenRouterTextAdapter<any> {
  const apiKey = process.env.OPENROUTER_API_KEY
  if (!apiKey) throw new Error('OPENROUTER_API_KEY is not configured')

  const model = process.env.AI_MODEL || 'openrouter/free'
  return createOpenRouterText(model as any, apiKey)
}

2. The response is schema-validated, not trusted prose. chat() takes a Zod outputSchema, so the model either returns a typed object or the call fails loudly — with a plain-JSON fallback for models that don't support strict structured output:

const result = await chat({
  adapter,
  messages: [{ role: 'user', content: prompt }],
  outputSchema: AiSuggestionsResponseSchema,
  stream: false,
})

3. The model's claims get fact-checked against the real pantry. This was the part I cared about most: an AI that says "uses: chicken" when you don't actually have chicken is worse than useless. So every suggestion gets reconciled server-side — anything the model claims as "used" that isn't genuinely in your pantry gets demoted to "missing" before it's ever rendered:

export function reconcileWithPantry(suggestion: MealSuggestion, pantryNames: string[]) {
  // anything claimed as "used" that isn't actually in the pantry
  // gets moved to "missing" instead — the model can't fake what you have
  ...
}

Standard stuff rounds it out: empty-pantry state, a loading state ("Thinking of something delicious…"), and a retry-able error state that never leaks a raw API error to the UI.

What I'd do differently

Given more time, the next step is exactly what the theme asks for: hand it to my friend and see what breaks. Right now it's been built and exercised locally, but not yet used by the person it's actually for — that's the real test, and I'll be reporting back on what they said.

AI disclosure

This project and this post were built with heavy assistance from an AI coding agent (Claude Code) — architecture, implementation, debugging version mismatches in the TanStack Start/Router packages, and writing this post. I reviewed and verified the code and claims above myself.

Built solo for the Hacktoberfest Weekend Challenge: Build for a Friend (#hf26challenge).