DEV Community: Keerthana Kasthuril

Ghost In The Machine: Helpful Spirit That Makes You Productive

Keerthana Kasthuril — Wed, 28 Oct 2026 16:55:50 +0000

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

What I Built

I built Spooky Site Blocker, a privacy-first Chrome extension that acts as a productivity tool possessed by a poltergeist.

I wanted to interpret the "Ghost in the Machine" theme literally. Instead of a standard website blocker that just shows a generic "Time's Up!" screen, this extension reads the actual title of the tab you are wasting time on and generates a hyper-specific, sinister message telling you to leave. If you are procrastinating by watching mechanical keyboard reviews, the screen goes pitch black, a ghost appears, and a local AI whispers something like: "The plastic will outlive you, yet your code remains unwritten. This tab is dead."

Demo

Code

keerthanak-tw / spooky-site-bloker

👻 Ghost in the Machine: Local AI Site Blocker

A privacy-first, locally powered Chrome extension built for the Hacktoberfest "Ghost in the Machine" Challenge.

This extension monitors the time you spend on distracting websites. When your time is up, it locks the page with a spooky overlay and uses a local AI model (Gemma) to generate a context-aware, creepy message based on the specific tab you were reading, telling you to get back to work.

🦇 Why Open Innovation Matters Here

A time-tracking extension that actively reads the DOM and titles of your browser tabs is a massive privacy risk if it sends that data to a cloud provider.

By building this with Ollama and the Gemma:2b open-weight model, this project ensures:

Total Privacy: Your browsing habits and tab history never leave your machine.
Offline Capability: The poltergeist in your machine doesn't need an internet connection to haunt you…

View on GitHub

How I Built It

The project is built entirely on local, open-source AI infrastructure:

The Brain: I used the open-weight Gemma:2b model running locally via Ollama.
The Framework: A vanilla JavaScript Chrome Extension using Manifest V3.

The most interesting technical challenge was getting a Chrome extension to talk to a local AI without triggering modern web security blocks. I couldn't just call the Ollama API from the injected content script because websites like GitHub or YouTube have strict Content Security Policies (CSP) that block requests to localhost.

To solve this, I architected a messaging system where the injected content.js scrapes the page context, passes it to the invisible background.js service worker, which then safely makes the fetch() call to the local Gemma model (running with CORS enabled) and sends the creepy response back to the UI.

Why Does Open Innovation Matter?

Open innovation is the only reason this extension is safe to use.

To generate context-aware messages, the extension has to actively read the DOM and titles of your browser tabs. If I had built this using a closed API, I would be streaming my entire browsing history to a third-party cloud server—a massive privacy violation just for a productivity joke.

By utilizing local inference with Ollama and an open-weight model like Gemma, your browsing data never leaves your machine. Plus, it runs perfectly offline. Your Wi-Fi might go down, but the ghost in your machine will still haunt you.

My Agent Session

I utilized an AI agent as a pair programmer to brainstorm the initial concept and navigate the architectural shift required to bypass Chrome's strict Content Security Policies for local API fetching.

The Spirit of It

The real magic of this project is the jumpscare of accountability. There is something deeply unsettling about being 20 minutes deep into a mindless Reddit rabbit hole, only for your screen to lock up and a localized AI to specifically call out the exact topic you are wasting your life on. It transforms a standard productivity tool into something that genuinely feels like the machine is watching you.

How I Used a Local LLM to Never Wash Multiple Pans Again

Keerthana Kasthuril — Fri, 23 Oct 2026 17:58:35 +0000

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

What I Built

I built the Zero-Thought Pantry Chef, a 100% local AI cooking assistant designed to eliminate culinary decision fatigue and minimize cleanup.

While most recipe apps give you complex, multi-step instructions that require a pristine kitchen and an hour of prep, this app is engineered to reward extreme laziness without sacrificing a decent meal. You input whatever random leftovers are in your fridge, and the agent processes them through a strict "Sloth Protocol." It forces the model to generate a meal requiring a maximum of one cooking vessel, limits total prep and cook time to under 20 minutes, allows for minimal quick knife work, and mandates eating directly from the pot or microwave bowl to bypass dishwashing. It intelligently assumes you have basics like salt, spices, and cooking oil, saving exhausted professionals and students from the burden of meal planning.

Demo

Here is a look at the Streamlit UI in action. When I input random staples like yam, rice, and cheese, the Sloth Chef doesn't give me a traditional casserole recipe. Instead, it tells me to chop the yam, microwave it to soften, toss in the rice and cheese with basic seasonings, and eat it straight out of the microwave bowl for a zero-effort Yam and Cheese Bowl.

Code

The entire application runs through a streamlined Python architecture using Streamlit for the frontend and Ollama for local inference.

keerthanak-tw / sloth-chef

🦥 Zero-Thought Pantry Chef

Built for Hacktoberfest 2026: "Reward Laziness" Week (International Sloth Day).

This is a local Python web app that takes whatever leftover ingredients you have in your fridge and generates a recipe requiring the absolute minimum amount of physical effort. It rigidly enforces a "Sloth Protocol": one pot only, zero knife work (tear everything by hand), and eating straight out of the cooking vessel to avoid washing dishes.

🛠️ Stack

Language: Python
UI Framework: Streamlit
Model Runner: Ollama
Model: Llama 3.2 (running 100% locally)

🚀 How to Run

Install Ollama and pull the model: ollama pull llama3.2
Install the Python requirements: pip install -r requirements.txt
Start the application: streamlit run app.py
The app will automatically open in your default web browser at http://localhost:8501.

🌍 Why Open Innovation Matters

This project relies on open-weight models (Llama 3.2) and open-source tooling (Ollama, Streamlit) to work. Running this locally…

View on GitHub

How I Built It

I developed this using Python, Streamlit, and Ollama, executing entirely on my local machine. To accelerate the boilerplate setup, I utilized GitHub Copilot in VS Code, allowing me to focus entirely on prompt engineering and local model orchestration.

The backbone of the project is Llama 3.2, an open-weight model running locally via the Ollama harness. Instead of treating the AI as a broad knowledge base, I utilized strict system prompting to heavily constrain the model's output, forcing it to act as a hyper-efficient filter against physical labor. This approach demonstrates that you don't need massive parameter counts to build highly effective, specialized agents—a localized, 3B parameter model handles instruction-following perfectly when the boundaries are clearly defined.

Why Does Open Innovation Matter?

Relying on open-weight models and open-source local execution makes this project viable in ways a closed API never could:

Absolute Privacy: My dietary habits and pantry contents are processed locally. I am not sending my daily routines to a third-party server.
Zero-Cost Automation: Running inference locally means zero API subscription fees or token anxiety. I can run this app every single day to figure out dinner, and it will remain completely free forever.
True Offline Reliability: Because the entire stack lives on my machine, it works flawlessly without an internet connection. If my mobile network drops or I am entirely offline, the Llama model still executes instantly. You shouldn't need a cloud server just to figure out how to cook your leftovers.

The Lazy Payoff

This tool entirely removes the friction between being hungry and actually eating. By mathematically eliminating measuring and dishwashing while capping prep time at 20 minutes, it saves roughly 15 minutes of recipe scrolling and 15 minutes of post-meal cleanup. I used it to figure out a zero-effort yam and cheese bowl, and sticking to the single-vessel rule meant I was back to relaxing almost immediately.