DEV Community: Tanishk

Sloath-AI

Tanishk — Tue, 20 Oct 2026 20:14:32 +0000

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

What I Built
Let’s be honest: my Downloads folder was an absolute crime scene.

Between random PDF receipts, screenshots named Screenshot 2026-10-12 at 4.23.11 PM.png, three different copies of my resume, and half-finished Python scripts, finding anything felt like digging through digital junk mail. Every few months I'd promise myself I'd sit down and organize it all, only to get bored after sorting five files and give up.

So I decided to be properly lazy and build a tool to do the chore for me: SlothDesk AI.

SlothDesk AI is a desktop productivity assistant that lives on your machine and cleans up your folders without you having to lift a finger:

It looks at a messy directory and automatically groups everything into clean folders like Documents, Code, Images, and Archives — but only after showing you a safe preview first.
It actually reads the first couple of pages of your PDFs or text documents using a local AI model and renames them from things like scan_004921.pdf to quarterly-tax-statement-2026.pdf.
It lets you ask questions like "Where is my operating systems homework from last week?" and finds the exact file without uploading your notes to any cloud.
It calculates cryptographic hashes of your files to find duplicate copies wasting gigabytes of space, staging them into a safe trash folder so nothing ever gets permanently deleted by accident.
And if you ever make a mistake, there is a full undo button backed by SQLite that puts everything back where it came from.
To keep it fun, I built the UI with an obsidian black and electric yellow theme, complete with a friendly sloth mascot named Barnaby wearing little golden spectacles.

Demo
Live Web App: https://slothdesk-ai-24yo.onrender.com
API Documentation: https://slothdesk-ai-24yo.onrender.com/docs
Running Locally (with Ollama): Just clone the repo and run ./run.sh on Ubuntu Linux.
Code

tani2112 / Sloathdesk-AI

SlothDesk AI 🦥

“Work less. Let your sloth handle the boring stuff.”

🌐 Live Demo: https://slothdesk-ai-24yo.onrender.com

SlothDesk AI is a privacy-first desktop productivity assistant built for the “Slow and Steady” open-source AI challenge. It brings open-weight local AI directly to your operating system to organize messy folders, suggest intelligent filenames based on document excerpts, search files through natural language queries, and prepare safe storage cleanup recommendations.

🌟 Key Features

🗂️ 1. Smart File Organizer

Safe Dry-Run Previews: View an exact interactive preview table of where every file will be placed before anything moves.
Categorization Engine: Groups clutter into Documents, Images, Videos, Audio, Archives, Code, and Other.
Zero Data Loss Guarantee: Never overwrites files silently. Automatically resolves filename collisions (e.g. report (1).pdf).
Safety Boundary Checks: Prevents path traversal and skips system directories (/etc, /proc, node_modules, .git).

✍️

…

View on GitHub

The code is completely open-source under the MIT license:
👉 github.com/tani2112/Sloathdesk-AI

It includes a full suite of 20 unit and security tests checking path traversal prevention, duplicate hash checks, and collision-safe file moves.

How I Built It
I wanted this app to be fast, safe, and above all, respectful of the user's computer:

Local Inference with Ollama: Instead of relying on an expensive cloud API, the backend hooks into a locally running Ollama instance. I tested it mainly with qwen2.5:1.5b because it’s super quick and runs smoothly even on older laptops, but you can switch to llama3.2 or any model you prefer right from the settings.
Graceful Fallbacks: One thing that bugged me about a lot of AI apps is that they completely break if the model isn't running. I built SlothDesk so that if Ollama isn't started yet, it automatically falls back to regex search, file extension mapping, and SHA-256 deduplication. It still works 100% as a solid organizer even without the AI running.
FastAPI & Python Standard Library: The backend uses FastAPI. For safety, I wrote strict path validation to make sure file operations never escape the selected folder or touch system directories like /etc or /proc. I also integrated Python's watchdog to detect when new files land in your downloads in real time.
React 19 & Tailwind CSS: The frontend is built on Vite, React, and Tailwind. I really wanted a unique look, so I went with an obsidian dark theme highlighted by neon yellow and amber gradients.
Docker & Render Deployment: To make the web demo easy to check out, I wrote a multi-stage Dockerfile and a render.yaml blueprint that compiles the React bundle and serves it all as one unified service.
Why Does Open Innovation Matter?
When you think about building a desktop assistant, the first instinct a lot of people have today is: "Just send the files to an LLM cloud API."

