Listing Writer

Vaibhav Agrawal — Sat, 17 Oct 2026 17:41:06 +0000

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

What I Built

Listing Writer is a local-first, AI-powered listing generator for Etsy and eBay sellers.

Imagine a vintage reseller or a handmade crafter with 20 items to photograph and list over the weekend. They don't have a copywriter. They use a generic cloud AI tool, but it forces them to upload photos of unreleased inventory to a server they don't control. Worse, generic AI often hallucinates details—confidently writing "approximately 8 inches wide" for an item it cannot actually measure.

Listing Writer solves this by running entirely on the seller's laptop. It uses an open-weight vision model to read the photo, generate a title, description, tags, and price range, and streams the result instantly.

But its most important feature is honesty: if the model cannot see the size, material, or quantity in the photo, it writes [seller to confirm] instead of guessing. The seller gets a perfect starting point without being fed AI hallucinations.

Demo

(Note: Because I am running Gemma 3 locally on my CPU, text generation takes about 90 seconds. The video is trimmed to show the setup, the offline proof, and the final result.)

https://www.youtube.com/watch?v=gXQ9E0Teu8s

Code

competitive-programmer04 (Vaibhav Agrawal) · GitHub

competitive-programmer04 has 27 repositories available. Follow their code on GitHub.

github.com

How I Built It

The stack is incredibly lightweight: Python, Streamlit, and Ollama.

I used Gemma 3 (4B), an open-weight vision model, served locally via Ollama. The Streamlit frontend communicates with the local Ollama server via localhost:11434.

When the user clicks "Generate," the app reads the image bytes, packages them with a carefully engineered prompt (which includes the selected "voice"), and sends them to Ollama. The app uses ollama.chat(..., stream=True) so the text renders progressively on the screen rather than making the user stare at a blank loading screen.

Because I built this for real people, I also focused heavily on error handling. Here is what happens when the user doesn't have Ollama running, and what the one-time ~3.3GB model download looks like:

Why Does Open Innovation Matter?

For this specific use case, closed APIs are a dealbreaker.

Privacy & Unreleased Inventory: Sellers often list handmade items or vintage finds they haven't publicly announced yet. Uploading those photos to a third-party API (like OpenAI or Anthropic) means that data is on a server they don't control. With local open weights, the photo never leaves the laptop.
Zero Marginal Cost: A seller listing 200 items a month would be billed for 200 vision API calls. With an open model running locally, the cost of generating 1 or 1,000 listings is exactly $0. The only cost is the electricity to run the laptop.
True Offline Capability: Sellers source inventory at flea markets, warehouses, and craft fairs—places with terrible WiFi. A closed API fails completely without internet. My tool works completely offline after the initial one-time model download.
No Lock-in: If Gemma 3 isn't good enough for a specific niche, I can swap the model="gemma3:4b" string to llama3.2-vision in a single line of code. I am not locked into one provider's pricing changes or deprecations.

Touch Grass Birder: On-Device Bird ID in the Browser with Open-Weight AI

Vaibhav Agrawal — Sat, 10 Oct 2026 15:54:50 +0000

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

What I Built

Touch Grass Birder is an offline, on-device bird call identifier that runs entirely in your browser. Record 6 seconds of a bird call, get a species ID in seconds, then put your phone away and go find the bird.

It identifies 6,522 species using the BirdNET v2.4 open model, running locally on your device via ONNX Runtime WebAssembly. There is no server, no API key, and no internet required after the first load.

It's for anyone who's ever heard a bird on a trail, pulled out their phone, and realized their bird ID app doesn't work — because it needs a server round trip, and there's no signal where the birds actually are.

The whole design is built around minimizing screen time. The user taps "Record 6 seconds," sees the result, and is told to pocket their phone and go find the bird. The screen is the shortest part of the experience.

Demo

Live app: https://hacktoberfest-week1-challenge.vercel.app/

Repo: https://github.com/competitive-programmer04/_hacktoberfest_week1_challenge

With network — first-time setup:

Airplane mode. No network. Still identifying birds.

Code

Repo: https://github.com/competitive-programmer04/_hacktoberfest_week1_challenge

