DEV Community: Tashu Gupta

SlothDesk AI: Let Gemma Organize Your Files While You Take It Slow 🦥🤖

Tashu Gupta — Tue, 20 Oct 2026 19:27:04 +0000

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

What I Built

Ever opened your Downloads folder to find one file, only to get lost in a sea of screenshots, PDFs, documents, and randomly named files? 😭

I wanted to make that everyday frustration a little easier to handle.

Meet SlothDesk AI — an AI-powered file organization assistant that helps turn a messy workspace into a more organized one, without taking control away from the user.

Instead of manually sorting files one by one, you can scan a workspace, review AI-generated organization suggestions, approve the actions you want, and execute them. Supported file operations can also be undone.

🦥 The idea: let AI help with the repetitive work while you stay in control.

Key Features

📂 Scan: Inspect files in a workspace.
🤖 AI Suggestions: Get recommendations for organizing files.
👀 Human Approval: Review and approve or reject proposed actions before execution.
↩️ Undo Support: Reverse supported file operations.
🔒 Restricted Demo: The hosted demo is designed to operate within a designated sample workspace.

The goal isn't to automate everything blindly. It's to make file organization easier while keeping important decisions in human hands.

Demo

🚀 Try the live application: https://slothdesk-ai.onrender.com

The project is deployed on Render, with a React frontend and a FastAPI backend.

Code

💻 Explore the source code on GitHub: https://github.com/tashu031/SlothDesk-AI

Feel free to explore the implementation, try the demo, and share suggestions or contributions!

How I Built It

SlothDesk AI combines a web interface, a Python backend, database storage, and an open-weight language model.

Tech Stack

Frontend: React and Vite
Backend: Python and FastAPI
Database: SQLite
AI Model: Gemma 2B
Local Inference: Ollama
Deployment: Render
Testing: Pytest

How AI Fits Into the Workflow

The application uses AI to assist with organization suggestions. Those suggestions then go through an approval workflow before file operations are executed.

This separation is important: an AI-generated recommendation shouldn't automatically become an unrestricted operation on someone's filesystem.

I also implemented demo-mode restrictions to keep the hosted application's file operations within its designated sample workspace.

Building SlothDesk AI helped me understand that an AI application is about much more than connecting a model to a user interface. It also requires backend validation, testing, controlled file operations, and a workflow that users can trust.

Why Does Open Innovation Matter?

Open innovation makes it possible for developers to experiment with AI beyond relying entirely on closed, hosted APIs.

Using Gemma 2B with Ollama for local inference gave me the opportunity to explore how an open-weight model can fit into a practical developer tool.

Here's why that matters:

More control: Developers can experiment with where and how inference runs.
Local experimentation: Model inference can run on a developer's own machine when the required model and resources are available.
Learning by building: You can explore the entire workflow, from model output to backend validation and human approval.
Freedom to experiment: Developers can adapt the application and experiment with different models and approaches.

Open models don't automatically solve privacy, security, or deployment challenges. Those still require careful engineering. But they give developers more flexibility to learn, experiment, and build useful tools.

For me, this project was an opportunity to bring open-weight AI into an everyday problem rather than building just another chatbot.

My Agent Session

For this project, I focused on implementing and testing the application workflow, including file-operation safeguards and automated tests.

I haven't included a shareable DevRelay agent session in this submission.

The Lazy Payoff 🦥

The payoff I'm aiming for is less repetitive file sorting and fewer manual decisions.

Instead of deciding where every file belongs individually, users can review a set of suggestions and approve the actions that make sense.

I haven't measured a reliable time-saving figure yet, so I won't invent one. Measuring the time required for manual organization versus the AI-assisted workflow is a useful next step.

Because being lazy is fun. Building something that genuinely saves time is even better. 😄

Final Thoughts

SlothDesk AI started with a simple question:

What if organizing a messy folder felt more like reviewing a helpful assistant's plan than doing all the work yourself?

Building this project gave me hands-on experience with open-weight AI, local inference, full-stack development, testing, and safer AI-assisted automation.

