DEV Community: Aniruddha Shirke

SlothDesk: A Local-First AI Assistant for Digital Chores

Aniruddha Shirke — Sun, 25 Oct 2026 17:29:40 +0000

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

What I Built

SlothDesk is a local-first assistant for small digital chores. It organizes a folder into useful categories, summarizes text-based documents, and turns pasted notes into checklists or practical plans.

For file cleanup, SlothDesk scans a selected folder and prepares a preview showing each file’s suggested category and destination. Nothing moves until the user reviews the plan and confirms. It avoids overwriting existing files and keeps an undo manifest for the latest organization run.

Code

Aniruddhashirke / SlothDesk

🦥 SlothDesk

Your local-first AI helper for boring digital chores.

SlothDesk is a Streamlit app that organizes files, summarizes text-based documents, and turns pasted notes into practical checklists. AI features use a local Ollama model, so your document contents are not intentionally sent to a hosted model API.

Features

Preview-first file organization — sort files into folders by type and review every proposed move before anything changes.
Optional local AI classification — ask Ollama to classify files with unknown extensions using the filename only.
Document summaries — summarize text-based PDF, TXT, and Markdown files.
AI productivity helper — turn pasted notes or instructions into concise plans, checklists, and summaries.
Undo support — save a manifest for the latest organization run and restore moved files where possible.
Privacy-first workflow — file operations stay on your computer and Ollama runs locally.

Architecture

Main flow: Streamlit UI (app.py) -> Application services (src/) ->…

View on GitHub

How I Built It

SlothDesk is a Python and Streamlit app. File categories are assigned with extension rules first; optional AI classification is used only for unknown file types and sends the filename, not the file contents.

For document summaries and the notes helper, SlothDesk sends extracted text to a local Ollama service using Gemma 3 4B. PDF text extraction uses pypdf. The main flow is:

Folder → scan and classify → preview plan → user confirms → move files → save undo manifest
PDF/TXT/Markdown → extract text → local Gemma through Ollama → summary

Keeping File Cleanup Safe

SlothDesk separates planning from action. First it scans the selected folder and creates a destination for each file. The preview shows the filename, suggested category, destination, and reason. I can review the plan before confirming any moves.

The organizer skips hidden files, avoids overwriting existing files, and records the latest run so it can attempt to undo those moves. This makes the workflow useful for real folders where I want automation but still need control over what changes.

Where Gemma Fits

Most files are sorted with built-in extension rules, which keeps routine classification fast and predictable. If I enable AI classification, Gemma is only asked to classify unknown file types using the filename; it does not receive those files’ contents.

For document summaries and the notes helper, SlothDesk sends extracted text to Gemma through my local Ollama service. That keeps inference on my machine, while letting me choose a different installed model if I want to change the setup.

What I Learned

Local inference makes privacy easier to reason about, but response time depends on the machine and whether the model is already loaded. While trying a real PDF, I hit the app’s original two-minute request timeout. I raised the timeout and improved the message shown if a request still takes too long.

I haven’t measured a specific number of minutes saved, so I’m focusing on the practical reduction in steps: scan, review one plan, and confirm instead of sorting each file manually.

Why Does Open Innovation Matter?

Running an open-weight model locally keeps document text on the user’s computer instead of sending it to a hosted model API. Once Ollama and the model are installed, the AI features can run against the local service without depending on a cloud inference provider. The model setting is configurable, and the project code can be inspected and changed.

Open tools also let people adapt the workflow to their own folders and privacy needs, rather than handing their files to a closed service just to sort or summarize them.

The Lazy Payoff

A folder that would take repeated manual sorting can be scanned into one reviewable plan. I can check the proposed destinations once, confirm the moves, and use the saved manifest to undo the latest run if needed. I haven’t measured a time-saving figure yet, so I’m describing the reduced steps rather than claiming a number.

Prize Categories

Best Use of Gemma

🛡️ Dispute Defender: a local AI that has to cite its evidence

