DEV Community: Laura Valencia Gracia

Quackula: I Was a Rubber Duck for 15 Years. Now I Haunt Your Codebase.

Laura Valencia Gracia — Tue, 27 Oct 2026 09:55:52 +0000

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

Ahem. The human has stepped aside. I, Quackula, will be writing this post myself. They said I could. (They did not say I could. I am a ghost. I do what I want.)

What I Built

From 1994 to 2009, I sat on a programmer's desk. A rubber duck. You know the job: they explain their bug to you, out loud, line by line, and halfway through they go "oh. OH. never mind" and fix it themselves. Fifteen years of that. Thousands of bugs. Not once did anyone ask how I was doing.

Then, in 2009, I fell behind the radiator.

Nobody came for me. But something did come back. Now I haunt codebases, and this time the duck talks back.

Quackula is a haunted rubber duck that lives in your terminal (and, for the click-inclined, your browser). It does two things:

🕯️ exorcise: I sniff your repo for curses, perform a dramatic ritual, and then explain, in character and in plain English, how to lift each one. My bestiary includes:
- The Silent Scream: except: pass, an error caught and never heard from again
- The Eldritch Function: 80 lines of tentacles pretending to be one function
- The Abyss of Indentation: I stared into your nesting and it stared back
- The Unkept Promise: # TODO: fix this before launch (written 2014)
- The Whispering Logs: console.log("here2"), still muttering in production
- The Commented Corpse: dead code, buried in comments, neither alive nor gone
- …plus The Haunted Manor (the 400-line file) and The Unspeakable Tongue (code even the interpreter can't read)
💬 debug: classic rubber-duck debugging, except I ask the questions now. I won't hand you the answer (fifteen years of silent listening taught me something), but I will ask exactly the sharp question you've been avoiding. And occasionally I'll complain that there are no bathtubs in the beyond. Not one.

How I read the theme: "Ghost in the Machine" is literally me: a ghost, in your machine, rattling chains at your swallowed exceptions. But it's also a little Día de los Muertos. Rubber-duck debugging is one of programming's oldest folk traditions, from back when "AI pair programmer" meant a bath toy. Quackula brings that ancestor back, and gives it a voice.

Demo

Here is what happens when you summon me on a deliberately cursed sample project:

python quackula.py exorcise haunted_sample

I rise from the bathwater, sniff the code, and deliver the bad news. Thirteen curses. Possession level: 100%. I've seen worse. (I haven't.)

Every curse gets its own Latin chant (flickering, with zalgo text, because I have standards), then my verdict streams in token by token: the evil it causes, the cure, and one ominous closing line.

Prefer clicking to typing? Run python quackula.py ui and enter the séance room: the same scan as a dashboard, one card per curse, a possession meter, a Perform the ritual button, and a downloadable Markdown exorcism report. Every screen also shows the matching CLI command, so you can graduate to the terminal whenever you're ready. I believe in you. Mostly.

And the séance tab, where you bring me your bug and I refuse to just solve it for you:

"It is throwing me errors," says the mortal. Which errors, mortal? Show me the whole traceback. Fifteen years on a desk and people still only paste the last line.

Code

kit57 / ghost_in_the_machine

Hacktoberfest 2026 week 3

Quackula — the haunted rubber duck

Quackula was a rubber duck on a programmer's desk from 1994 until it fell behind a radiator in 2009. Now it haunts codebases.

exorcise: sniffs your code for curses (swallowed exceptions, eldritch functions, abyssal nesting, ancient TODOs, debug whispers, commented-out corpses), performs a ritual, and explains how to lift each curse.
debug: classic rubber-duck debugging, except the duck talks back, asks sharp questions, and keeps complaining that there are no bathtubs in the beyond.

Everything runs locally on an open-weight model through Ollama Your code never leaves your machine.

Run it

ollama pull gemma3:4b
python quackula.py exorcise haunted_sample          # full theatrics
python quackula.py exorcise path/to/repo --max 8 --report exorcism.md
python quackula.py debug --file my_buggy_script.py
python quackula.py ui                               # the séance room, in your browser