The application is now live, and I'm excited to keep improving it.

If you try it, I'd love to hear your feedback. What would make file organization easier for you?

⭐ Try it: https://slothdesk-ai.onrender.com

💻 Explore the code: https://github.com/tashu031/SlothDesk-AI

Build thoughtfully. Automate carefully. Take it slow. 🦥

devchallenge #hf26challenge

DukaanPilot AI: Less Paperwork. More Profit. 🚀

Tashu Gupta — Wed, 14 Oct 2026 14:52:11 +0000

An AI-powered business assistant built for small businesses, homepreneurs, and social-commerce sellers.

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

🔗 Live Demo: https://dukaanpilot-ai.onrender.com

💻 GitHub Repository: https://github.com/tashu031/DukaanPilot-AI

💡 What I Built

Small business owners often manage orders, expenses, invoices, inventory, and customer payments manually. Keeping everything organized can become time-consuming, especially for people running a business alongside their studies or other work.

DukaanPilot AI is a business management platform designed to simplify these everyday operations. It brings essential business tools together in one dashboard and provides data-grounded AI assistance to help sellers understand their business performance.

The goal is simple: less paperwork, better visibility, and more time to grow your business.

✨ Key Features

📊 1. Financial Dashboard

Track total revenue, recorded expenses, estimated profit, and pending payments.
View revenue and expense trends.
Identify low-stock products and business recommendations.

📦 2. Order Management

Create and manage customer orders.
Track order and payment statuses.
Organize customer and product information in one place.

🧾 3. Invoice Management

Generate invoices linked to customer orders.
View invoice details, payment status, and due dates.
Open print-friendly invoices and save them as PDFs.

💰 4. Expense Tracking

Record business expenses by category.
View spending breakdowns.
Understand where business costs are concentrated.

🤖 5. AI Business Assistant

Ask questions about top-selling products, revenue, expenses, pending orders, payments, and inventory.
Get responses grounded in stored database records for supported business queries.
Receive practical suggestions based on recorded business data.

📝 6. AI-Assisted Order Parsing

Convert seller messages into structured order details.
Extract information such as customer name, product, quantity, price, order status, and payment status.
Use a deterministic rule-based fallback when local AI inference is unavailable.

📉 7. Inventory Monitoring

Track stock quantities and safety thresholds.
Identify products that need restocking.

⚙️ 8. Store Settings

Manage business profile information and store preferences.

🛠️ Tech Stack

Frontend

React 19
TypeScript
Vite
Tailwind CSS v4

Backend

Python
FastAPI
Pydantic
SQLite

Gemma through Ollama for local inference
Deterministic rule-based processing and business intelligence as a fallback

Deployment and Development

Git and GitHub
Render
REST APIs

🏗️ How It Works

Business owners record orders, expenses, and inventory information.
The FastAPI backend processes requests and stores business data in SQLite.
Analytics services calculate revenue, expenses, estimated profit, payment dues, and product performance from recorded records.
The AI assistant uses deterministic database-grounded responses for supported queries and can use Gemma through Ollama when the local inference service is available.
The React frontend presents the results through dashboards, management pages, and the AI assistant.

The focus is on making business information easier to access without requiring sellers to maintain multiple disconnected spreadsheets.

🎯 Who Can Benefit?

DukaanPilot AI is designed with these users in mind:

Home-based business owners
Handmade jewellery and craft sellers
Instagram and social-commerce entrepreneurs
Small boutique owners
Students building a side hustle
Micro-businesses that need a simpler way to manage daily operations

🚀 Try the Project

🌐 Live Application: https://dukaanpilot-ai.onrender.com

📂 Source Code: https://github.com/tashu031/DukaanPilot-AI

Explore the dashboard, review the available demo records, test order and invoice workflows, and ask the AI assistant questions about the recorded business data.

Note: The deployed application uses shared public demo data. Please do not enter private customer information or sensitive financial details. Gemma inference depends on local Ollama availability; the deterministic fallback supports the deployed demo.

🧠 What I Learned

Building DukaanPilot AI helped me work across frontend development, backend API design, database operations, business analytics, AI-assisted data extraction, and deployment.