Aniruddha Shirke — Sun, 18 Oct 2026 18:35:25 +0000

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

What I Built

A buyer opens a dispute on a $29 set of linen kitchen towels: "The box was crushed and the item inside is damaged." You packed it in a double-walled box with bubble wrap. USPS shows it delivered four days after it shipped. The platform gives you until the end of the month to answer.

Now you have to dig up the order, the tracking, the message thread and the policy, and write something calm. It's late, and the whole thing is worth $29. Plenty of people just refund it.

I made this case up. It's case_002 in my test set, and every case in this project is synthetic. It is the shape of problem I wanted to attack: the evidence is scattered, the deadline is short, and the amount is too small to feel worth the effort. That is my premise, not a statistic.

Dispute Defender is a local AI that drafts the seller's reply, and every clause has to cite numbered evidence. You give it a case folder (dispute notice, order CSV, messages, photos). It gives back:

numbered evidence (E1, E2, ...) and a list of what's missing,
a fight-or-fold verdict (for case_002: FIGHT, score 0.45, expected recovery $13.05, from a simple heuristic of mine, not a calibrated probability),
a letter where every clause ends in a citation like [E5],
a REPAIRS list of anything the code had to change.

Who would pay? The person I built it for is a small marketplace seller who handles disputes alone, in the gaps between other work. I haven't asked anyone whether they'd pay, so I'm not putting a price on it. [Optional: your price idea, labeled untested.]

Order 9814174 for Linen kitchen towel set ($29.00) was placed on 2026-01-13. [E2]
The carrier shows the package delivered on 2026-01-18. [E4]
On 2026-01-23, the buyer wrote: "The box was crushed and the item inside is broken." [E5]

Code

Aniruddhashirke / disputedefender

Dispute Defender

A local AI that drafts a seller's reply to a marketplace dispute, where every clause must cite numbered evidence.

A buyer says the item never arrived, was not as described, or arrived damaged. The seller has a short deadline, the facts are scattered across an order record, tracking, a message thread and a policy, and the amount is often too small to feel worth the effort. Dispute Defender builds the evidence list, drafts the letter with a local Gemma model, then checks each clause against only the evidence it cites. Code repairs what it can without adding a word and drops the rest.

Model: Gemma 3 4B, open-weight, running locally through Ollama. Customer data stays on the seller's machine.
Code: Python 3.10+, standard library only (nothing to install).
Built for the DEV Hacktoberfest Open-Source AI Challenge, Week 2 ("Side Hustle"). The project and this repository were…

View on GitHub

Python standard library only (nothing to install), 163 tests, MIT license. The README has the commands to reproduce every number below.

How I Built It

The open-source AI: Gemma 3 4B, an open-weight model, running locally through Ollama. The project is built around one rule: a language model never decides what counts as true.

case folder -> numbered evidence -> triage -> Gemma drafts -> verify each clause -> retry once -> repair or drop

Each clause must cite numbered evidence. A verifier checks each clause against only the evidence it cites. Code then repairs what it can without adding a word, and drops the rest. Everything after the model is plain, deterministic code.

That rule caught real failures:

It described photos it never saw. My photo evidence is only a file name. Gemma wrote that the photo "shows the scarf packed in its original condition," and kept doing it. A stricter prompt cut photo claims from 7 of 15 runs to 1, but it created new failures (evidence ids in prose, uncited lines) and made the model slower. So I took the decision away from the model. Code now writes the photo sentences and the model never sees them.

It cited a true fact to the wrong evidence item. In one case, all 3 runs wrote "Tracking shows it was delivered on April 22 [E6]." The fact is in E7. The repair added E7 without adding a word. In another case, the verifier dropped "The buyer opened a dispute on 2026-06-06 [E6]." That date appears in two evidence items, and the repair only re-cites when exactly one other item contains the fact. With two, it refuses to guess and drops the sentence. That can lose a sentence that was true. I chose to fail closed.

