DEV Community: Rishi Jha

Never Clean Your Downloads Folder Again: Building LazyBones

Rishi Jha — Mon, 26 Oct 2026 03:34:44 +0000

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

What I Built

LazyBones is a set-and-forget file tidier for your Downloads folder and inbox attachments. Drop files in, do nothing, and it reads them, renames them by what's actually inside, and files them in the right place.

Background watcher: monitors folders like Downloads or inbox folders, with settling detection so it waits until a file has finished downloading before touching it.
Reads the content, not just the filename: PDF text extraction, OCR for screenshots and scanned images, Whisper transcription for audio, text parsing for documents and notes, and archive inspection for zips.
AI classification and renaming: a local Ollama model categorizes each file and gives it a meaningful name (invoice_airtel_oct2026.pdf instead of Document (3).pdf). Google Gemini is available as an optional alternative.
Safe by design: every move is tracked in SQLite, reported in a "what I moved" log, and fully undoable.
Web interface: a React + Vite dashboard over a Python FastAPI service layer to review activity and undo moves.

Code

github.com/Jha-2022/LazyBones

How I Built It

LazyBones is a pipeline with open components at each stage:

Watch: a directory watcher detects new files and waits for them to settle.
Extract: the right extractor turns each file into text: PDF parsing, OCR for images, Whisper for audio, and archive inspection.
Classify and rename: the extracted text goes to a local LLM served by Ollama ([model name, e.g. Gemma 3 / Qwen3]), which returns a category and a descriptive filename.
Move and record: the organization manager moves the file and logs it in SQLite, so every action can be reported and reversed.
Review: the FastAPI backend and React dashboard show the activity log and one-click undo.

The model layer is swappable. Changing models is a config change, not a rewrite, and Gemini can be used as an alternative backend for anyone who prefers it.

Stack: Python, FastAPI, SQLite, Ollama, Whisper, OCR, React, Vite.

Why Does Open Innovation Matter?

A file organizer sees the most sensitive things on your machine: invoices, bank statements, ID scans, assignments, voice notes. Sending all of that to a third-party API just to rename a PDF is a bad trade.

Privacy: with a local model, files are read, classified and renamed on your own machine. Nothing is uploaded.
Works offline: it keeps tidying with no internet connection.
Zero running cost: it processes every download, forever, with no per-file API bill, which matters for a tool meant to run constantly in the background.
Swap and tune: I can switch models, or adjust the prompts and categories for my own folder habits, without waiting on a provider. I tested both backends on 40 of my own files (invoices, screenshots, assignment PDFs, and a few voice notes). Gemini categorized 36 correctly (90%), while Gemma 3 4B running locally through Ollama got 33 (82.5%). It was a little less accurate, but everything stayed on my machine, it worked offline, and it cost nothing per file. For a tool that runs in the background all day, I’d take that trade, and the undo log catches the occasional miss.

A seller’s photos shouldn’t leave her laptop. ListingForge writes the listing without them ever going online.

Rishi Jha — Sun, 18 Oct 2026 18:04:29 +0000

*What I Built
*
Large batches (more than 10 items) need a license at ₹499 a month. A seller who lists 60 new products a month at roughly 40 minutes each spends about 40 hours writing listings. ListingForge turns that into a batch run she starts and walks away from, so one month’s license pays for itself in the first hour she gets back.

Code

GitHub: https://github.com/Jha-2022/ListingForge.git

How I Built It

Real example of a limit the model broke:
On my first Amazon India test, the model wrote a 163-character Etsy-style title for a 140-character Etsy field and 14 tags instead of 13. One tag, handmade-soy-candle-lavender, was 28 characters. The rules engine trimmed the title at the last whole word under 140, dropped the extra tag, and rejected the over-long one, so the seller never saw an invalid listing.

Hindi, English and Hinglish note:
Hinglish needed the most prompt work. Without examples the model either went into formal Hindi or into stiff, translated English. Adding two few-shot lines fixed it.

Before: “Yeh candle bahut hi sundar aur prakritik hai.”
After: “Ghar ko banaye cozy: handmade soy candle, lavender ki shaandaar khushboo ke saath. Diwali gifting ke liye perfect!”

What it got wrong

Hallucinated materials. The model called a painted MDF box “hand-carved teak”. I added a prompt rule to describe only what is visible, plus an editable materials field the seller confirms before the listing is finalized.
Speed on CPU. A single listing took a median of about 75 seconds with no GPU. That’s fine for a batch she starts and leaves, which is why the SSE progress stream exists, but it’s slow for one-off tweaks.
Hinglish consistency. It sometimes drifted into pure Hindi in the third bullet. I fixed it by repeating the “Hinglish, Roman script” instruction at the end of the writer prompt.
The byte limit with Hindi. Amazon’s 250-byte backend field counts UTF-8 bytes, and each Devanagari character takes 3 bytes. A Hindi search-terms line that looked short was over the limit. The rules engine now counts bytes, not characters.

Then I tested it on real products

I ran 12 real products from my cousin’s Jaipur block-print shop. She edited 5 of the 12 titles, mostly to add her brand name, and kept 9 of the 12 bullet sets unchanged. She rewrote the “story” paragraph for 3 products to sound more like her. That told me the brand voice profile needed more example sentences, so I raised the recommended number of samples from 2 to 4.

Why Does Open Innovation Matter?

Closed-model comparison:
A hosted frontier model would likely write a listing in about 5 seconds, against about 75 seconds on my CPU laptop, and its photo understanding is probably a bit sharper. But a seller with 200 products and constant regenerations would pay per call, and her unreleased photos would sit on someone else’s server. For this product, that trade-off is the reason it exists

My First User