It also reinforced an important lesson: AI-powered business tools should distinguish between verified database facts and generated suggestions. Financial figures should come from recorded data rather than invented estimates.

🔮 What's Next?

Some areas I would like to explore further include:

User authentication and isolated business workspaces
More robust invoice and payment workflows
Improved order extraction and validation
Additional analytics and business reports
More flexible AI integrations and testing

🙌 Built for the Side Hustle Spirit

A side hustle should be about creating value—not spending all day managing paperwork.

With DukaanPilot AI, I wanted to build something practical that brings business operations and AI assistance closer together for small sellers.

If you explore the project, I would love to hear your feedback!

⭐ Check out the repository: https://github.com/tashu031/DukaanPilot-AI

🌐 Try the live demo: https://dukaanpilot-ai.onrender.com

Hacktoberfest #DevChallenge #SideHustle #AI #OpenSource #Python #React #FastAPI

TrailMind AI: Your AI Should Help You Leave the Screen

Tashu Gupta — Wed, 07 Oct 2026 14:18:13 +0000

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

What I Built

What if the best thing an AI could do was not keep you on your screen, but help you put it down?

That is the idea behind TrailMind AI.

TrailMind is an offline-first outdoor adventure companion that uses open-weight AI to turn ordinary outdoor time into small, meaningful adventures.

Instead of asking an AI to generate more content for you to consume, TrailMind asks a different question:

What can AI help you do in the real world?

You can tell TrailMind where you are, what kind of experience you want, and how much time you have. It can then turn that into an outdoor mission — such as a walk, exploration activity, nature observation challenge, or mindful outdoor experience.

The core loop is simple:

Plan → Go Outside → Observe → Record → Reflect

TrailMind includes:

Outdoor adventure recommendations
Walking and exploration route generation
Nature observation challenges
Offline adventure checklists
Observation, photo, and note recording
Nature Detective experiences
Adventure Journals
Outside Score
Demo Mode for quickly exploring the application
Offline fallback when an AI runtime is unavailable

The application is designed for students, developers, families, travelers, and anyone who wants technology to encourage real-world activity instead of replacing it.

TrailMind is deliberately designed around a different kind of AI experience:

The goal is not to keep you chatting with the AI. The goal is to give you a reason to stop chatting and go outside.

Demo

Live Application

Launch TrailMind AI

The production application is deployed on Render with a separate frontend and FastAPI backend.

The easiest way to experience TrailMind is:

Open the application.
Choose Start an Adventure.
Select an outdoor activity.
Generate your adventure mission.
Take the mission outside.
Complete the observation and checklist activities.
Record your observations.
Finish the adventure.
Generate your Adventure Journal.
Check your Outside Score.

For judges and anyone exploring the project remotely, Demo Mode provides a quick way to experience the product without needing to physically visit a location.

The important part of the experience is what happens after the screen:

Open TrailMind → Get your mission → Put the phone away → Explore.

Code

The complete project is open source on GitHub:

TrailMind AI — GitHub Repository

The repository contains the complete frontend and backend implementation, AI provider architecture, offline fallback system, adventure workflows, journals, Nature Detective, tests, and deployment configuration.

The project is structured so that the AI layer can evolve without rebuilding the entire application around a single provider.

How I Built It

TrailMind is built as an offline-first web application with a provider-based AI architecture.

The main open-weight AI integration is Google Gemma, running locally through Ollama.

The architecture looks like this:

User
↓
TrailMind Frontend
↓
FastAPI Backend
↓
AI Provider Layer
├── Local Gemma + Ollama
├── Optional hosted AI provider
└── Offline Rule Engine

This separation was an important design decision.

Instead of making the entire product dependent on one proprietary AI API, the application treats AI as a replaceable capability.

Open-Weight Gemma

Gemma is used as the open-weight AI layer for generating outdoor adventure experiences.

With the local setup, users can run Gemma through Ollama and experiment with AI-powered adventure generation without requiring every interaction to be sent to a closed third-party service.

