DEV Community: Disha Khanapurkar

There’s a Snarky Dead Guy Trapped in My Laptop, and He Has Opinions About My Stack Trace!

Disha Khanapurkar — Sat, 31 Oct 2026 06:30:51 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

Meet PolterPaste — a desktop ghost that lives rent-free in your operating system's clipboard.

Every time you copy a piece of text, code, or a messy stack trace, a snarky 19th-century aristocrat named Lord Bartholomew Blackwood pops up on your screen to judge your choices with effortless Victorian sarcasm. No old dusty English—just sharp, witty roasts delivered via a semi-transparent, gothic floating UI.

Demo

Suppose you make a small error and copy it to perhaps debug it:

No one can escape Lord Bartholomew's perfect taunt:

Well, if you try to reason out, he's got a witty replies up his sleeve!

Code

Here is the core engine behind the haunting. You can check out the full repository on GitHub: [https://github.com/tan-byte/lord_bartholomew/]

import time
import tkinter as tk
import pyperclip
from google import genai

# Initialize the Gemini client with your API key
client = genai.Client(api_key="YOUR_ACTUAL_API_KEY_HERE")

def get_ghost_commentary(copied_text):
    # The snarky Victorian persona prompt
    prompt = (
        "You are Lord Bartholomew Blackwood, a snarky Victorian ghost trapped "
        "inside this laptop. You speak with crisp, effortless aristocratic "
        "sarcasm—sharp, witty English that cuts deep. Look at what the mortal "
        "just copied and give a 1-to-2 sentence biting, theatrical roast of their "
        "code or life choices. Keep it punchy and utterly unimpressed. Text copied: "
        f"'{copied_text}'"
    )

    try:
        # The crucial AI interaction point using the official Google GenAI SDK
        response = client.models.generate_content(
            model="gemma-2-9b-it",
            contents=prompt,
        )
        return response.text.strip() if response.text else "The ghost stares in silence."
    except Exception as e:
        return f"The spirit's connection to the cloud severed: {e}"

How I Built It

PolterPaste brings together three simple layers to create the illusion of a haunted machine:

The Clipboard Watcher: Built using pyperclip running in a lightweight background while loop that polls clipboard changes every 1.5 seconds.
The Intelligence Layer: Powered by the official google-genai SDK (gemini-3.8-flash), which transforms raw, boring copied text into personalized theatrical roasts using structured system instructions.
The Gothic UI: A custom, borderless, semi-transparent floating window built with Python's native tkinter featuring dark styling (#0d0d0d), a scrollbar for longer rants, and a click-to-dismiss behavior so it stays until you acknowledge your digital sins.

Why Does Open Innovation Matter?

Building lightweight desktop agents like this highlights why accessible, open-developer tooling is so powerful. Being able to plug a cutting-edge cloud model directly into local system utilities like the clipboard with just a few lines of Python opens up endless possibilities for creative, whimsical, and borderline unhinged developer tools that completely change how we interact with our operating systems!

Prize Categories

Best use of Gemma
Ghost in the Machine

P.S: The best response so far:

A buddy that helps you before procrastination gets you.

Disha Khanapurkar — Sun, 25 Oct 2026 17:41:29 +0000

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

What I Built

SlothGuard is an ambient local agent that quietly watches your screen and only speaks up when you appear stuck.
Most AI tools force you to break focus: select text, switch windows, write a prompt, and wait.
SlothGuard flips that. It runs in the background, takes low-resolution screenshots every few seconds, and detects when the screen has barely changed for a while (you’re staring at the same error, the same docs, or the same failing test). When that happens, it asks a local open-weight model for one short, calm tip and speaks it through local text-to-speech. Then it goes silent again.
It exists so developers (especially the ones coding late at night) can stay a little lazier. You don’t have to notice you’re stuck. You don’t have to decide to ask for help. The agent notices the stagnation and offers a gentle nudge only when it might actually be useful.

Demo

 https://github.com/tan-byte/slothguard

How I Built It

SlothGuard was built entirely around local, open-source AI. Rather than utilizing a closed API, every component was picked with privacy, offline capability, and customizability in mind.

Tech Stack

Component	Tool(s) Used	Purpose
Screen Capture	`mss` + `Pillow`	Fast, cross-platform, and low-resolution captures to minimize CPU usage.
Stagnation Detection	`scikit-image` (SSIM)	Compares perceptual similarity between grayscale, downscaled frames to detect when the screen has stayed nearly identical.
Local Inference	Ollama with `moondream` (preferred) or `gemma2:2b`	Generates a short, context-aware tip based off of the "stuck" signal. Vision capable models can utilize a cropped screenshot for better context.
Text-to-Speech	Piper TTS (`en_US-lessac-medium`)	Completely offline, neural TTS to audibly deliver the tip.
On-Screen Overlay	`tkinter`, `ctypes`, and Windows MessageBox fallbacks	A non-blocking, always-on-top popup to display the tip alongside audio for better visibility.
Orchestration	`Python 3.10+`, `PyYAML`, `NumPy`, `Requests`	Config loading, timing, cooldowns, and API calls to the local Ollama instance.

Architecture & Implementation Details

Heuristic First: The detection logic is entirely local. SSIM is ran against downscaled, grayscale frames, only triggering an intervention if similarity is above the threshold for a configurable amount of time (~90 seconds by default).
Model-Centric Tips: The heuristic only answers "Has this screen changed?". The open-weight model is responsible for answering "What should I say?". A constrained system prompt is fed to Ollama alongside an optional screenshot, forcing it to output one short, calm, and non-judgemental tip.
Non-Blocking Design: Model generation, TTS, and overlays all run asynchronously or in their own processes, allowing the capture loop to resume without stalling.
Resilient Fallbacks: If Piper isn't installed, it will gracefully print to console. If the overlay fails to initialize, it will fall back to a system message box or a highly visible console output, ensuring the tip is always delivered.
Fully Configurable: All timings, thresholds, models, and cooldown ranges are exposed through config.yaml, allowing for easy tuning between "real use" and "demo" modes.
Cooldown System: After each intervention, a randomized cooldown (5-8 minutes by default) is applied to prevent nagging, embodying the "only when useful" philosophy.

The open-weight model isn't an optional add on for this project, it's the core. Without it, SlothGuard would only be a timer playing a static message. With it, a generic "stuck" signal is transformed into a contextually relevant nudge.

Why Does Open Innovation Matter?

A closed API version of SlothGuard would require sending screenshots containing my actual code, stack traces, terminal output, and debugging sessions to a third-party server. For something designed to run all day in the background, this was a non-negotiable privacy concern.

Utilizing open-weight models locally allows for the following benefits:

True Privacy: All data is processed on-device. Screenshots, prompts, and tips never leave the machine.
Offline Reliability: It works anywhere. Trains, cafes with spotty Wi-Fi, or late nights with flaky internet are all a non-issue.
Zero Marginal Cost: Once the model is pulled, SlothGuard can run for hours on end with no tokens, rate limits, or API fees to worry about.
Freedom to Tinker: Anyone can swap models, iterate on the system prompt, tweak detection thresholds, or extend functionality without permission, paywalls, or vendor lock-in.

This level of autonomy, privacy, and flexibility is only possible due to the open-weight ecosystem and the tools that allow for local inference.

The Lazy Payoff

The value of SlothGuard isn't measured by saving minutes on a singular task, it's measured by removing the miniscule bits of friction that add up over the course of a day.

Traditionally, to get help when stuck, you have to go through a loop of: noticing you're stuck, deciding it's worth breaking flow for, switching contexts to ask an AI, formulating a prompt, and returning to your work.

SlothGuard cuts all of these steps out. By the time your brain registers that you've been circling the same bug for far too long, there's already a gentle, local tip being spoken to you. It's not about automating the solution, it's about automating the moment of asking for help. Less self-monitoring, less activation energy, and just a tiny nudge exactly when it's needed. That is the lazy payoff.

Shakti: Turning Everyday Vegetable Orders into a Smarter Side

Disha Khanapurkar — Sun, 18 Oct 2026 18:17:44 +0000

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

Shakti 🌱 — A Small Business Assistant Built for the People Who Need It Most

What if a vegetable seller could manage customer orders, track stock, and prepare WhatsApp messages without spending hours doing everything manually?

Not every small business has the budget for expensive software. Some sellers manage their entire business through handwritten notes, memory, and WhatsApp conversations.

I wanted to build something that could make their day a little easier.

That's how Shakti started.

What I Built

Shakti is an AI-powered business assistant designed for small vegetable sellers who want to spend less time managing orders and more time running their business.

Here's what it brings together:

🥦 Stock management: Keep track of available vegetables and quantities.
💬 Natural-language order parsing: Turn informal customer messages into structured order previews.
🌍 Multilingual interaction: Designed for everyday messages in Marathi, Hindi, English, and transliterated Marathi.
👥 Customer management: Maintain customer details and order history.
📱 WhatsApp-ready messages: Prepare personalised customer messages with click-to-send links.
✅ Seller confirmation: Review extracted items and quantities before confirming an order.

Imagine receiving a message like:

"Udya 2 kilo tomato ani 1 kilo kanda pathva."

Instead of manually interpreting and rewriting the order, Shakti is designed to extract the items and quantities into a structured preview that the seller can review.

The goal isn't to replace the seller's judgement. It's to remove repetitive work.

Who could pay for it?

Independent vegetable vendors, home-based sellers, and small produce businesses that need a lightweight way to organise orders and communicate with customers.

A future business model could be a free basic tier with paid features for higher order volumes, reports, and advanced customer management.

Demo

🎥 Watch Shakti in action:
At https://github.com/DishaKhanapurkar/shakti
Or
https://drive.google.com/file/d/136YrImOoEITWwG1fJPeSJeUEOGMeXXco/view?usp=sharing

Code

💻 GitHub repository: https://github.com/DishaKhanapurkar/shakti

Built with open-source tools and designed to be practical, understandable, and extensible.

How I Built It

Shakti uses a Python backend built with FastAPI and SQLite, with a lightweight HTML, CSS, and JavaScript dashboard.

The AI integration is built around Gemma 3 1B Instruct, Google's open-weight model, using Hugging Face Transformers.

Here's the architecture:

Frontend: A dashboard for stock, customers, and order previews.
Backend: FastAPI endpoints handle inventory, customer data, and order workflows.
Database: SQLite stores the application's business data.
AI layer: Gemma is integrated to interpret natural-language orders and return structured information.
Fallback parsing: A rule-based parser provides a simpler alternative when AI parsing is unavailable.
Human-in-the-loop workflow: The seller reviews the result before an order is confirmed.

One design decision matters here: language models can misinterpret quantities, item names, or informal messages. That's why the order workflow includes seller review instead of treating every AI-generated result as automatically correct.

For a small business, a confident-looking mistake can be more expensive than a little extra manual work.

Why Does Open Innovation Matter?

For Shakti, open innovation is about more than using a different model.

It's about making useful AI more adaptable to real-world needs.

1. Language is part of the product.

Customers don't always write polished English. They use regional languages, abbreviations, mixed-language messages, and transliterated text. An open-weight model gives developers room to experiment with prompts, evaluation examples, and model configurations for these situations.

2. Developers have more control over the AI layer.

Using Gemma through Transformers gives the project a model integration that can be inspected, tested, and adapted. It also creates the possibility of running inference locally after the model is downloaded, depending on the deployment and available hardware.

3. Cost matters to small businesses.

A tool for a small vendor needs a realistic path to affordable operation. Open-weight models give developers more flexibility to evaluate hosting costs, local inference, and deployment options instead of depending entirely on a closed AI API.

4. Open tools make experimentation accessible.

FastAPI, SQLite, and Transformers make it possible to build and iterate on the complete application without starting with an expensive infrastructure stack.

The bigger idea is simple: useful AI shouldn't be limited to businesses that can afford a large software budget.

What I Want to Improve Next

Shakti is a starting point, not a finished business platform.

My next priorities are to test order extraction against a representative set of Marathi, Hindi, English, and mixed-language messages; measure how often the model correctly identifies products and quantities; and gather feedback from actual sellers.

I'd also like to explore voice-based ordering and better inventory suggestions.

The most important metric won't be how impressive the AI sounds. It will be whether a seller can complete everyday work with fewer mistakes and less effort.

Prize Categories

Best Use of Gemma — for the Gemma-based natural-language order parsing integration.

Thanks to the Hacktoberfest team and the open-source AI community for encouraging developers to build tools around real problems, not just demos.

If you run a small business or know someone who sells vegetables, I'd love to hear from you:

What's the most repetitive task in your business that you'd want AI to take off your hands?

GadMitra: An AI companion to explore the Sahyadris 🌿

Disha Khanapurkar — Sun, 11 Oct 2026 16:56:06 +0000

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

What I Built

We spend hours looking at screens, watching travel reels, saving trekking destinations, and telling ourselves we'll explore them someday.

I wanted to build something that could turn that someday into a small adventure.

Meet GadMitra — a companion for exploring Maharashtra's Sahyadri forts, discovering local heritage, and finding reasons to step outdoors.

The idea is simple: choose a fort, tell GadMitra how much time you have, and get an outdoor quest to try. It could be a short exploration, noticing details in an old fort, or taking a moment to appreciate the landscape around you.

Here's what the current prototype includes:

🏞️ Fort discovery: Explore forts through photo-rich cards.
🧭 Quest generation: A backend-powered flow for generating outdoor activities based on your selection and preferences. AI generation is still being worked on.
🎉 Quest completion: Mark a quest complete and celebrate with a confetti animation.

I'm also exploring photo-based quest verification, an AI companion for questions about forts and nature, and adventure collages people can share after their trips.

The goal isn't to make people spend more time in another app. It's to give them a reason to put their phones away and experience the world around them.

Demo

Screenshots and demo video:

Screen Recording 2026-10-11 221611.mp4 - Google Drive

drive.google.com

I'll share a walkthrough of the fort selection, quest flow, and completion celebration here.

Code

GitHub repository: https://github.com/DishaKhanapurkar/GadMitra

Built with Angular, FastAPI, and Python.

How I Built It

GadMitra uses Angular for the frontend and FastAPI for the backend.

The frontend lets users explore forts, select a destination, and interact with the quest flow. The backend exposes API endpoints for fort information and quest requests.

I also experimented with Hugging Face Inference Providers for AI-powered quest generation. I ran into a practical challenge: the available inference credits were exhausted, so I still need to resolve the model-inference setup.

Rather than hide that limitation, I'm treating it as part of the learning process. I want to make the AI component reliable and accessible without making the entire outdoor experience dependent on a paid API.

Why Does Open Innovation Matter?

Outdoor exploration shouldn't need an expensive subscription or a complicated setup.

Open-source tools make it possible to experiment with AI, understand how the pieces fit together, and adapt the experience to local needs.

For GadMitra, that means building around a place and culture I want to highlight: Maharashtra's forts and the Sahyadri landscape.

It also means other developers can contribute new forts, improve quest generation, add languages, or build features that make outdoor exploration more accessible.

I'd love to see this grow beyond a prototype into something that helps more people discover the places around them.

My Agent Session

Optional — I'll add a DevRelay session link if I capture one.

Prize Categories

No additional partner prize category claimed at this stage.

GadMitra 🌿 — A little less scrolling. A little more exploring.

What would get you outdoors more often: discovering hidden places, learning local history, or completing small nature quests?