Key files:

frontend/src/audio.js — resampling and 3-second chunking with 1.5s overlap

frontend/src/inference-worker.js — ONNX Runtime WebAssembly session, sigmoid post-processing

frontend/src/model.js — model download, Cache Storage, and worker orchestration

frontend/src/pages/Record.jsx — the recording UX and result display

How I Built It

The entire stack is open-source. This project uses an open-weight model, an open-source inference framework, and local inference.

The stack:

BirdNET v2.4 — an open acoustic classifier from the Cornell Lab of Ornithology. 6,522 species, open weights, trained on real-world field recordings. I used the INT8 ARM variant (converted by tphakala) — ~47 MB, optimized for mobile CPUs.

ONNX Runtime Web — the open-source inference engine. Runs the model via WebAssembly directly in the browser, no installation, no backend.

React + Vite — the frontend.

vite-plugin-pwa — makes the app installable and offline-capable.

The pipeline:

Record 6 seconds via MediaRecorder, producing a WebM/Opus blob.

Decode and resample to 48 kHz using the Web Audio API.

Chunk into 3-second windows with 1.5-second overlap.

Send each chunk to a Web Worker running ONNX Runtime WebAssembly.

Run inference — the model outputs logits for 6,522 species.

Apply sigmoid to convert logits to confidence scores.

Sort and filter — top match plus alternatives, with a low-confidence fallback if nothing scores above 25%.

The caching strategy: the service worker precaches the app shell and the ONNX Runtime WASM files. The 47 MB BirdNET model is downloaded from Hugging Face on first load and cached in the browser's Cache Storage by model.js. After first load, every subsequent visit serves everything from disk — no network required.

A few things I had to learn the hard way:

PWAs can't run a Python backend. My first version was FastAPI + Python BirdNET. It worked, but it required a laptop nearby. If the model doesn't run on the phone, "offline" is marketing, not engineering. Porting to ONNX Runtime Web meant rewriting the entire inference pipeline in JavaScript.

The ONNX Runtime WASM file is 14 MB, not the 3 MB I assumed. Workbox's default precache limit is 2 MiB, so the build failed until I raised maximumFileSizeToCacheInBytes.

BirdNET uses sigmoid, not softmax. It's a multi-label classifier — multiple species can be present simultaneously. I initially used softmax and got nonsensical confidence scores.

Threaded WASM requires SharedArrayBuffer, which needs COOP/COEP headers. Single-threaded WASM is slower but works everywhere without special server config, and it's fast enough for a 3-second chunk.

Why Does Open Innovation Matter?

This project literally would not exist without open-source AI.

Offline is only possible with open weights. A closed bird ID API requires a network round trip. The best places to hear birds — deep forest, high alpine, remote wetland — are exactly where that round trip fails. Only an open-weight model can be downloaded to the device and run locally. This isn't a nice-to-have; it's the entire premise.

Privacy by architecture, not policy. A rare sighting is sensitive. It reveals where you were, when you were there, and what you saw. With a closed API, that data goes to a company server. With BirdNET running on-device, the audio never leaves your phone. Not because of a privacy policy because there is no server to send it to.

Zero marginal cost. No API bills, no rate limits, no monthly fees. A free public tool is only viable when the marginal cost of one more user is zero. With open weights, it is.

Portability and no lock-in. The same BirdNET model runs on Python, Node.js, a Raspberry Pi, and — as here — in the browser via ONNX Runtime. If a better runtime appears tomorrow, you swap it in without retraining. No vendor owns your pipeline.

Inspectable and modifiable. Anyone can inspect the model, fine-tune it on local species, or replace it with a different classifier. A closed system gives you a black box and a rate limit. This gives you a file and a license.

The challenge asked for open innovation, and the honest answer is that the open pieces aren't a bonus feature bolted onto a closed core. They are the product.

DEV Community: Vaibhav Agrawal

Listing Writer

What I Built

Demo

Code

competitive-programmer04 (Vaibhav Agrawal) · GitHub

How I Built It

Why Does Open Innovation Matter?

Touch Grass Birder: On-Device Bird ID in the Browser with Open-Weight AI

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?