This also makes the project easier to experiment with because the model and AI provider can evolve independently from the rest of the application.

Offline-First Architecture

The outdoors is not always the best place for a reliable internet connection.

That created an interesting engineering requirement:

What happens if the AI is unavailable exactly when the user is outside?

Instead of making the application fail, TrailMind includes an Offline Rule Engine.

When a live AI runtime is unavailable, the application can still provide deterministic outdoor experiences and continue the core workflow.

Users can still:

Create an adventure
Follow an outdoor checklist
Complete a mission
Record observations
Create journal entries
Track their Outside Score

This means connectivity is not treated as a requirement for the core outdoor experience.

Technology Stack

Frontend

React
Vite
TypeScript
Tailwind CSS
Progressive Web App capabilities

Backend

Python
FastAPI
Pytest

Google Gemma
Ollama
Provider-based AI architecture
Offline Rule Engine

Data

Local/in-memory fallback
Optional MongoDB Atlas integration

Deployment

Render

Render Deployment

TrailMind's production frontend and FastAPI backend are deployed on Render.

Render is not simply mentioned as a deployment option — it is part of the actual production architecture of the project.

There is one important distinction I want to make clear.

The public Render environment cannot access the local Ollama runtime used during development. Therefore, the deployed application currently uses TrailMind's Offline Rule Engine when local Gemma inference is unavailable.

The local development setup can run Gemma through Ollama, while the production deployment remains functional through the offline fallback.

I chose to make this behavior explicit because transparency about AI infrastructure is important.

Why Does Open Innovation Matter?

The idea of TrailMind depends heavily on the possibilities created by open AI.

A traditional closed-API approach could certainly generate outdoor suggestions.

But open-weight AI enables something more interesting.

Privacy

Local inference gives users the possibility of processing their AI interactions on their own machine instead of sending every interaction to a third-party AI provider.

For an application involving personal routines, locations, observations, and journals, that can be meaningful.

Control

TrailMind does not have to be permanently tied to one AI provider.

The application can work with:

Local Gemma
Another compatible AI provider
Or no live AI service at all

The outdoor experience itself remains intact.

Resilience

An application that depends entirely on a remote AI API can become unusable when connectivity disappears.

TrailMind takes the opposite approach.

The AI layer can disappear temporarily without taking the entire outdoor experience with it.

The user can still complete the core mission and record their experience.

Experimentation

Open-weight models make experimentation much more accessible.

Developers can run models locally, experiment with prompts, compare models, change the AI layer, and understand more about how the system behaves.

For TrailMind, open innovation is therefore not just about avoiding a proprietary API.

It enables a different product philosophy:

AI should be a facilitator of real-world experiences, not the destination.

Technical Highlights

AI Provider Architecture

TrailMind separates the application logic from the AI provider.

This makes it possible to experiment with different AI runtimes without rewriting the core application.

The architecture supports local open-weight AI while retaining a deterministic fallback.

Nature Detective

The Nature Detective feature is designed to make users pay attention to their surroundings.

Instead of simply telling someone where to go, TrailMind can turn the environment itself into part of the experience.

A normal walk can become an observation challenge.

Adventure Journal

After an adventure, TrailMind can turn the user's observations and experience into an Adventure Journal.

This creates a natural closing loop:

Explore → Observe → Reflect

The AI is therefore used not only before the outdoor experience, but also to help users reflect on what they actually experienced.

Outside Score

TrailMind also includes an Outside Score.

The intention is not to turn outdoor time into another addictive metric.

Instead, it provides a lightweight way to recognize completed outdoor activities and encourage continued participation in the real world.

Demo Mode

Because judges and users may not be physically near the same location, TrailMind includes Demo Mode.

This makes the complete product flow easier to evaluate while preserving the real-world purpose of the application.

Testing

Before deployment, I validated both the frontend and backend.

The frontend production build completed successfully with:

1592 modules transformed

Frontend automated tests:

2 test files passed — 6 tests passed

Backend automated tests:

11 tests passed

The deployed FastAPI backend also exposes a health endpoint for production verification.

