DEV Community: Carla

My first month of hackathons: 4 local AI projects, 4 lessons

Carla — Sun, 08 Nov 2026 17:40:14 +0000

October 2026 was my first month of hackathons. I wanted a few real projects on GitHub, something outside my work projects, and to learn new things by doing them. I joined Hacktoberfest: two small exercises in MLH Global Hack Week and three weekly DEV challenges.

The AI in every project is an open Gemma model running on my own computer with Ollama. No paid API. Here is what each project does, what went wrong, and what it taught me.

1. Search by meaning (Global Hack Week)

What it does. Ten short customer-support notes from a small online shop, saved in Postgres with pgvector on Tiger Cloud. EmbeddingGemma turns each note into a list of numbers that represents its meaning, so a search finds notes that mean the same thing, even with no words in common. "Voglio i soldi indietro" ("I want my money back") finds the note about a refund.

What went wrong. My query always returned 3 notes, even when none of them had anything to do with the search. LIMIT 3 means "give me 3 rows", not "give me the 3 that match".

What I learned. Search by meaning needs a minimum score. Relevant notes scored about 0.67–0.70 and unrelated ones about 0.50, so I keep only results above 0.6. Now "no results" is a possible answer. It isn't perfect: the refund note scored only 0.51 for "voglio i soldi indietro", so the minimum score hides it too.

2. Support Copilot (DEV week 2)

What it does. Picture a one-person shop that sells handmade ceramics. Every evening the owner answers the same emails: "my mug arrived cracked", "my parcel is late". Support Copilot finds how she solved similar cases before and writes a draft reply that follows her own policies. She reviews it and sends it.

What went wrong. For "My vase arrived broken, I want my money back", the search found two past cases: a broken item and a customer who changed their mind. Gemma sometimes picked the wrong policy: returns accepted if unused, customer pays shipping. Not what you tell someone holding a broken vase. And with a low minimum score, a question about teapots pulled in unrelated cases, and Gemma confidently said the shop had no teapots, something it couldn't know.

What I learned. What helped: telling the model to follow the most similar case, lowering the temperature to 0.2 so replies stay consistent, and raising the minimum score to 0.6. Now, when nothing relevant is found, the draft says the owner will check. And a person still reads every draft before it is sent.

3. Lazy Screenshot Namer (DEV week 3)

What it does. After week 2 I had a folder of files called "Screenshot 2026-10-11 173802.png". Renaming 7 of them by hand took me 10 to 15 minutes. Lazy Screenshot Namer asks Gemma 4 to look at each screenshot, describe it and suggest a short name, like sql-show-chunks.png. It also flags screenshots that seem to contain a password. I tested it with a fake password made for the test, and it caught it.

What went wrong. In my first version the model often got stuck in a loop, repeating words inside the file name. One name was 13,706 characters long. It took about 4 minutes per image, and no name was usable.

What I learned. Small models need limits and simple steps. Capping the output at 40 tokens (num_predict in Ollama) brought it down to about 9 seconds per image. Removing the example from my prompt stopped the model from copying it: three different screenshots had all been given the example name. And asking it to first describe the image, then name it in a separate step, took useful names from 2 out of 7 to 7 out of 7.

4. Tell the Tree (DEV week 4)

What it does. I used to keep my family tree on a genealogy website. The site shut down, and everything I had put there turned into a 404. Tell the Tree is a family tree that lives on my computer. You fill it in with sentences, in Italian or English, like "Allegra è figlia di Claire e di Lord Byron" ("Allegra is the daughter of Claire and Lord Byron"). Gemma copies the names and family words, my code decides what they mean and checks them, and the change appears as a preview. Nothing is saved until I confirm.

What went wrong. I wrote 15 test sentences to build with, and on those Gemma got 14 right. But I had also written 6 secret sentences before the engine existed, in everyday spoken Italian, and I ran them only once. Gemma got 1 out of 6. For example, it kept the title in "Nonna Lucia" (Grandma Lucia) and created a person called "papà" (dad). The secret sentences also found a real bug in my code.

