DEV Community: Jose Antonio Granero

Every rhyme rule I gave Gemma, it found a loophole. Catrina News turns today's tech headlines into Día de los Muertos calaveras

Jose Antonio Granero — Sat, 31 Oct 2026 16:09:51 +0000

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

What I Built

Catrina News is a daily broadside of calaveras literarias about the tech companies in today's news, written by an open-weight model on my laptop and read aloud by the Catrina.

A calavera literaria is a short satirical poem Mexicans write for Día de los Muertos, imagining Death coming to take someone away. Most people know them as playful verses for friends and family, but they were born as something sharper: in 19th-century Mexican newspapers they mocked politicians and the rich, and José Guadalupe Posada's skeletons, the Catrina among them, were drawn for those pages.

The broadside where the Catrina first appeared: José Guadalupe Posada, Mexico, 1913. Public domain.

So I went back to the origin. The powerful of 2026 are tech companies, and the news gives them plenty of material:

El iPhone Duo, un gran diseño,
prometía un lujo sin igual.
Mas la bisagra, con su empeño,
se quebró, ¡y al cliente un penal!

The iPhone Duo, a great design, / promised a luxury without equal. / But the hinge, with its insistence, / broke, and a penalty for the customer!

Every day it:

pulls the last 24 hours of tech news with SerpApi's Google News engine,
lets Gemma pick the ones worth satirizing (and drops anything about real people or tragedies),
writes a calavera for each, with every rhyme and syllable checked by plain Python, not by the model,
adds a line-by-line English gloss,
and has the Catrina read them aloud with ElevenLabs.

The result is printed as a Posada-style hoja volante (broadside), in English or Spanish, under a motto that borrows the shout of his headlines: ¡Gran Calavera Tecnológica!, after broadsides like his Gran Calavera Eléctrica (early 1900s).

Demo

🌐 catrinanews.tech: press Meet La Catrina to hear her introduce herself, or Listen to the broadside and she'll read every calavera.

The video opens with La Catrina herself introducing the project (an ElevenLabs avatar with the same voice that reads the calaveras), then the broadside reads itself: press "Listen to the broadside" and she recites every calavera while her skull's jaw follows her voice.

Code

finallyjay / catrinanews

Today's tech news as Día de los Muertos calaveras: a local open model writes them, code checks every rhyme, the Catrina reads them aloud.

Catrina News 💀🌼

Today's tech news, as Día de los Muertos calaveras. A local open-weight model writes satirical verses about the companies in today's headlines, plain Python checks every rhyme, and the Catrina reads them aloud.

👉 catrinanews.tech · Leer en español

Built for the Hacktoberfest Open-Source AI Challenge, Week 4: Ghost in the Machine.

What's a calavera?

A calavera literaria is a short, satirical poem Mexicans write for Día de los Muertos, imagining Death (la Flaca, la Catrina) coming to take someone away. They began as jokes at the expense of the powerful in 19th-century newspapers, where José Guadalupe Posada's skeletons, the Catrina among them, were born.

Most tools treat calaveras as sweet poems for loved ones. Catrina News goes back to the origin: the satire of the powerful. Today, that's tech companies.

How it works

SerpApi + RSS ──► editor (Gemma) ──► poet (Gemma)

…

View on GitHub

How I Built It

Headlines come from SerpApi's Google News engine: one request returns the last 24 hours of Spanish tech news as clean JSON, with the outlet's name and the article's real URL (the free Google News RSS only gives redirect links). Those links are what each calavera's "From …" points to.

Everything is Python's standard library talking to Gemma 3 12B through Ollama on a 2020 13-inch MacBook Pro (M1, 16 GB). No frameworks.

The model writes; code listens

A calavera has rules: four lines of about eight syllables, and lines 2 and 4 must rhyme in consonance (everything from the stressed vowel on sounds the same: capital / hospital). A 4B or 12B model can't reliably hear that. So the model never grades its own work.

rima.py does, in about 200 lines: Spanish stress rules, diphthongs and hiatus, the silent u in que, b and v sounding alike, synalepha between words, and the +1/−1 syllable rule for the last word of a line. When a stanza fails, the model gets feedback it can act on:

No rima: el verso 2 termina en "director" (suena "-or") y el verso 4 en "mansión" (suena "-on"); deben rimar en consonante. El verso 3 tiene 11 sílabas; déjalo en unas 8.

Each headline gets three candidates with up to three rounds of feedback, and code picks the best.

What the numbers said

I measured before building anything: 5 headlines × 2, up to 3 tries each.

	Rhyme 2-4	Rhyme 1-3 too	Lines of 7–9 syllables	Time per calavera
Gemma 3 4B, plain retries	9/10	7/10	18/40	~9 s
Gemma 3 4B + meter feedback + best-of-3	10/10	8/10	30/40	29 s
Gemma 3 12B + meter feedback + best-of-3	10/10	9/10	34/40	59 s

Feedback works; planning doesn't. Telling the 4B which sounds failed took it from 4/10 rhymes on the first try to 9/10. Asking it to choose its rhyming pair first sounded smarter and made it far worse: 2/10, with invented words like "sopio" and "lumpo" to force a fit.

Every rule I added, the model found the loophole

This was the ghost in my machine.

Panteón (graveyard) is the easiest rhyme in a calavera, and the 4B ended a line with it in 4 of its first 10. I banned it. It switched to millón.
I banned any word already used in the sheet. It kept the same sound with new words: razón, decepción, perfección, extinción, afición, lección… In one sheet, 12 of the 20 line endings were -ón words.
I banned rhyme sounds already used in the sheet. That finally worked, because a sound is something only the code can hear.
The editor picked the iPhone Duo twice. I asked for one headline per topic. It picked the iPhone Duo and "foldable phones". I gave it a fixed list of categories to choose from (a JSON-schema enum)… and it labelled all 11 headlines "apps and subscriptions". Describing each category with examples fixed it. Code still checks that no category repeats and that no two headlines share a product name.
It once picked a headline about deepfake abuse, despite the prompt forbidding violence. Now a regex in code drops those, whatever the model says.
The worst one: given a headline about alleged espionage, it picked it anyway (a named person and a spy story, both forbidden) and wrote "y al chino lo llevó al montón" ("and Death took the Chinese man to the pile"). Satire of a company had turned into a joke about a people. That sheet never went online. Now code drops headlines about spies, crimes or a named person's title ("CEO of…", "head of…"), and rejects any stanza that names a nationality or ethnicity, sending the model back with "la burla es para la empresa, nunca para un pueblo" (mock the company, never a people).

The pattern held all week: the model interprets, code verifies. Each rule improved a number, and the model found the next way around it. Form is code's job. Whether the joke lands is the model's, and that's where size shows: the 12B writes "te vende aire, ¡qué cruel plan!" (it sells you air, what a cruel plan!) where the 4B wrote "lo envió al millón, ¡qué arroz!" (it sent him to the million, what rice!).

The gloss doubles as a nonsense detector

Rhymes don't survive translation, so the Spanish is the original and Gemma writes a plain line-by-line English gloss. Unexpected bonus: filler that hides in Spanish verse is obvious in English. "Lo llevó al reino del brazo" reads fine in Spanish; in English it's "took him to the realm of the arm."

The Catrina's voice

voz.py calls ElevenLabs over plain REST, stitching each clip with the previous and next text so the sheet sounds like one reading. I picked the voice by measuring, not just by ear: of three voices reading the same calavera, Lucia paused at the end of every line (6 pauses, against 2 for the first voice I tried), so you can actually hear the rhyme land.

She also introduces herself

I first tried to animate Posada's original engraving with ElevenLabs' avatars: "No face detected in the image." Fair enough, it's a skull. So I generated a portrait of a woman dressed as La Catrina with Flux 3, in ElevenLabs' own image tools: white skull face paint, a wide feathered hat, sepia like an old print. The avatar, speaking with the same voice, opens the demo video and greets you on the site (click to play, with English and Spanish subtitles timed to the pauses in her voice). On the site itself, the skull in the masthead talks: the Web Audio API measures her voice as it plays and opens the jaw to match, no service involved.