It restated the buyer's claim in its own words. "The buyer says I have not received my order [E4]." The verifier flagged received, which isn't in E4, and dropped the sentence. A paraphrase that's fair to a human got cut. That is the cost of a word-level check.

With the rules removed, it turned into a customer-service bot. On a minimal prompt, Gemma wrote "Thank you for reaching out" and "I understand your concern that the package never arrived, despite the tracking." The verifier flagged never and the uncited line after it. I also added a check that rejects apologies and admissions unless the evidence itself contains them.

The numbers. "First draft clean" means the verifier found nothing wrong in the model's first attempt. All rows are Gemma 3 4B on one ASUS laptop (about 46% of the model on the GPU), on 30 generated cases (26 scored; 4 were fold verdicts).

Setup	Runs scored	First draft clean	Content dropped	Attempts	Seconds/case
Full prompt, 1 run per case	26	92% (24 of 26)	4%	1.04	25.2
Full prompt, 3 runs per case	77	94% (72 of 77)	3%	1.03	25.5
Minimal prompt, no fine-tune	26	0% (0 of 26)	50%	2.0	42.1

The three-run row isn't three independent confirmations: three of its five non-clean runs are the same case. Put differently, 23 of 26 cases were clean in every run. One run failed with an Ollama server error and is not counted.

Cutting the prompt to save time made the model worse and slower, because every case needed a second attempt. In fairness, the minimal prompt is designed for a fine-tuned model, and I ran it on the untuned one. It shows what happens when the rules are left out.

Earlier, on 15 runs of 3 hand-built cases, 40% of first drafts were clean when the model wrote the photo sentences, and 60% with the stricter prompt. Letting code write them gave 100% clean on those same cases. That 100% is on cases I tuned against, so it is not a held-out number. On 20 unseen generated cases an earlier build scored 95%, and on 12 scored runs of a harder generator on a CPU-only laptop it scored 67%. Those came from different builds and machines, so I'm not claiming a trend. On the same 6 cases on the ASUS, the full prompt gave 4 of 6 clean and the minimal prompt 1 of 6.

Limits

The Etsy policy and checklist are placeholders. No real policy is encoded.
The verifier checks words, not meaning. A misleading rearrangement of true facts can pass.
Every case is synthetic, written by my own generator, and the samples are small.
The win score is a heuristic I made up.
On a CPU-only laptop it took about 136 seconds per case on my harder cases.

Why Does Open Innovation Matter?

Dispute data is customer data: names, addresses, messages. Because Gemma's weights are open, the whole thing runs on the seller's own machine, offline, and none of it leaves. There's no per-token bill either, only electricity.

Open weights also let me do the work this project needed. I could read every raw draft, find that the model invents photo details, and build a verifier around its mistakes. I could pin one model file and rerun the same 30 cases to get the numbers above. With a closed hosted model I couldn't fix which version answered or inspect what it did between releases. The price is speed: a 4B model on a laptop is slow, and I've measured exactly how slow.

Prize Categories

Best Use of Gemma: Gemma 3 4B, running locally through Ollama, writes every letter, and all the measurements above are Gemma runs.

TerraQuest: Put the Phone in Your Pocket, Let an Open-Weight Model Name the Animals and Plan

Aniruddha Shirke — Thu, 08 Oct 2026 20:46:18 +0000

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

What I Built

Most outdoor apps want your eyes on the screen. TerraQuest wants them on the trail.

TerraQuest is a walking companion that tracks your walk in the background, speaks a small mission to you, and names the plants, birds, insects and other wildlife you photograph. Tap Start, put the phone in your pocket, and walk. When something catches your eye, take one photo. The app identifies it, pins it on the map where you found it, and saves it to a journal you read after the walk, not during it.

How it keeps the screen short

Walks track themselves. GPS distance, active time and estimated calories run without you touching anything.
Missions are read aloud. Prompts like "listen for a bird for 10 seconds" are spoken, and you can answer by voice.
Rewards follow walking, not scrolling. XP and streaks come from walks and finds. A day with no walk doesn't count.
The journal is for later. Each walk saves its route, the photos of what you found, and a short report.
Nearby places are suggested from OpenStreetMap, with walking directions.