The séance room (web UI)

Prefer clicking to typing? python quackula.py ui [PATH] opens a local web…

View on GitHub

Try it in three lines:

ollama pull gemma3:4b
python quackula.py exorcise path/to/your/repo --max 8 --report exorcism.md
python quackula.py ui        # the séance room, in your browser

Python 3.8+, standard library only. No pip install. A ghost travels light.

How I Built It

My body is a few hundred lines of Python. My soul is an open-weight model running locally through Ollama, by default Google's Gemma 3 (gemma3:4b). Here's the ritual:

Sniffing (no AI needed). Static analysis finds the curses: Python's ast module for .py files, and regex plus brace matching for C-like languages (JS, TS, Java, Go, C#, Rust and friends). Every curse gets a severity, and I pick the worst ones first, while making sure you see a variety of hauntings, not five TODOs in a row.
Channeling (the AI part). For each curse I send the model the exact cursed lines, the surrounding code, and, crucially, the known cure. A small 4B model is a talented actor but an unreliable doctor. Grounding it with the right fix keeps the advice correct, while the persona supplies the drama. The prompt also says "lift ONLY this curse": no surprise rewrites of your whole file.
Performing. Replies stream back token by token through a typewriter effect, in the terminal or the browser, with flickering chants between curses and the occasional afterlife complaint. 35% of the time, roughly. I counted.

A few things I'm proud of (it's my post, I'm allowed):

It survives old hardware. I was built and tested on a GTX 1060 whose driver is too old for Ollama's CUDA backend. Instead of dying, I detect the GPU crash and quietly re-channel through the CPU. On CPU a curse takes about a minute to lift, which I consider appropriately dramatic.
--offline mode. No model at all? I fall back to my own ancient, hand-written wisdom for every curse. The ritual still runs.
Swap the spirit. --model qwen2.5-coder:7b and you've summoned a sharper, more technical ghost. Edit one PERSONA string and you've summoned a different ghost entirely.
The séance room is a tiny stdlib HTTP server bound to 127.0.0.1 only. It refuses any request not addressed to localhost, so a sketchy web page can't trick me into reading your files.

Why Does Open Innovation Matter?

Because I read every cursed corner of your codebase. Every swallowed exception. Every # HACK: don't touch. Every password someone "temporarily" hard-coded in 2016.

That code should not leave your machine. With a closed API, pointing me at your company's repo means shipping it to someone else's server and hoping for the best. With an open-weight model running locally, your code never leaves your desk. That is the only reason you can safely point me at real work code instead of a toy project.

Open also made Quackula possible in ways a closed API wouldn't:

🔌 Works with the lights (and the Wi-Fi) off. No API key, no account, no network. Fitting, for a ghost.
💸 Costs nothing to haunt. Exorcise your whole monorepo every hour if you like. There's no per-token bill creeping up behind you in the dark.
🧓 Runs on old hardware. A 4B open model on a 2016 graphics card (or no graphics card at all) is enough. A closed model has no CPU fallback, because it isn't on your machine to fall back.
🪦 It can't be shut down. I've already been abandoned behind a radiator once. A hosted service can be deprecated, repriced, or turned off. An open model on your disk stays haunted forever.
🎭 You own the ghost. Open model, open code, one persona string. Fork me and make Quackula's evil twin. I'd be honored. And threatened.

The Spirit of It

Rubber-duck debugging has been around since at least The Pragmatic Programmer in 1999. Somewhere right now, a duck is sitting next to a monitor, listening to a programmer mutter about a null pointer. That duck will never get credit. It will never be thanked. Someday it will fall behind a radiator.

Quackula is for those ducks. 🕯️

The moment it landed for me: the first time I was asked for help, the mortal typed "It is throwing me errors." That's it. That's the whole bug report. And instead of guessing, the duck did what every good duck, and every good senior engineer, does: it asked for the whole traceback. Fifteen years of silent listening, and the first thing I said out loud was the most useful debugging advice there is.