What I learned. Test with sentences you didn't build on, and publish the result as it is. And keep a person in the loop: those wrong names would show up in the preview, where I can discard them before they are saved.

What's next

Right now I'm using Tell the Tree with my own family, on my computer only, and writing down every sentence it gets wrong. That list will decide what I fix next.

If you did Hacktoberfest this year too, what did you build?

My family tree became a 404, so I built one that lives on my computer

Carla — Sat, 31 Oct 2026 19:12:04 +0000

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

What I Built

I used to keep my family tree on a genealogy website: names, dates, photos. Then the site shut down, and everything I had put there turned into a 404.

That's my ghost in the machine: a family that still exists somewhere, in a database I can't reach anymore.

Tell the Tree is the tree I wish I'd had. You fill it in by telling it about your family, in plain sentences, in English or Italian:

Allegra è figlia di Claire e di Lord Byron.
(Allegra is the daughter of Claire and Lord Byron.)

A small open-weight model, Gemma 4 E2B, runs on my computer through Ollama and reads the sentence. My code checks it and shows the change in the tree as a dashed "new" preview. Nothing is saved until I confirm, and nothing ever leaves my computer.

It's for anyone who has family stories in their head and doesn't want to hand them to a website that might close one day.

The demo family has a ghost story of its own: the Godwins, the Shelleys and Lord Byron at Villa Diodati in 1816. That was the rainy summer when, stuck indoors, they held a ghost-story contest and Mary began writing Frankenstein. It's also a hard family to put in a tree. Mary's father, her half-brother and her son were all called William. Her husband and her son were both Percy. There are stepsisters and half-sisters everywhere.

Demo

Tell the Tree runs locally, so there's no live link. Here it is in action:

I type "Elizabeth è la sorella di Percy" (Elizabeth is Percy's sister). The tree has two Percys, so it asks which one I mean, shows Elizabeth as "new", and saves her only when I click "Add to tree". This was the first sentence after starting the app, so Ollama was still loading the model: the 22.7 seconds on screen are real, but I shortened that wait in the GIF.

Besides telling the tree in sentences, you can:

answer its questions when something is ambiguous ("Which Percy do you mean?")
add, edit or delete people by hand (the same checks apply)
fix a relationship
add a photo for each person, stored inside the tree file
search, and switch between a horizontal and a vertical tree
export and import GEDCOM, the standard format genealogy programs use to exchange trees
print the tree or a PDF register
switch between two themes: a plain register, and Villa Diodati 1816, with a moon and bats

Code

carla800 / tell-the-tree

A local family tree you build by telling it, in plain sentences. Gemma 4 E2B + Ollama.

Tell the Tree

A family tree you build by telling it, in plain sentences. It runs entirely on your own computer.

You write sentences like "Mary's father was William Godwin" or "Allegra è figlia di Claire e di Lord Byron" (English or Italian). A small local model, Gemma 4 E2B running through Ollama, reads the sentence. The code checks it against the tree and shows you a preview of the change. Nothing is saved until you confirm, and your data never leaves your computer.

Built for DEV's "Ghost in the Machine" challenge, October 2026.

Why I built it

I used to keep my family tree on a genealogy website. The site shut down, and everything I had entered turned into a 404. I wanted a tree that lives on my own computer, in a file I own, that I can export to a standard format (GEDCOM), and that I can…

View on GitHub

How I Built It

Gemma copies, the code decides

Family relationships are full of traps. In Italian, nipote can mean grandchild, or nephew or niece. A model asked to "work out the relationship" can get this wrong in a quiet, believable way, and a wrong link in a family tree is worse than a missing one.

So I split the work:

Gemma copies. It reads the sentence and copies out the names and the kinship word exactly as written: "half-brother", "fratellastro", "nipote".
The code decides. An Italian/English dictionary decides what that word means.
When a word is ambiguous, the code looks at the tree. If the tree isn't enough, it asks me.

Then the code runs its checks:

no cycles: nobody can become their own ancestor
no impossible dates
no conflicting parents
no guessing between people with the same name: it asks "Which Percy do you mean?"

Every fact keeps the sentence it came from. Finally the change appears in the tree as a dashed preview, and only my confirmation saves it.

The stack

Model: Gemma 4 E2B (gemma4:e2b-it-qat), running locally with Ollama
Backend: Python, FastAPI, SQLite (one file per tree, photos included)
Frontend: React, TypeScript, React Flow and dagre to draw the tree
Tests: 153. I also checked that the GEDCOM export and import work together: when I export the demo family and import it again, I get back the same tree.

E2B or E4B?

I tried both on my 15 test sentences:

Model	Gemma alone	With my code
Gemma 4 E2B	14/15	15/15
Gemma 4 E4B	12/15 (13/15 after one fix)

E4B was also 2.5 times slower. Fifteen sentences is a small test, so I don't read too much into it, but it was enough to stay with E2B.

The honest part: 6 secret sentences

I wrote those 15 sentences myself while I was building, so they're clean, and a score on them doesn't prove much.

So before writing the engine, I wrote 6 more sentences in everyday spoken Italian, about an invented family, and put them aside. When the code was finished, I froze it with a git tag (holdout-run) and ran the 6 sentences exactly once.

	Result
Gemma alone	1/6
With my code	5/6

Here is what Gemma did with spoken Italian:

It copied "Nonna Lucia" (Grandma Lucia) with the title, as if "Nonna" were part of her name.
It turned words that aren't names into people: "papà" (dad), "figlio di nonno Carlo" (Grandpa Carlo's son).
It missed relationships that were implied but never said.
It invented a marriage.