Printed once, like a broadside

The site is static: HTML and MP3s, generated on my laptop and served by Render on a .tech domain. No model, no API key and no GPU online. It's how a hoja volante worked: printed at the shop, handed out on the street.

Why Does Open Innovation Matter?

Satire needs a model nobody else controls. These verses mock real companies. With an open-weight model on my own machine, no provider's content policy decides which companies can be laughed at, and no API bill grows with every headline.
Open weights let me measure. I could run the same prompts on the 4B and the 12B, change one rule at a time and compare, for free, as many times as I wanted. That's how I found every loophole above.
It won't disappear. The broadside is plain files. If any service I used shut down tomorrow, catrinanews.tech would still be there.

Prize Categories

Best Use of Gemma: Gemma 3 12B (and 4B for comparison) is the editor, the poet and the translator, running locally through Ollama.
Best Use of ElevenLabs: the Catrina reads every calavera (stitched clips, a voice chosen by measuring pauses at line ends), her skull's jaw moves with that voice on the site, and an ElevenLabs avatar of La Catrina narrates the demo in the same voice.
Best Use of a .tech Domain: live at catrinanews.tech.
Best Use of SerpApi: SerpApi's Google News engine finds the day's tech news the Catrina writes about, with the source and link shown on every calavera.
Best Use of Render: the broadside is served as a Render static site from a Blueprint (render.yaml).

Fridge Sloth 🦥: snap your fridge, get a grocery list and healthy meals, fully offline on Gemma

Jose Antonio Granero — Sat, 24 Oct 2026 13:38:31 +0000

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

What I Built

Fridge Sloth is for the moment you stand in front of the open fridge, door wide open, trying to remember what you need to buy and what on earth you could cook tonight.

Instead, you take one photo. Fridge Sloth:

Looks at the photo and lists the food it can actually see, with a rough "plenty / some / low" amount.
Checks it against your staples, the things you always want at home (milk, eggs, tomatoes…), and builds a grocery list of what's missing or running low.
Suggests three healthy meals you can make mostly from what's already there: real dishes like omelettes, salads, stir-fries and wraps, 30 minutes or less, 5 steps max. Anything a recipe still needs goes onto your grocery list with one tap.

Who gets to be lazier? Anyone who does the weekly shop and then stares at a half-full fridge wondering what's for dinner. You skip the mental inventory, the list-writing and the "what can I even make with this?" moment.

Everything runs locally on Gemma 3 (4B) through Ollama, on my 6-year-old M1 MacBook. No account, no API key, and your fridge photo never leaves your machine.

Demo

The video is a real run of the app on my laptop with a public-domain USDA fridge photo (source). The two waits are sped up and labelled with their real time: ~37 s for the scan and ~26 s for the recipes. I recorded it before the speed-up described below; the same scan now takes ~20 s. The voice-over was generated with ElevenLabs.

Gemma saw: milk, yogurt, juice, eggs, lettuce, cheddar cheese, bread, pesto…
Grocery list: butter, tomatoes, carrots, apples, orange juice, plus spinach and feta, which I'd just added to my staples. None of them are in the photo ✅
Healthy meals: a pineapple & lettuce omelette (20 min), a cheesy lettuce wrap (15 min) and a quick yogurt bowl (10 min). One tap put the omelette's olive oil on the list.

Code

finallyjay / fridge-sloth

🦥 Snap your fridge, get a grocery list and healthy meals — runs fully offline on Gemma 3 + Ollama.

Fridge Sloth 🦥

Snap a photo of your fridge, get a grocery list and three healthy meals you can cook with what's already there Runs fully offline on Gemma 3 through Ollama. Your fridge photo never leaves your machine.

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

How it works

┌──────────────┐   1. vision (no hints)   ┌──────────────────────┐
│ fridge photo │ ───────────────────────> │ items actually seen  │
└──────────────┘        Gemma 3           │ + amount left        │
                                          └──────────┬───────────┘