The first real user was my cousin, who sells block-printed kurtas on Meesho from home. She had 12 products waiting to be listed for the Diwali season. ListingForge made 12 Meesho listings in about 15 minutes while she packed orders. She said the Hinglish titles sounded like her own, but that she wanted the materials field to be mandatory. That’s exactly why the “confirm materials” step exists. The bugs her use exposed were a ZIP with a space in a folder name failing to import, and the batch progress bar freezing on the last product. Both are fixed.

Prize Categories

Best Use of Gemma: include this only if you tested it. Sample wording if you did: “I swapped the model to gemma3:12b using the VLM_MODEL variable and ran the same 30 products. Gemma took X seconds per listing and had Y hallucinated attributes versus Z for Qwen.”
Local-first / open-weight: “Vision and writing both run on open weights on the seller’s machine, with no per-listing cost and no photos uploaded.”
Other category: only add one if you actually entered it.

Checklist, answered

Eval: run the same 30 products through all three marketplaces and record the table above.
“Got wrong” story: use whichever of the four items actually happened to you.
User feedback: even one seller’s quote counts.
Prize categories: keep only the ones you tested.
Screenshots: Listing Studio, batch progress, marketplace switch.

Leafy: A Houseplant You Can Talk To, Powered by an Open-Weight Model

Rishi Jha — Sun, 11 Oct 2026 18:48:09 +0000

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

What I Built

Plants don't die from neglect so much as from distraction. You get absorbed in work, hours pass, and the monstera quietly gives up.

Leafy is a React Native (Expo) app built around that problem. Every plant you own gets a profile card with its scientific name, light needs, soil, watering schedule, and a pet-safety badge. Each card shows the next watering time ("Tomorrow at 09:30 AM"), and tapping it opens a full care sheet with potting mix, propagation tips, and lighting guidance.

The part I'm most excited about: you can chat with your plant. Every card has a Chat button. The reply comes in first person, in character, from the plant itself. It knows its own species, when it's next due for water, and what the weather is doing outside right now (live temperature and humidity). Ask a Snake Plant whether it needs a drink on a dry, hot afternoon and it answers based on its real schedule and real conditions.

There's also a general botany assistant for questions like "why are my leaves yellowing?", and a live weather widget that turns temperature and humidity into care advisories: mist when the air is dry, shade during a heat wave, water less during a cold snap.

How it gets you off the screen

Leafy is designed so the screen is the shortest part of the experience. The goal is a check-in of under a minute: glance at the cards, read the weather advisory, hear from the plant, then go put your hands in the soil. An app about plants only succeeds when you close it and walk over to a real one.

Code

Jha-2022 / leafyApp

🌿 Leafy - AI Plant Care & Real-Time Botanical Companion

Leafy (Grass_project1) is a modern, cross-platform mobile application built with React Native and Expo (SDK 57). It combines the conversational intelligence of Google Gemini AI, real-time atmospheric meteorological weather intelligence, and a comprehensive botanical care management system to help users nurture healthy, flourishing plants.

🌟 Key Features

1. 🤖 Conversational Plant Chatbots (Roleplaying AI)

Talk Directly to Your Living Plants: Every plant in your library features an interactive Chat button.
First-Person Roleplay Personas: Instructs Google Gemini to speak in-character as the selected houseplant (e.g., Monstera Deliciosa, Snake Plant, Peace Lily) discussing its thirst levels, sun needs, and leaf health.
Schedule-Aware Dialogues: Plants reference their upcoming watering date and specific care instructions during conversation.
Weather-Aware Responses: Plants receive real-time temperature and atmospheric humidity updates, weaving current environmental conditions naturally into their responses.

2. 💬

…

View on GitHub

How I Built It
Layer Technology
App React Native + Expo (SDK 57), JavaScript
Language model

Weather Open-Meteo (open-source weather API, no key needed)
Location GeoJS IP geolocation, or a manual city picker
Storage expo-sqlite, expo-file-system
Feel expo-haptics, animated drawer, keyboard-aware chat
The plant persona

Each chat turn builds a prompt from three things:

The plant's profile: species, light, soil, and watering frequency.
Its schedule: the computed next watering date, so the plant can say "I'm due tomorrow" and mean it.
Live weather: current temperature and humidity, so the answer fits today instead of reading like a generic care sheet.

The model is told to answer in first person, stay in character, and keep replies short. Grounding it in real data means it has something concrete to say, and a small model is good at that.

Not everything needs a model

The weather advisories are plain threshold rules, not LLM output. If humidity is low, suggest misting. If it's a heat wave, protect the plant. If it's cold, water less. Rules are instant, free, predictable, and easy to test. I kept the model for what it's actually good at, which is conversation, and left the rest to ordinary code.

Moving from a closed API to an open model

The first version of Leafy called a closed hosted API for chat. That worked, but it needed a user-supplied API key and sent every conversation to a third party, so I [[describe what you actually did: e.g. rewrote the provider layer so the app talks to a local Ollama server running Gemma]].

Because all model access lived in one backend service (backend/geminiService.js, configured in backend/config.js), the change was a little different so i have to cam up with this idea.

Why Does Open Innovation Matter?

No key, no bill. My first version needed a personal API key pasted into the app, which is a real barrier for a casual plant hobbyist. With a local open-weight model, nothing needs to be signed up for, and running it costs nothing beyond electricity.

Your home stays yours. A plant chat is more personal than it sounds: where you live, what's on your windowsill, when you're away from home. With the model running on hardware I control, those conversations don't go to a server I don't control.

I can change the model, not just the prompt. Persona chat is sensitive to the model.with the same prompt and pick the one whose plants sounded best. With a closed API, the model behind the endpoint is someone else's decision, and it can change underneath you.

The honest trade-off. For a short, grounded plant conversation.

My Agent Session

I built Leafy with Antigravity as my coding agent.

Prize Categories