Sentence h06 went the other way. Gemma got it right and my code got it wrong: it merged two different Williams into one person. That was exactly the trap I had written into that sentence.

The 5/6 also needs a warning. It only measures whether the code made the right decision: save, ask, or refuse. In 3 of those 5 cases, it would have saved wrong names, like "Nonna Lucia". The only thing standing between those mistakes and the tree is the preview, where I see the dashed "new" people and can say no.

These are the real ghosts in my machine: a "papà" who isn't anyone, a wedding that never happened, two Williams who became one. The preview is how they stay out of the family.

I didn't fix anything before publishing. If I fixed the code until those 6 sentences passed, they would become test sentences like the others, and the number would stop meaning anything. So it stays 1/6 and 5/6.

What's next:

fix the two-Williams bug
remove kinship titles from names ("Nonna", "Zio")
when a "name" isn't really a name ("papà"), ask instead of creating a person
run E4B on the secret sentences

Why Does Open Innovation Matter?

For this project, it's the whole point.

It can't disappear on me. My last tree lived inside someone else's service and died with it. Tell the Tree keeps each family in a single file on my computer, exports to GEDCOM, and uses a model whose weights are on my own disk. If I stopped working on this app tomorrow, the tree would still be mine.

Family data is private data. Names, birth dates and photos of people who are still alive, and who never agreed to be on anyone's server. Here, none of it leaves the computer.

The model can't change under me. I tested one specific model, and because it runs locally, that's the model the app keeps using. With a closed API, the model behind the endpoint can be updated or retired, and my test results would quietly stop being true. A secret test that runs once only means something if the model stays the same.

Trying another model was easy. Comparing E2B with E4B meant pulling another model with Ollama and running the same tests.

It costs nothing to run.

The Spirit of It

Día de los Muertos is about remembering the people who came before us. A family tree is a quiet version of the same thing: a place where people who are gone still have a name, a date, a face.

The part of Tell the Tree I care about most is a small one: every fact keeps the sentence it came from. Not just a date in a box, but the words someone used when they told it.

My old website lost everything at once. This time, the people, the photos and the words all stay in a file on my own computer.

Prize Categories

Best Use of Gemma. Gemma 4 E2B runs locally through Ollama and reads every sentence. The app is designed around what a small local model is good at (copying words out of a sentence) and what I'd rather not trust it with (deciding what a relationship means), and I measured both, including where it fails.

Credits