To me, that felt totally wrong for a tool that lives on your personal computer.

Your downloads folder has your pay stubs, bank statements, personal photos, and proprietary code. You shouldn't have to beam your private documents across the internet just to give them sensible names.

With open-weight models like Qwen and open runtime engines like Ollama, you get intelligent document understanding running right on your own CPU or GPU. It costs zero dollars in monthly API tokens, it works when your Wi-Fi drops, and your data never leaves your machine. That’s what open innovation makes possible: powerful tools that put the user in complete control.

My Agent Session
I built and debugged this project—from the FastAPI security sandbox to the React frontend and Render container deployment—pairing with Antigravity (Google DeepMind).

The Lazy Payoff
Here is my honest before-and-after:

Before building this, every Friday afternoon I’d stare at ~150 random files in my Downloads folder, squint at cryptic PDF names, open them one by one to see what they were, create five new folders, and drag things around manually. It took at least 20 minutes of brain-numbing clicking.

Now:

I open SlothDesk and click "Organize Folder".
I check the dry-run preview table to verify where everything is heading.
I hit "Apply", and in about 2 seconds, 150 files are tucked away into their proper category folders.
I hit "Scan Duplicates" and wipe out 800MB of accidental double downloads.
Total time: about 30 seconds. That leaves me with 19 and a half minutes to do what Barnaby does best: kick back and relax.

BillBuddy

Tanishk — Wed, 14 Oct 2026 20:12:15 +0000

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

What I Built
I built SellCraft, an AI-powered product listing generator for solo online shop owners, Instagram thrift sellers, Etsy crafters, and resellers.

Writing product titles, descriptions, benefit bullet points, search tags, and social captions takes small sellers hours every single week. Most solo sellers can't afford expensive copywriting agencies or commercial AI tools that charge $20–$40/month subscriptions.

SellCraft solves this by taking basic product details (name, category, specifications, target audience, platform, tone, and language) and generating a complete, marketplace-ready listing in seconds:

SEO-optimized primary title + 3 alternative titles for A/B testing
Detailed product narrative and description
5 benefit-driven key selling points
Search keywords and marketplace tags
Ready-to-post Instagram caption complete with line breaks, emojis, and 15–20 relevant hashtags
A high-urgency call-to-action sentence
1-click individual section copy and clean .txt file export
Small boutique owners, Instagram DM shops, and resellers would pay for this because it cuts their listing creation time from 20 minutes down to 10 seconds per item, without requiring expensive per-token cloud subscriptions.

Demo
Live Deployed App: https://billbuddy-frontend-zfns.onrender.com
Backend API & Swagger Docs: https://billbuddy.onrender.com/docs
Code

tani2112 / billbuddy

SellCraft — Open-Source AI Product Listing Generator

Local, open-weight e-commerce copilot for small business owners, Instagram sellers, resellers, and boutique shops.
Create high-converting SEO titles, product descriptions, 5 key selling points, tags, and Instagram captions in seconds with 100% privacy and zero per-token API fees.

1. Project Overview

Small business owners, Instagram sellers, and independent creators spend countless hours writing copy for their catalogs, marketplaces (Etsy, eBay, Shopify, Amazon), and social media. Many cannot afford costly SaaS subscriptions (like Jasper or Copy.ai) or expensive copywriting agencies.

SellCraft solves this problem by delivering enterprise-quality listing generation powered by open-weight AI models (such as Qwen 2.5 and Llama 3.2) running locally on the user's machine through Ollama.

Zero Cloud API Fees: Generate unlimited listings without an OpenAI/Anthropic subscription or credit card.
Total Data Privacy: Product specs, photos, pricing, and drafts never leave your computer.
Multilingual Support: High-converting copy tailored…

View on GitHub

GitHub Repository: https://github.com/tani2112/billbuddy