The application was then tested through the deployed environment to verify the main user workflows.

What I Learned

The most interesting lesson from building TrailMind was that adding AI does not always mean making the AI do more.

Sometimes the better question is:

What should the AI help the user do next?

For many AI applications, the answer is:

"Ask another question."

For TrailMind, the answer is:

Go outside.

That changed the architecture of the project.

It influenced the offline-first approach, the provider-based AI layer, the adventure workflow, and even the way the interface is designed.

The AI is intentionally not the destination.

It is the starting point for a real-world activity.

Future Improvements

There are several directions I would like to explore next:

Better local Gemma models for different devices
More advanced local route generation
Richer nature observation workflows
Better offline maps
Voice-guided outdoor missions
More personalized adventure recommendations
More accessibility features
Community-created outdoor missions
Support for additional open-weight models
More advanced local AI capabilities

The long-term vision is to build a platform where AI helps people interact more with the physical world rather than spending more time inside a digital one.

Prize Categories

Render

TrailMind AI is deployed on Render using a separate production frontend and FastAPI backend.

Render is part of the actual deployment architecture of the project.

Gemma

TrailMind integrates Google's open-weight Gemma model through a local Ollama runtime.

Gemma forms the open-weight AI layer for generating outdoor adventure experiences, while the Offline Rule Engine keeps the application functional when local AI inference is unavailable.

Final Thoughts

We are building AI systems that can answer almost anything.

But perhaps one of the most useful things an AI can tell us is something much simpler:

You've been on the screen long enough. Go touch grass. 🌱

That is the idea behind TrailMind AI.

Not another AI that asks you to stay.

An AI that gives you a reason to leave.

Plan less. Explore more.

Project: TrailMind AI

Live Demo: Launch TrailMind AI

Challenge: Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass

Built with: React • FastAPI • Google Gemma • Ollama • Render

Study Buddy

Tashu Gupta — Sat, 03 Oct 2026 19:59:47 +0000

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

What I Built

I built StudyBuddy — a simple, unified, and distraction-free study companion designed to help my close friend stay calm, focused, and confident during intensive study sessions.

🚀 Live Demo: https://tashu031.github.io/StudyBuddy/

💻 GitHub Repository: https://github.com/tashu031/StudyBuddy

Who I Built It For & The Problem It Solves

My friend has been cramming for software engineering interviews and university exams. Like many learners, they were constantly fighting against modern "study app fatigue":

Bloated Subscriptions & Paywalls: Everyday flashcard apps have started locking basic features like quiz modes, dark mode, or offline review behind pricey monthly paywalls.
Context-Switching Chaos: They were juggling three separate browser tabs: a random web Pomodoro timer, a flashcard app, and a practice quiz site.
Distraction & Data Tracking: Popups, login screens, streaks that induce anxiety, and ad banners constantly break deep work flow.

StudyBuddy solves this by unifying the entire study routine into a single, light-weight, zero-friction app that works completely offline:

⏱️ Pomodoro Clock: A visual circular timer with 25m Focus, 5m Short Break, and 15m Long Break intervals, customizable durations, task goal setting, and built-in ambient sound generators (Soft Rain, White Noise, Alpha Focus Waves).
🗂️ Interactive 3D Flashcards: Smooth flip animations, card mastery progression (Mastered vs Still Learning), deck management, and keyboard shortcuts (Space, ←, →, 1, 2).
📝 Dynamic Quiz Generator: Automatically transforms flashcards from any deck into randomized 4-option multiple-choice quizzes with smart distractor generation and instant feedback.

No sign-ups, no monthly fees, no tracking — just pure, peaceful focus.

Demo