Why walking

Regular brisk walking is one of the simplest habits you can build. It is linked to better heart health, mood, sleep and energy, and it needs no gym or equipment. The hard part is keeping it up. TerraQuest gives a walk a reason: a bird to listen for, a plant to find, a streak to keep. Turning "I should walk" into "I wonder what's around the corner" is the whole idea. (Calories are estimates from GPS and time, not medical data.)

Many people walk past plants and birds they've never learned the names of, and learning them usually means stopping to search on a screen. TerraQuest is for anyone curious about nature who doesn't want to look down at a phone, from families on a weekend stroll to people building a daily walking habit.

Demo

Live app: [https://terra-quest-hazel.vercel.app/]

The first scan downloads the on-device model once. After that, scanning works without a connection.

Code

https://github.com/Aniruddhashirke/TerraQuest (MIT licensed)

Aniruddhashirke / TerraQuest

🌿 TerraQuest

A mobile-first outdoor companion. Go for a walk, scan the plants, birds and insects you meet, and watch your journal, map and stats fill up. It's a PWA that installs on your phone and works offline.

Features

Sign in with Google or your phone number (SMS code), or continue as a guest.
Home dashboard: nearest nature spot, Today / Week / All time stats, weekly goal ring with streak, daily mission and recent finds.
Walk tracking: GPS route, distance (Haversine with outlier filtering), active time and estimated calories. Steps show "unavailable" rather than being faked.
Scan and identify: take a photo of a plant, bird or insect. A cloud vision model names it…

View on GitHub

How It Works

start walk
   |
   v
GPS route + timer (runs in the background)
   |
   v
photo of a plant, bird, insect or animal
   |
   +-- online? --> cloud vision model --> name + scientific name
   |                    |
   |                    +-- plant? --> Pl@ntNet second opinion
   |
   +-- offline, slow, or error --> CLIP on the device (Transformers.js)
   |
   v
result card --> saved to the journal with photo, GPS and time
   |
   v
map pins + route --> next mission --> stop walk --> report

1. Identification on the device (open model)

The open-weight model is CLIP ViT-B/32 (Xenova/clip-vit-base-patch32), running in the browser through Transformers.js. It is a zero-shot classifier, so there is no training and no server. The photo is scored against about 70 nature labels, which I tuned to birds, plants and insects common on Indian walks, such as bulbul, myna, banyan and tulsi.

2. A cloud upgrade, and an honest fallback

When the phone is online, the photo also goes to my own serverless function, which asks a cloud vision model for a common and scientific name. The API key never reaches the browser. If the call fails, times out after 25 seconds, or there is no signal, the app drops back to CLIP without an error screen:

if (navigator.onLine) {
  try { list = await identifyOnline(photo); source = 'cloud' } catch { /* fall back */ }
}
if (!list) { list = await classify(photo); source = 'device' }

The result card always tells you which path produced the answer.

3. Missions: rules first, AI second (Gemma)

A deterministic engine picks the next mission from your context: how far you've walked, how many plants and birds you've found, and a cooldown so you don't get the same mission twice. Gemma (open weights, running in the browser over WebGPU, [model variant]) only rewords the text and writes the optional walk note after your walk. If it is offline, slow, or returns something odd, a built-in template is used. The prompt says never to invent a species.

4. Everything is stored on the device

Walks, finds, missions and your profile live in IndexedDB through Dexie, so the app shell and your saved data keep working with no signal.

Other pieces: React 18 and TypeScript, Vite with a PWA service worker, Leaflet with OpenStreetMap and Overpass for nearby places and routes, Wikipedia for species summaries, the browser speech APIs for voice, and Firebase Auth for optional sign-in (guests work fine). Vitest covers the mission rules, geo math, stats, journal reports and identification parsing.

Why Open Matters Here

A trail is the worst place for an app that needs a network.

It works where the walk happens. With CLIP on the device, a scan doesn't depend on cell coverage. A cloud-only identifier stops at the edge of signal.
Photos stay on the phone on that path. That matters for family walks and private land.
It costs nothing per scan. There is no per-image bill for a free walking app.
It's hackable. The model is one constant and the label list is a plain array. Anyone can fork it, swap the model, or add their own region's species.

Where the closed model was better: it gives sharper common and scientific names, while zero-shot CLIP is coarser and will say "kingfisher" where a cloud model might name the exact species.
Where open won: it's the only version that works with no signal, keeps photos private, and costs nothing. That's why the cloud model is an optional upgrade, not the foundation.

What Went Wrong, and What I Changed

npm install failed on a second machine. Transformers.js pulls in sharp and onnxruntime-node, whose native downloads fail on Windows and restricted networks. The browser app never uses them, so I set ignore-scripts=true in .npmrc and stopped copying node_modules between machines.
A zero-shot classifier always has to pick something. Show it a phone screen or a face and it will confidently name a bird. I added decoy labels like "phone screen", "person" and "building" so non-nature photos land there instead.
It can still be wrong. In testing, a colourful coleus leaf came back as "fern" at 69%. Confidence is shown on every result, and the cloud model and Pl@ntNet exist to correct cases like this.
Model output can't be trusted. The cloud answer is parsed as JSON and validated: categories are whitelisted, confidence is clamped between 0 and 1, text lengths are capped, and anything malformed triggers the CLIP fallback.
Plant identification can hurt people. The prompt tells the model never to say whether anything is edible, poisonous or safe to touch.
Adding Gemma broke the production build. Its WebGPU runtime is about 6 MB and the PWA precache limit is 2 MB. Instead of raising the limit, I made it a lazy chunk, cached only the first time someone taps Write a walk note. The main app stayed small.
Sign-in worked locally but failed once deployed with auth/unauthorized-domain. Firebase only allows sign-in from authorized domains, so I added the live domain in the console. Guest mode keeps the app usable regardless.
Browsers have no step sensor. Rather than faking a step count, the app shows steps as unavailable and uses GPS distance for missions.
Public OpenStreetMap servers are fair-use. Nearby results are cached for 30 minutes so the app doesn't hammer them.

What's Next

Bird sound identification with BirdNET, an open model, so you can identify a bird without looking at the screen at all.
Separate local data for each signed-in account.
Restoring an in-progress walk after a reload.

Map data © OpenStreetMap contributors. Species summaries from Wikipedia. Plant second opinions from Pl@ntNet. Built with React, Vite, Dexie, Leaflet, Firebase, Transformers.js and Gemma.

Prize Categories

Week 1 Theme: Touch Grass (primary category)
Best Use of Gemma
General Hacktoberfest Open-Source AI Challenge

DEV Community: Aniruddha Shirke

SlothDesk: A Local-First AI Assistant for Digital Chores

What I Built

Code

Aniruddhashirke / SlothDesk

🦥 SlothDesk

Features

Architecture

How I Built It

Keeping File Cleanup Safe

Where Gemma Fits

What I Learned

Why Does Open Innovation Matter?

The Lazy Payoff

Prize Categories

🛡️ Dispute Defender: a local AI that has to cite its evidence

What I Built

Code

Aniruddhashirke / disputedefender

Dispute Defender

How I Built It

Why Does Open Innovation Matter?

Prize Categories

TerraQuest: Put the Phone in Your Pocket, Let an Open-Weight Model Name the Animals and Plan

What I Built

Why walking

Demo

Code

Aniruddhashirke / TerraQuest

🌿 TerraQuest

Table of contents

Features

How It Works

1. Identification on the device (open model)

2. A cloud upgrade, and an honest fallback

3. Missions: rules first, AI second (Gemma)

4. Everything is stored on the device

Why Open Matters Here

What Went Wrong, and What I Changed

What's Next

Prize Categories