DEV Community: Tanishka Khanapurkar

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

Tanishka Khanapurkar — Fri, 30 Oct 2026 12:49:59 +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.

Tanishka Khanapurkar — Sat, 24 Oct 2026 18:34:56 +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.

Local Invoice & Receipt Sorter: A Privacy-First Side Hustle Tool

Tanishka Khanapurkar — Thu, 15 Oct 2026 12:14:04 +0000

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

What I Built

I built a local receipt and invoice parser designed specifically for freelancers and small business owners. It takes messy PDF invoices or snapshots of paper receipts, extracts structured data (vendor name, line items, totals, dates), and organizes them into neat CSV summaries—all running 100% locally on your machine.

Freelancers would pay for this because it saves hours of tedious bookkeeping at tax season while guaranteeing that sensitive financial data and client details never get sent to third-party cloud APIs.

Code

// Core local processing logic snippet
public class InvoiceParser {
    public InvoiceData parseLocally(File invoiceFile) {
        // Runs text extraction and local open-weight inference
        String rawText = extractText(invoiceFile);
        return LocalInferenceEngine.extractStructuredData(rawText);
    }
}

How I Built It

The project is built around open-source AI and local inference models. Instead of relying on closed commercial APIs, it leverages lightweight open-weight models running locally to parse documents securely. The backend handles file processing and data formatting locally without external network calls.

Why Does Open Innovation Matter?

Open innovation and open-weight models are vital for financial and administrative tools. Small businesses and freelancers handle sensitive client data, tax IDs, and proprietary pricing sheets. Relying on closed, hosted APIs means uploading confidential financial records to third-party servers. Local open-source models make complete data privacy, offline usability, and zero recurring API costs possible.

My First User

I tested this out with a freelance peer who manages their own design contracts. They loved that they could dump all their monthly PDF invoices into a local folder and get an organized spreadsheet in seconds without worrying about cloud privacy risks.