🚀 Live Deployed App (GitHub Pages): https://tashu031.github.io/StudyBuddy/
💻 Local Execution: Run locally via start.bat or python -m http.server 3000 (http://localhost:3000)
📹 Walkthrough / Screenshots:

Key Highlights

100% Offline Audio: Uses the browser's native Web Audio API to synthesize peaceful completion chimes and ambient sound frequencies in real-time — zero external MP3 downloads required!
Local Persistence: All custom flashcards, decks, session streaks, and quiz high scores are stored securely in localStorage.
Keyboard-First Navigation: Study with rapid keyboard flow without touching your mouse.

Code

GitHub Repository: https://github.com/tashu031/StudyBuddy

tashu031 / StudyBuddy

🎓 StudyBuddy App

🚀 Live Demo: https://tashu031.github.io/StudyBuddy/
💻 GitHub Repository: https://github.com/tashu031/StudyBuddy

A simple, beautiful, and distraction-free study companion with a Pomodoro Timer, interactive Flashcards, and an automatic Knowledge Check Quiz.

✨ Features

1. ⏱️ Pomodoro Focus Timer

Preset Modes: Focus (25m), Short Break (5m), and Long Break (15m).
Smooth Visual Countdown: Circular SVG progress ring with minute/second digital display.
Audio Chimes: Pleasant synthesized tones via Web Audio API (100% offline, zero audio file dependencies).
Session Goals: Set your current study task and check it off when accomplished.
Ambient Focus Noise: Built-in sound generator for Soft Rain, White Noise, or Focus Alpha Waves to help block distractions.

2. 🗂️ Interactive 3D Flashcards

Flip Animation: Click or press Spacebar / F to flip cards between question and answer.
Mastery Tracker: Mark cards as Mastered (green check) or Still Learning (amber…

View on GitHub

The project is built entirely with clean, vanilla web technologies for longevity and lightning performance:

index.html: Accessible, semantic markup structure for tabbed productivity views.
styles.css: Modern CSS design system featuring CSS Custom Properties, 3D flip card transformations, circular SVG countdown math, and adaptive Dark/Light themes.
app.js: Modular state-driven JavaScript containing the timer cycle engine, Web Audio frequency synthesis, deck CRUD logic, and algorithmic multiple-choice distractor generation.

How I Built It

To bring StudyBuddy from concept to a polished, ready-to-run tool in a single weekend, I leveraged an autonomous agentic pair-programming workflow powered by Google DeepMind's Antigravity agent harness and cutting-edge open AI tools:

Architecture & Rapid Scaffolding:
- Guided by agentic workflows, we structured the app into three cohesive pillars (Timer, Flashcards, Quiz) ensuring they shared a reactive state and local storage layer.
Offline-First Audio Engineering:
- Rather than relying on third-party audio CDNs that fail without internet access, we utilized the agent to synthesize harmonic sine-wave chimes and pink/white noise filters using the native AudioContext pipeline.
Algorithmic Quiz Generation:
- Built a dynamic distractor selection algorithm that takes any flashcard deck, extracts answers from peer cards to act as plausible multiple-choice options, and ensures every question remains challenging and educational.
Zero-Build Deployment:
- Kept the stack strictly dependency-free (no complex build tools, node_modules overhead, or bundle steps) so anyone can open index.html or double-click start.bat and run it instantly on any device.

Why Does Open Innovation Matter?

Open innovation is what ensures technology remains a public good rather than a gated tollbooth.

For educational software in particular, open innovation matters because:

Equitable Access to Learning: A student in a remote area with spotty internet or limited financial resources should never be locked out of essential recall and focus tools. Open tools guarantee that anyone can inspect, host, modify, and benefit from the software offline.
Longevity & Data Sovereignty: Proprietary SaaS study apps frequently shut down, pivot, or hold user notes hostage behind paywalls. Building with open standards ensures notes and flashcard decks belong to the user forever.
Collaborative Evolution: With open innovation, educators and developers across the world can fork StudyBuddy to add language decks, spaced-repetition algorithms (like SM-2), or custom audio soundscapes without asking for permission.

My Agent Session

StudyBuddy was designed and developed through an autonomous agentic pair-programming workflow with AI. During the development session, the agent and I designed the complete user journey, tested the SVG progress stroke calculations, fine-tuned the 3D card perspective matrix, and verified offline audio synthesis in real time.

Prize Categories

Build for a Friend (Primary Category)
Open Source / Local-First Productivity & Education

Built with passion by @tashu031