┌──────────────┐   2. match by name                  │
│ your staples │ ────────────────────────────────────┤
└──────────────┘     plain code, ~1 ms               │
                                          ┌──────────▼───────────┐
                                          │ grocery list         │
                                          │ (missing / low)      │
                                          └──────────┬───────────┘
                     3. healthy recipes              │
                          Gemma 3         ┌──────────▼───────────┐
                                          │ 3 meals, ≤ 30 min    │
                                          └──────────────────────┘

Vision: Gemma lists the food it can actually see in the photo, with a rough amount (plenty, some, low) It is not…

View on GitHub

It's deliberately tiny: a Python server that uses only the standard library (http.server + urllib), an optional tracing module, and one HTML page with vanilla JS. The only thing you install is Ollama:

brew install ollama && ollama pull gemma3:4b
python3 server.py   # open http://localhost:8000

There are 35 tests, and Gemma is mocked in them, so they run in CI without a model.

How I Built It

Stack: Gemma 3 4B (vision) on Ollama, a zero-dependency Python server, and a single HTML page. The page shrinks phone photos to 1024 px in the browser before sending them, which is plenty for Gemma and much faster.

Structured output everywhere. Every call to Gemma passes a JSON schema in Ollama's format field, so the server always gets back data it can use ({"seen": [{"item": "eggs", "amount": "plenty"}]}), never prose to parse.

The bug that taught me the most: Gemma "saw" whatever I told it to look for

My first version sent the photo together with the staples list and asked "which of these are in the fridge?". On the USDA photo, Gemma confidently reported butter, tomatoes and apples as "low". None of them are in the picture. Handing a small vision model a checklist primes it to find the items on it.

The fix was to split the work:

Vision step, no hints: "List every food you can actually see. Never guess hidden items." The staples list is not in this prompt at all.
Matching step: your staples are compared with the items Gemma actually listed.

That one change removed the invented items. At first, step 2 was a second, text-only Gemma call. It's now plain code, and the Sentry traces below are why.

The same rule, never trust the model's claim, check it, came back for the recipes. In one run a recipe listed a banana "from your fridge" when there was none. Now any recipe ingredient that wasn't actually seen is moved to the grocery list.

Asking a small model for less

I first asked Gemma to also classify each item (ingredient, drink, condiment…). The 4B model was bad at it ("eggs: condiment"), and those wrong labels starved the recipe step of ingredients. Removing the field worked much better.
"Healthy" needs to be spelled out. The first recipes included a "smoothie & cheese toast". The prompt now says what a healthy meal is (a real dish built on vegetables, whole grains, legumes, eggs, fish or lean protein; easy on butter, cream and salty sauces; never a drink presented as a meal) and that each meal must use at least two foods actually in the fridge.
Matching staples doesn't need a model at all (see below).

Watching the agent with Sentry Agent Tracing

A scan took about a minute, and I wanted to know where that minute went. Fridge Sloth has optional Sentry Agent Tracing, off unless you set SENTRY_DSN:

Each scan or recipe request is an invoke_agent trace with a gen_ai.chat span per Gemma call, carrying the model, token counts and Ollama's own timings (model load, prompt processing, generation).
Every check the server runs on Gemma's output is a gen_ai.execute_tool span: dedupe_seen_items, match_staples_by_name and check_recipe_ingredients. In Sentry's Agent Activity view, the "never trust the model" checks show up right next to the model calls, with what they caught.

1. The traces exposed a real bug. On a messy example photo, two scans failed after about 4½ minutes. The trace showed why: a single vision call ran for 4.46 minutes, and the next step never started. The 4B model was stuck in a loop, listing the same items until its JSON answer was cut off at about 10,000 characters.

The fix: the schema now allows at most 30 items, which Ollama enforces while generating; every answer is capped in length; and a cut-off answer fails fast with a clear message. The same photo then scanned in 1.15 minutes, and that trace showed the next problem.

2. The traces showed where to optimize. The matching step, Gemma comparing two short lists of words, took ~25 s, a third of every scan. I first tried asking Gemma only about the staples plain code couldn't place ("is any of these here under another name?"). It was faster but wrong: the 4B model over-claimed, deciding the spinach was the cheddar cheese. So matching is now plain code, with a strict rule: an item counts as a staple only if it ends with it. "Cheddar cheese" is cheese and "free-range eggs" are eggs, but "tomato sauce" is not tomatoes and "milk chocolate" is not milk. Missing a synonym ("OJ") only means buying something you already have; a false match means not buying something you need.