How I Built It
SellCraft is built entirely around local open-weight AI inference:

AI Model & Inference: I used Qwen 2.5 (1.5B) running locally via Ollama. Qwen 2.5 was chosen because it delivers exceptional reasoning and structured JSON generation in under 1GB of memory, runs at ~14 tokens/second on consumer laptop GPUs, and natively supports English, Hindi, and Hinglish. The app also supports Llama 3.2 and vision-capable open models.
Backend: Built with Python and FastAPI. It handles model prompt tailoring based on platform rules (Instagram vs. Etsy vs. eBay), enforces strict JSON schema validation, exposes system health diagnostics, and manages local persistence with SQLite.
Frontend: Built with React 18, TypeScript, Vite, and Tailwind CSS. It features a modern dashboard, progressive generation indicators showing the active local model, light/dark mode, toast notifications, and an inline editor to tweak listings before exporting.
Testing: Automated tests written with pytest verify the generation endpoints, schema validation, CRUD operations, and offline Ollama fail-safes.
Why Does Open Innovation Matter?
Open innovation and open-weight models made things possible for SellCraft that closed proprietary APIs simply could not:

Zero Recurring Token Costs: Closed APIs charge for every single prompt, draft, and revision. For a side hustler or small seller on thin margins, those per-request fees add up fast. Open models let sellers run infinite generations on their own machine for $0.
Total Data Privacy: Crafters and boutique owners often write listings for custom jewelry, unreleased collections, or proprietary handmade items. With local open-weight models, no product photos or specifications are ever transmitted to third-party cloud servers or used for model retraining.
Offline Resilience & Independence: Open-source AI means sellers aren't at the mercy of sudden API price hikes, rate limits, or vendor downtime. The model runs locally and stays in the developer's hands forever.

TrailBuddy

Tanishk — Sun, 11 Oct 2026 19:34:22 +0000

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

What I Built
Like many developers, I spend way too much time glued to screens. Between debugging, reading docs, and scrolling feeds, my days were blending together indoors. When I saw the "Touch Grass" theme for Week 1, I wanted to build something that doesn't just talk about going outside, but actually forces you to put your phone down and be present.

I built TrailBuddy — Your AI Nature Companion.

Here is what it does:

18 "Touch Grass" Missions: Fun, bite-sized outdoor challenges across Botany, Wildlife, Sensory, Mindfulness, and Earth. Things like sitting still and listening to an outdoor soundscape for 3 minutes, tracking down three completely different leaf shapes, or finding 5 natural colors that aren't green or brown.
Screen-Free "Pocket Mode": My favorite feature. When you start an activity, you tap "Pocket Mode", and the screen dims into a slow, breathing dark green circle that literally says "Screen idle. Look around you! Put your phone in your pocket." You get a gentle audio chime when the time is up, so you're never tempted to check your notifications while doing a mission.
Private Field Journal: A simple place to write down what you noticed—the smell of rain on dry dirt, bird calls, or tree bark textures. It stores everything locally in SQLite and intentionally never asks for GPS permissions, so your private reflections stay yours.
AI Nature Guide: An on-device assistant you can ask about plant shapes, bird behaviors, animal tracks, and trail safety.
It's for anyone who feels screen fatigue and wants a gentle nudge to get out into the park or backyard and notice the little things.

Demo
You can try the live web app here: 👉 https://trailbuddy-3iri.onrender.com