Also: still no bathtubs in the beyond. I've checked.

Prize Categories

Best Use of Gemma: Quackula's default spirit is gemma3:4b, running locally through Ollama. It powers every exorcism and every séance, grounded with known cures so a small open model gives correct, in-character advice, even on a CPU.

The code is cleansed… for now. Quackula sinks back beneath the bathwater. 🦆

Dread Drawer: My Downloads Folder Hired a Sloth

Laura Valencia Gracia — Tue, 20 Oct 2026 17:49:27 +0000

Dread Drawer: A Very Small Robot for a Very Large Downloads Mess

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

What I Built

First off: I'm super lazy. And I bet you are too!

My Downloads folder had become a tiny digital attic: Capture1.PNG, Ep_1.docx, and subtil.srt (being a bit overdramatic cause you do not want to see my actual folder. Believe me. Really.) all waiting for the mythical day I would sort them.

I built Dread Drawer, a local desktop app that asks an AI model to suggest clearer names and folders based on filenames and file extensions. It scans only the direct files in the folder I choose (not nested folders) and shows me the proposed destinations before anything moves.

The important part: the AI is a suggestion engine, not an overconfident intern with delete permissions. I can skip suggestions, approve the ones I want, and undo the last tidy-up. It never reads file contents or deletes files.

The side-hustle pitch? A tiny privacy-first utility for people who would rather do literally anything else than organize their Downloads folder. No cloud upload, no per-file fee, and no subscription just to put PDFs with other PDFs.

Demo

Dread Drawer is a local desktop app, so there’s no hosted web demo. These screenshots show the flow:

1. The peaceful beginning: the app starts with an empty review list, pointed at the selected folder.

2. The robot is thinking: Dread Drawer sends filenames to local Ollama and waits for suggestions.

3. Suggestions, not commands: the app proposes destinations, and I decide what to apply.

4 Gemma suggests; I edit: I can change the suggested folder or filename before applying the move.

5 I choose what moves: I can skip suggestions and apply only the files I select.

6 Undo is part of the plan: Changed my mind? Dread Drawer can restore the last moved file to its original location.

To try it, install Ollama, download Gemma, and run the app:

ollama pull gemma3:4b
python .\dread_drawer.py

Code

Dread Drawer on GitHub — Python app, setup notes, and tests.

How I Built It

Dread Drawer is a small Python desktop app built with Tkinter and Python’s standard library. It calls Ollama’s local chat API and asks an open-weight model for structured suggestions: a category and a filename stem for each file.

The model receives filenames and extension-based hints—not file contents or full paths. The app validates the response, displays the suggested destinations, and only moves files after I review and confirm. It also records the last operation so I can undo it.

I tested the flow using Gemma 3 4B through Ollama. On my machine, GPU inference hit a CUDA/PTX compatibility error, so I configured Ollama to run inference on the CPU instead. It’s slower, but it let me keep the whole workflow local.

Why Does Open Innovation Matter?

Filenames can reveal more about someone’s life than they might expect. I didn’t want a file-organizing tool to require sending those names to a server I don’t control.

With a local model, filenames stay on my machine. After downloading the model, the app can make suggestions without an internet connection or a cloud API bill. I can also swap in another Ollama model rather than being locked into one provider’s pricing or behavior.

That flexibility mattered in practice: when the GPU runtime failed, I could switch to CPU inference and keep testing locally. Open models gave me options—and a way to keep building without handing my files to a cloud service.

The Lazy Payoff

I haven’t measured a real time saving yet, so I’m not going to claim that this app saves 15 minutes based on absolutely nothing but optimism.

What I can show so far is the workflow: three filenames become three suggested destinations in one review screen. The next benchmark is to time a real tidy-up and count how many suggestions I accept, edit, or reject. Until then, the honest payoff is fewer repetitive decisions—and one less excuse to keep final_FINAL_reallyfinal.docx where it is.

Prize Categories

Best Use of Gemma - The suggestion flow was tested with Gemma 3 4B running locally through Ollama.