The result, on the same photos and staples:

Photo	Before	After
USDA (clear)	51.6 s	19.9 s
Door shelves	52.9 s	20.7 s
Messy	68.8 s	43.6 s

A scan is now one Gemma call plus two checks that take about a millisecond each:

3. Generation is what takes the time. A recipe request is about 800 tokens; nearly all of its ~30 s is Gemma generating the answer, with model loading and prompt reading taking a few seconds. Shorter answers, not a faster prompt, are what would speed it up next.

4. Checking my own setup. The looping scans' errors never showed up as Sentry issues, even though their traces did. Sentry's usage stats explained why: the error events had been rejected as too large. By default, Sentry's Python SDK attaches each stack frame's local variables to error events, and here those held the prompt, Gemma's answer and the base64 photo, several times over. So errors from real scans were silently dropped, and smaller ones would have sent exactly the data I promised never to send. One setting (include_local_variables=False) fixed both, and I checked it end to end: the same error with a real photo now arrives in Sentry at 11 KB, with no prompt, answer or photo in it.

Privacy is kept, in traces and error reports alike. Only metadata is sent: timings, token counts and how many items each check looked at. The photo, the prompts, Gemma's answers and even the food names never leave the machine, and the tests check exactly that for both.

Gemma 3 4B vs 12B

I also tried the 3× bigger model on the same photos, on the same laptop (before the matching speed-up):

	4B	12B
Scan, clear photo	~45 s	~44 s
Scan, messy photo	~49 s	~109 s
Recipes	~30 s	~95 s
Messy photo	missed the milk, called beer "juice"	saw beer, salsa and bread, but still missed the milk and eggs
Recipes	decent	not better (a cream bread pudding)

12B reads messy photos a little better, but it's about 3× slower on recipes and the recipes weren't better. I kept 4B. Switching is one environment variable (FRIDGE_MODEL=gemma3:12b) if your machine is faster than mine.

Honest limitations

It works well on clear, well-lit photos. On messy, dim ones the 4B model still misreads things: it called a pack of beer "juice bottles", and in the demo photo it reads pineapple slices as banana (hence the yogurt & banana bowl).
It only knows what's in the photo. Something hidden behind the milk shows up as missing.
Staples are matched by name, so a synonym like "OJ" won't count as orange juice.
Recipes are suggestions, not nutritional advice.

Why Does Open Innovation Matter?

A photo of the inside of your fridge is personal. It shows what you eat, drink and can afford. With an open-weight model running locally, it never leaves your laptop. Even the tracing sends only timings and counts.
It runs on hardware people already own. Gemma 3 4B handles both the vision and the recipes on a 6-year-old M1 laptop. No GPU server, no subscription, no per-request cost, so it can stay free.
I can see and change everything. I could swap models with one environment variable, constrain the output with a JSON schema that the runtime enforces token by token, cap the answer length, and design the pipeline around the model's real weaknesses. With a closed API I'd be guessing; here I could measure the problem and fix it.
It works offline, including in a kitchen with bad Wi-Fi.

Prize Categories

Best Use of Gemma: Gemma 3 4B does the AI work, reading the photo and writing the healthy recipes, entirely locally through Ollama.
Best Use of Sentry Agent Tracing: every model call and every check on its output is traced (Agent Activity screenshots above). The traces exposed a real bug and showed where the time went, which led to scans 2.6× faster on clear photos. Following up on errors missing from Sentry's stats also uncovered a privacy problem in my own error reporting, now fixed.
Best Use of ElevenLabs: the demo's voice-over was generated with ElevenLabs text-to-speech (eleven_v4), one line per moment in the video, stitched so it sounds like one take. The script is scripts/narrate_demo.py.

Example photos are from Wikimedia Commons: USDA (public domain) and others under CC BY-SA. Full credits are in the repo.