Villa Diodati photo: Robertgrassi, public domain, via Wikimedia Commons
Fonts: Atkinson Hyperlegible and IM Fell English, SIL Open Font License
Gemma by Google DeepMind, run with Ollama; FastAPI, React Flow and dagre

The full story, mistakes included, is in my DEVLOG.

Thanks for reading. And if your family history also lives on a website you don't control, maybe export it today.

I let a local Gemma 4 name my screenshots (and it caught my fake password)

Carla — Sun, 25 Oct 2026 12:18:13 +0000

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

What I Built

Last week, for my Week 2 project, I took a lot of screenshots. Then I spent 10 to 15 minutes doing the most sloth-unfriendly job in the world: opening each Screenshot 2026-10-11 173802.png, figuring out what was in it, pressing F2 and typing a name like ghw-hypertable-show-chunks.png.

Lazy Screenshot Namer does that for me. It looks at every screenshot in a folder with a local Gemma 4 model, describes it, and suggests a short name that says what's inside. It also does one thing I would never bother to do by hand: it flags screenshots that seem to contain a password or a key, before they end up in a repo or a blog post.

Who gets to be lazier: anyone who documents their work with screenshots. Developers writing READMEs and bug reports, students taking notes, anyone with a Screenshots folder full of timestamps.

Demo

Before: eight screenshots with the names Windows gave them.

The dry run shows what Gemma 4 sees in each image and the name it suggests. Nothing is renamed yet:

After --apply:

How close did it get to the names I chose by hand last week?

Suggested by Gemma 4	My own name
sql-show-chunks.png	ghw-hypertable-show-chunks.png
sql-time-bucket-devices.png	ghw-hypertable-time-bucket.png
search-results-customer-orders.png	ghw-pgvector-ricerca.png
sql-note-execution-result.png	ghw-pgvector-tabella.png
teapot-inquiry-draft.png	demo-teapots.png
customer-service-vase-replacement.png	demo-damaged.png
customer-service-package-delay.png	demo-late.png
sensitive-config-db-connection-vars.png ⚠️	a fake `DB_PASSWORD`, made for the test

Not identical, but every name tells you what's inside, and it even read show_chunks and time_bucket straight from the SQL on screen. The one miss: it called my customer notes "customer orders".

Code

carla800 / lazy-screenshot-namer

Rename screenshots with a local Gemma 4 model that describes each image, and flag the ones that seem to contain secrets

Lazy Screenshot Namer

Turns Screenshot 2026-10-11 173802.png into sql-show-chunks.png. A local Gemma 4 model looks at each screenshot, describes it and suggests a name that says what's inside. It also flags screenshots that seem to contain a password or a key, before they end up in a repo or a blog post.

Everything runs on your laptop with Ollama: your screenshots never leave your machine.

Built for the Hacktoberfest 2026 Open-Source AI Challenge, Week 3: Slow and Steady.

Before and after

Windows name	Suggested by Gemma 4	My own name, chosen by hand
Screenshot 2026-10-11 173802.png	sql-show-chunks.png	ghw-hypertable-show-chunks.png
Screenshot 2026-10-11 174415.png	sql-time-bucket-devices.png	ghw-hypertable-time-bucket.png
Screenshot 2026-10-15 140512.png	search-results-customer-orders.png	ghw-pgvector-ricerca.png
Screenshot 2026-10-15 140748.png	sql-note-execution-result.png	ghw-pgvector-tabella.png
Screenshot 2026-10-18 223001.png	teapot-inquiry-draft.png	demo-teapots.png
Screenshot 2026-10-18 223612.png	customer-service-vase-replacement.png	demo-damaged.png
Screenshot 2026-10-18 223740.png	customer-service-package-delay.png	demo-late.png
Screenshot 2026-10-25 122211.png	sensitive-config-db-connection-vars.png	(a fake password, made for testing)

How it works

For each image in a folder:

Describe…

View on GitHub

How I Built It

It's a single Python script around Gemma 4 E2B (gemma4:e2b-it-qat, about 4 GB), Google's open-weight model, running locally with Ollama on a laptop without a GPU. Gemma 4 can read images, so for each screenshot:

Describe (with the image): one sentence about what the screenshot shows, plus a line sensitive: yes/no.
Name (text only, fast): turn that sentence into 2 to 5 hyphenated words.
Rename safely: dry run by default, --apply to rename, never overwrite a file, and log every change to a CSV so it can be undone.

Getting there took three wrong turns, and they taught me more than the final code:

The 13,706-character file name. My first version asked for a JSON answer. On most screenshots the model got stuck in a loop, repeating words inside the name (...show-chunks-table-data-preview-success-connected-status...) and never closing the JSON. Four minutes per image, zero usable names. Capping the output at 40 tokens fixed both problems at once: about 9 seconds per image.
The model copied my example. My prompt said "for example: sql-editor-query-results", and three different SQL screenshots all got exactly that name. Removing the example and asking for "the most specific thing you can read on screen" made them distinct.
Describe first, then name. On terminal screenshots, the model latched onto the command (python copilot.py) and ignored the actual content. Asking it to describe the screenshot first, then naming it in a separate call, took me from 2 useful names out of 7 to 7 out of 7. Splitting a task into two simpler steps really helps a small model.

I also learned not to trust the output blindly: the code keeps at most 5 words, strips anything that isn't a letter, a digit or a hyphen, and asks for the sensitive line before the name, so a truncated answer never loses the privacy flag.

As last week, I paired with an AI assistant to move fast, but the testing, the wrong turns and the fixes were all part of the fun.

Why Does Open Innovation Matter?

Screenshots are some of the most private files on a computer. In the last two weeks alone, mine included a database dashboard, query results and, at one point, a real connection string with a password. Sending them to a cloud API just to get a nicer file name would be a terrible trade.

Screenshots never leave the laptop. Gemma 4 runs locally with Ollama: no upload, no third-party AI provider seeing your screen.
It works offline and costs nothing. No API key, no per-image bill. You can point it at a folder of hundreds of screenshots and let it run, which is the whole point of being lazy.
A small open model runs on normal hardware. Gemma 4 E2B reads screenshots well enough on a laptop without a GPU.
I could fix what broke. The endless names, the copied example and the ignored content were all fixed by changing things I fully control: the output limit, the prompt and the number of steps. With a closed model I could still change the prompt, but not run it on my own machine for free.

The Lazy Payoff

By hand, last week: about 10 to 15 minutes for 7 screenshots (look, think of a name, F2, type).
With the namer: 8 screenshots in 25 seconds (from 12:26:49 to 12:27:14 in the rename log), plus about a minute to read the dry run.
The bonus I would never have done by hand: checking every screenshot for secrets. It flagged the fake password on the first try, with no false alarms on the other seven.

Prize Categories

Best Use of Gemma

I built a support copilot for one-person shops that runs Gemma 4 on a laptop

Carla — Sun, 18 Oct 2026 21:08:10 +0000

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

What I Built

Picture a one-person online shop selling handmade ceramics. The owner makes the mugs, photographs them, packs them... and every evening answers the same emails: "my mug arrived cracked", "my parcel is late", "can I get a refund?". She already knows the answers. She just has to write them again, consistently, every single time.

Little Kiln Support Copilot drafts those replies for her. You paste a customer message; it finds how you solved similar cases before and writes a draft that follows your own policies. You review it and send it.

Who would pay: solo makers and small shops on Etsy, Shopify or their own site, for whom support eats hours but a full helpdesk subscription is overkill. Because everything runs on open models on the owner's laptop, there is no per-message AI bill, so a flat few euros a month (or a one-time setup fee) would be a sustainable price.

Demo

Three real runs from the command line, for a sample shop called "Little Kiln Ceramics".

A broken vase. The customer asks for their money back; the copilot recognizes a damaged item and applies the shop's damaged-item policy: free replacement within 2 days, no need to return the broken piece, a photo of the damage.

A late parcel. It promises to check the tracking and offers the 10% discount code (SORRY10) the shop used in a similar case. Notice the "In the past, we have offered..." wording: a small model sometimes leaks internal phrasing, which is exactly why a human reviews every draft.