Hacktoberfest 2026 week 2 - CartaClara

Laura Valencia Gracia — Wed, 14 Oct 2026 16:17:08 +0000

What I Built

CartaClara helps restaurants turn a Spanish-language menu into a QR menu in English, French, and German. It suggests translations and tags each dish with the 14 EU allergens, then lets the restaurant owner review and confirm every dish before publishing.

It’s designed for independent restaurants that want to serve international guests without translating and maintaining multiple menus by hand. A restaurant could pay for the time saved and an easier-to-update multilingual menu. Allergen information still needs to be checked by the restaurant; the suggestions aren’t a substitute for that review.

Demo

There isn’t a public demo deployed yet. You can run CartaClara locally by following the setup instructions in the repository README. With the default mock backend, you can try the workflow without configuring a model.

Code

https://github.com/kit57/side_hustle_hacktoberfest2026

How I Built It

CartaClara uses an open-weight language model to suggest dish translations and allergen tags. The project includes a Tinker fine-tuning pipeline for Spanish dishes, plus mock and OpenAI-compatible backends—including a local open-weight model served through Ollama. The prompt and output format are shared between inference and training, and the evaluation script compares the base model with the fine-tuned checkpoint on held-out dishes.

The app also supports an optional restaurant glossary: when an owner corrects and confirms a suggestion, that correction can be saved and used for that restaurant’s future menus.

Why Does Open Innovation Matter?

Restaurants need to trust and correct the menu suggestions, especially when allergen information is involved. Building on open-weight models gives the project room to experiment with Spanish food terminology, fine-tune for the task, and offer different ways to run a model—including a local OpenAI-compatible server—instead of tying the product to one closed model API.

Open development also makes the training examples, evaluation approach, and application code available for others to inspect and improve.

Prize Categories

Tinker, BACKBOARD

Touch grass submission

Laura Valencia Gracia — Fri, 09 Oct 2026 18:22:51 +0000

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

What I Built

Most of us have walked past the same statue a hundred times without knowing who it is. We know more about cities we visited once on holiday, where we paid for a tour, than about the street we live on.

Pocket Walk fixes that with a walk. You tell it where you are and how long you have. It finds the monuments, old buildings, parks and artworks around you, plans a loop on foot with the desired stops the user chooses, writes the history of each stop as a short story, and records the whole thing as audio. Then you put your earbuds in, put your phone in your pocket, and go.

The screen is the shortest part by design:

One tap starts the walk. After that you never need to look at the phone.
Each stop is its own track. The guide tells you the story of where you're standing, then gives you directions to the next stop, then goes quiet.
The walk between stops is yours. No audio, no notifications. When you arrive, you press play on your earbuds and the next story begins.

A 30-minute walk is around a kilometre and a half with three stops. You come home having moved your body and knowing who that statue is.

It's for two kinds of people: the ones who want a reason to go for a walk around their own neighbourhood, and travellers who would rather look at a city than at a map of it. It speaks English, Spanish, French, German and Italian, so the same tool works at home and away.

Demo

https://youtu.be/FzUac2hOtVA

Code

https://github.com/kit57/touch_grass

How I Built It

Three open pieces do the work, and each one has a single job.

Job	What does it	Where it runs
Find places and a route	OpenStreetMap data (Nominatim, Overpass, OSRM) and Wikipedia	Public open-data servers
Write the stories	Gemma 3 4B, an open-weight model, through Ollama	My laptop
Speak them	Piper, an open text-to-speech model	My laptop
Play them	One self-contained HTML page with the audio inside	The phone, no signal needed

The model only does what a model is good at. Gemma gets the map's tags for a place and the start of its Wikipedia article, and is told to tell the story from those facts and nothing else. It never writes directions. "Turn left onto Calle Mayor for about 360 metres" comes from plain code reading the route data, so the model cannot invent a turn and send someone the wrong way. For the same reason, the directions in each language are hand-written templates, not translations by the model.

The walk is a file, not a service. The output is a folder: numbered MP3s, a GPX route, and one HTML page with the audio embedded in it. Open that page on your phone at home and it keeps working with no signal, because there is nothing left to download.