(Tip: Try starting today's mission on your phone and putting it in your pocket!)

Code
The full source code is on GitHub:

tani2112 / TrailBuddy

Your AI companion for the outdoors

🌿 TrailBuddy — Your AI Nature Companion

"The real world outside has no battery limit, zero latency, and infinite resolution."

TrailBuddy is a modern, nature-inspired web application designed to encourage people to spend less time on screens and more time in nature. It helps users discover outdoor wonders, complete mindful "Touch Grass" challenges, consult a local open-weight AI guide, and record personal field observations in a private SQLite journal.

🧭 Tech Stack & Philosophy

Frontend: React 18, TypeScript, Vite, Tailwind CSS, Lucide icons, Canvas Confetti.
Backend: Python 3.10+ with FastAPI, aiosqlite for async SQLite, httpx for Ollama communication.
AI Core: Ollama running locally on your device with open-weight models (e.g. llama3.2, mistral, phi3). No paid cloud AI APIs. 100% private and on-device.
Database: SQLite (trailbuddy.db) with zero external cloud dependencies.
Design Aesthetic: Forest green, sage green, warm cream parchment, tactile…

View on GitHub

Frontend: React, TypeScript, Vite, Tailwind CSS, Lucide icons, Canvas Confetti.
Backend: Python FastAPI with aiosqlite for local database storage.
AI: Ollama running locally with open-weight models like llama3.2.
How I Built It
I wanted TrailBuddy to be self-reliant, fast, and completely free of paid cloud APIs:

Local AI with Ollama: I wired the chat interface to a local Ollama instance running llama3.2. Because the model runs right on the machine, you don't need any OpenAI API keys, credits, or subscriptions.
Thoughtful Prompts & Safety First: I tuned the system prompt to guide people with field observation cues (like looking at whether leaf stems are alternate or opposite) rather than pretending the AI is an infallible camera classifier. Most importantly, it includes an absolute safety rule: never tell someone a wild mushroom or plant is safe to eat without a real-life expert verifying it.
Offline & Graceful Fallbacks: If someone is on a trail with spotty cellular connection or doesn't have Ollama running, the rest of TrailBuddy (all 18 challenges, the timer, Pocket Mode, and the journal) still works 100% offline. The AI tab clearly explains how to start Ollama with terminal commands whenever you're back at your desk.
Why Does Open Innovation Matter?
To me, open innovation here was about two things: privacy and freedom.

First, when people write personal reflections or thoughts during a quiet walk in the woods, that data shouldn't be uploaded to third-party ad servers or used to train corporate models. Storing everything locally in SQLite and using open-weight models means your journal stays entirely on your own machine.

Second, nature doesn't have Wi-Fi. Closed APIs cost money per token and instantly break the second you lose cell reception on a hiking trail. Open-weight models like Llama give developers the freedom to build offline-first tools that anyone can run for free, anywhere in the world.

I Built Dadi's Recipe Vault to Save Family Recipes

Tanishk — Sun, 04 Oct 2026 20:49:56 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built Dadi's Recipe Vault, a web app that turns family recipe memories into structured recipes.

The idea came from a simple problem: a lot of family recipes aren't actually written down. Someone knows how to make something and explains it over a phone call or sends a message with the recipe. Over time, those messages can get buried, and the recipe can be lost.

So I wanted to make something simple where you can give the app a recipe explanation or transcript, and it turns that unstructured information into a proper recipe that can be saved and used later.

The app uses AI to extract the ingredients and cooking steps and organize them into a clean recipe card.

DEMO

Try the live app here:

https://dadi-recipe-vault.onrender.com

The frontend and backend are deployed separately on Render.

Code

GitHub repository:

https://github.com/tani2112/DEV

How I Built It

The frontend is built with React, TypeScript, Tailwind CSS and Vite.

The backend uses Python and FastAPI, with SQLite for storing recipes.

The main flow is:

Recipe text / transcript → Open-weight AI → Structured recipe → Saved recipe

The AI takes an unstructured recipe explanation and turns it into a structured recipe containing the recipe name, ingredients, quantities and cooking steps.

I also added instructions to avoid making up ingredients or quantities when they aren't provided.

The frontend and backend are deployed separately on Render.

Why Does Open Innovation Matter?

For this project, AI isn't just an extra chatbot feature. It is part of the main functionality of the application.

Using an open-weight model gives the project more control over how the AI is used and how the recipe information is processed.

It also gives me more freedom to experiment with the AI side of the project without making the whole application dependent on a closed AI service.

My Agent Session

I used an AI coding agent during development to help with implementation, debugging and deployment.

The project was tested and iterated on manually to make sure the final application actually worked.

Prize Categories

I'm submitting this project for the Build for a Friend challenge.

The project is built around a simple problem: keeping family recipes from getting lost in messages and conversations.

hey

Tanishk — Sun, 04 Oct 2026 06:24:56 +0000