A question nobody asked before. No past case is similar enough, so instead of inventing an answer, the draft says the owner will check.

Code

carla800 / support-copilot

Draft customer-support replies for one-person shops with local open models (Gemma 4, EmbeddingGemma) and pgvector

Little Kiln Support Copilot

Draft replies to customer messages for one-person online shops, based on how you solved similar cases before. The AI runs on open models on your own laptop, so customer messages are never sent to a third-party AI API and every draft costs nothing to generate.

Built for the Hacktoberfest 2026 Open-Source AI Challenge, Week 2: Side Hustle.

The problem

If you sell handmade products online on your own, a big part of your evenings goes into answering the same questions again and again: a parcel arrived broken, a delivery is late, someone wants a refund. You already know the answers. You just have to write them again, every time, in a consistent way.

How it works

The sample shop is Little Kiln Ceramics, a fictional one-person shop selling handmade ceramics.

Your past cases (customer message + how you resolved it) are stored in Postgres…

View on GitHub

How I Built It

The copilot is a small retrieval-augmented generation (RAG) pipeline in Python, built around two open-weight Google models running locally with Ollama:

Past cases become vectors. Each past case (customer message + how it was resolved) is embedded with EmbeddingGemma (300M parameters, 768-dimensional vectors) and stored in Postgres with pgvector on the Tiger Cloud free plan.
Retrieve. A new message is embedded the same way, and a single SQL query ranks past cases by cosine similarity (<=>) and keeps only those above a threshold.
Generate. Gemma 4 E2B (the quantization-aware e2b-it-qat build, about 4 GB, runs on a laptop with no GPU) receives the message plus the retrieved cases, with instructions to use only those policies and never invent prices or deadlines.

Three things I learned while testing:

The first drafts applied the wrong policy. "My vase arrived broken, I want my money back" retrieved both the damaged-item case and a change-of-mind refund case, and Gemma sometimes picked the refund policy: returns accepted if unused, customer pays shipping. Not what you want to tell someone holding a broken vase! Two fixes made it correct and consistent: telling the model to apply the resolution of the most similar case, and lowering the temperature to 0.2.
A low similarity threshold invites invented answers. At 0.5, the teapot question pulled in unrelated cases and Gemma confidently said the shop had no teapots, something it could not know. Relevant cases scored above 0.63 and noise below 0.58, so I raised the threshold to 0.6: with nothing relevant to read, the model now honestly defers to the owner.
Retrieval alone isn't enough. Earlier this week I built only the search half: "I want my money back" could not find a note about defective shoes, because embeddings capture what a text is about, not what follows from it. Adding the generation step is what connects "broken" to "here's what we do about it".

This is my first hackathon. I work a lot with AI tools, so I paired with an AI assistant to move fast on the parts that were new to me: pgvector and local models.

Why Does Open Innovation Matter?

For a side hustle, the economics decide everything, and open models change them:

No per-message cost. Every draft is generated on the owner's laptop. A tiny shop answering 20 emails a day pays nothing per reply, so a cheap flat price is sustainable for both sides. With a paid API, the cost would grow with every customer.
Customer data stays out of third-party AI APIs. Names, orders and complaints are never sent to an AI provider. (The past cases live in a Postgres database I control, here on Tiger Cloud's free plan; for full privacy, the same code runs against a local Postgres with pgvector.)
Small enough for a normal laptop. Gemma 4 E2B runs without a GPU, which is the hardware a solo maker actually has.
Multilingual for free. EmbeddingGemma handles 100+ languages; earlier this week I tested the same setup with Italian notes. A shop answering customers in their own language doesn't need a different product.
I can swap and tune everything. Model, temperature, threshold and prompt are mine to change, and they were exactly the knobs that fixed the wrong-policy and invented-answer problems.

The trade-off is honest: a bigger closed model might write smoother prose. But for drafts that a human reviews anyway, a free, private, local model is the better deal.

Prize Categories

Best Use of Gemma
Best Use of Tiger Data