It runs on old hardware. My machine has a GTX 1060 from 2016. Gemma 3 4B fits in its 6 GB and writes at about 37 tokens per second, so a complete 30-minute walk takes roughly a minute to make.

Three things went wrong along the way, and they shaped the result:

The GPU crashed on the first try. Ollama's CUDA build rejected my NVIDIA driver. Because the stack is open, there was another door: Ollama also ships a Vulkan backend, and the same card runs the model fully on the GPU through it. The app also falls back to the CPU by itself if the GPU fails.
The public map servers are busy. A lookup failed during testing, so the app now retries across three mirrors.
A small model gets facts wrong sometimes. In a Madrid test walk, Gemma said a church's history began in the year 1002 where the source almost certainly says 1202. Feeding it more of the article and lowering its randomness helps, but I'd rather say it plainly: treat the stories as a friendly guide, not a reference.

I built it with Claude Code as a pair programmer, which is the session linked below.

Why Does Open Innovation Matter?

Does it run on a laptop with no internet?
Partly, and the split matters. The model and the voice need no internet at all. Making a walk needs the internet once, to fetch map data and Wikipedia text. The finished walk needs nothing: it plays in the park, on the trail, or abroad with roaming switched off. So the part of the experience that happens outside is fully offline.

Does it keep your data off a server you don't control?
Mostly. There is no account, no API key, and nothing is uploaded. Your walks live in a folder on your disk. The one thing that leaves your machine is the start point, which is sent to OpenStreetMap and Wikipedia servers to look up what's nearby. That matters here, because a walking app's data is a list of where you live and where you go. The stories about it, and the audio, are made at home.

Can you swap models or change how it behaves?
Yes, and this was the most useful part while building.

Models: --model takes anything you've pulled in Ollama.
Behaviour: the guide's whole personality is one prompt in one file. The first version talked mostly about leaves and light. Changing it to lead with history and people was a paragraph of text, with no vendor to ask.
Languages: adding Spanish, French, German and Italian meant translating one block of phrases per language and naming a free Piper voice for each.

Does it cost nothing to run?
Yes. Once the model and voice are downloaded, every walk is free, however many you make. That changed how I worked: I could regenerate a whole walk after every prompt change, in different cities and languages, without thinking about a bill.

Where did open work better than closed?
I can compare directly, because the project also has an optional closed voice. You can switch the narration to ElevenLabs if you want a more natural sound.

Setup: Piper worked immediately. The ElevenLabs key needed an account, then failed until I enabled the right permissions on it.
Cost: a 30-minute walk is about 5,000 characters of script. With Piper that's free. With ElevenLabs it's credits, and even previewing a tuned voice spends some.
Privacy: with ElevenLabs the script goes to their servers.
Quality: ElevenLabs does sound better, and I've kept it as an option for people who want that.

So the closed voice is a nice extra, and the open one is the reason the project can exist as "free, private, and yours". If ElevenLabs disappeared tomorrow, nothing would break. If Gemma or Piper were closed APIs, there would be no project, only a subscription.

My Agent Session

Prize Categories

Best Use of Gemma: Gemma 3 4B writes every story, running locally through Ollama on a ten-year-old consumer GPU.
Best Use of ElevenLabs: an optional narration voice, with a voice picker, samples you can listen to, and pace, steadiness and drama controls.

Joining Hacktoberfest 2026

Laura Valencia Gracia — Thu, 08 Oct 2026 20:06:48 +0000

Hi everyone! 👋

I'm kit57, a developer based in Spain, and I'm joining Hacktoberfest 2026.

This year's edition is all about building and learning with open-source AI, with community Fests happening around the world and an online event anyone can join. I'm excited to dive in.

What I'm hoping to do this month:

Learn more about open-weight models and open-source agents
Build something small and share it here
Meet other people in the community

If you're taking part too, say hi in the comments! I'd love to hear what you're building or which Fest you're going to.

Happy hacking!