DEV Community: Utkarsh Yadav

👻 GhostShell AI: A Haunted Terminal Powered by Local AI

Utkarsh Yadav — Thu, 29 Oct 2026 09:05:15 +0000

👻 GhostShell AI: A Haunted Terminal Powered by Local AI

What if your terminal could talk back to you?

For the Hacktoberfest Week 4 challenge, I built GhostShell AI, an experimental haunted-terminal web app that combines a spooky interface with the idea of running AI locally on your own machine.

🔗 GitHub Repository: https://github.com/utkarshydv27/GhostShellAI

👻 What is GhostShell AI?

GhostShell AI turns a regular browser window into a mysterious terminal where you can interact with a fictional digital ghost.

The project explores how local AI can make creative, interactive experiences possible without requiring every conversation to be sent to a cloud-based AI service.

✨ Key Features

Haunted terminal interface: A spooky, terminal-inspired web experience.
Local AI integration: Connects to Ollama for generating responses using a locally running language model.
Ghost whispers: Interact with the ghost through the web interface.
Session memories: Stores conversation records locally in a JSONL file.
Offline fallback: Provides fictional responses when the local AI service is unavailable.
Open-source code: Explore the implementation, run it locally, and contribute improvements.

Note: The offline fallback is simulated; it is not actual AI inference.

🛠️ Tech Stack

Python
Flask
Ollama
HTML, CSS and JavaScript
Pytest for automated tests

🚀 How to Run GhostShell AI

You will need Python and Ollama installed on your computer.

Clone the repository:

git clone https://github.com/utkarshydv27/GhostShellAI.git
cd GhostShellAI

Create and activate a virtual environment on Windows:

py -m venv .venv
.\.venv\Scripts\Activate.ps1

Install the dependencies:

python -m pip install -r requirements-dev.txt

Download the default Ollama model and start the application:

ollama pull qwen2.5:1.5b
python app.py

Open the following address in your browser:

http://127.0.0.1:5000

To run the automated tests, use:

pytest -q

🔐 Privacy and Safety

GhostShell AI is designed as a fictional terminal experience. It does not execute arbitrary shell commands.

When configured with a local Ollama model, AI generation runs through the local Ollama service. Conversation records are stored in the project's local data directory. Review the source code and README before using the application.

💡 Why I Built This

I wanted to explore a creative side of AI development beyond ordinary chat interfaces. GhostShell AI is an experiment in combining local language models, Python web development, and an immersive user experience.

Projects like this also offer an opportunity to learn about local inference, API integration, frontend design, testing, and open-source collaboration.

🤝 Contributions Welcome

Have an idea to make the ghost smarter, the interface creepier, or the code better?

Check out the repository and contribute improvements:

👉 https://github.com/utkarshydv27/GhostShellAI

Bug reports, feature suggestions, documentation improvements, and code contributions are welcome.

🎃 Final Thoughts

GhostShell AI is a small experiment with a simple idea: AI doesn't always need to live in the cloud to create an interesting experience.

I'm continuing to learn, build, and experiment with open-source AI projects. Feedback and suggestions are welcome!

Challenge: Hacktoberfest Week 4 — Ghost in the Machine

Project: GhostShell AI

Repository: https://github.com/utkarshydv27/GhostShellAI

devchallenge #hf26challenge #Python #Ollama #LocalAI #OpenSource #Hacktoberfest

LazyDesk AI: Let Local AI Tidy Up Your Digital Mess

Utkarsh Yadav — Sat, 24 Oct 2026 04:04:53 +0000

What I Built

I built LazyDesk AI, a local-first file organization assistant designed to help people organize their digital workspace with AI-powered category suggestions.

The goal is simple: spend less time sorting files manually and more time doing useful work.

Demo

Try the live prototype here:

https://lazydesk-ai-etdd2s.v2.appdeploy.ai/

The prototype demonstrates file organization workflows, category suggestions, and manual review before choosing a category.

Code

GitHub Repository: Add your public GitHub repository URL here after uploading the project source code.

How I Built It

LazyDesk AI is a web-based prototype designed around a privacy-conscious, local-first workflow.

The project explores using Ollama with an open-weight model such as Qwen 2.5 to generate file-category suggestions locally. The Ollama connection still needs to be configured and tested on the target computer.

The interface includes a sample workspace, category filters, and editable category suggestions. The current prototype does not actually move or rename files on the user's computer.

Why Does Open Innovation Matter?

Open innovation makes AI more accessible to developers who want to learn, experiment, and build without relying entirely on closed platforms.

Open-weight models and local inference offer an opportunity to explore AI workflows while keeping sensitive file information on a user's own computer, when properly configured.

For me, this project is a step toward making practical AI tools that are accessible, transparent, and privacy-conscious.

The Lazy Payoff

The idea behind LazyDesk AI is that organizing digital files should not feel like another full-time job.

My next goal is to validate the local Ollama workflow and explore safe, user-approved file organization on a real computer.

Built for the Slow and Steady — Open-Source AI Challenge.

DukaanFlow AI: A Local-First AI Order Desk for Tiffin Sellers

Utkarsh Yadav — Fri, 16 Oct 2026 06:42:09 +0000

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

What I Built

DukaanFlow AI is a local-first AI order desk designed for small tiffin services and home-food businesses.

These businesses often receive customer requests through WhatsApp messages and phone calls. Managing daily changes manually can lead to mistakes, especially when a customer wants to skip one meal but keep their monthly subscription active.

DukaanFlow AI explores how AI can help sellers interpret requests such as:

"Please skip tomorrow's lunch."
"I will be away for three days."
"Cancel my order for Friday."

The goal is to help turn natural-language messages into structured order actions while keeping the seller in control. Important changes should be reviewed before they are applied.

Who would pay for it?

Independent tiffin providers, home-based food sellers, and small meal-subscription businesses could benefit from a tool that reduces manual order-management work. Pricing would need to be validated with real users.

Demo

Live demo: https://utkarshydv27.github.io/DukaanFlow-AI/

The website demonstrates the interface and sample workflow.

Note: The deployed GitHub Pages website is a static demo and is not connected to the local AI backend. Local AI inference runs separately through the application's local setup.

Code

GitHub repository: https://github.com/utkarshydv27/DukaanFlow-AI

The repository contains the project source code and setup information.

How I Built It

DukaanFlow AI explores a local-first AI architecture using:

Ollama to run a language model locally.
Qwen2.5 1.5B for local natural-language interpretation.
Rule-based fallback handling to support more predictable behavior.
Seller confirmation before important order changes are applied.
GitHub Pages to deploy the public demo website.

The idea is to combine the flexibility of an open-weight language model with explicit application rules. Rather than blindly trusting every AI response, the application should validate proposed actions and let the seller confirm important changes.

Why Does Open Innovation Matter?

Open innovation makes it possible to experiment with AI tools that developers can inspect, adapt, and run locally.

For small businesses, a local-first approach can reduce dependence on paid, per-request cloud AI APIs. It can also reduce the need to send customer messages to an external AI provider when processing is genuinely kept local.

Local inference still requires suitable hardware, electricity, and maintenance, and privacy depends on the complete implementation.

Most importantly, open-source tools give developers the freedom to customize AI for specific real-world problems. In this project, that means exploring a solution for small food sellers instead of building another generic chatbot.

My Agent Session

I do not have a public agent-session recording to share for this submission, so I am leaving this optional section out.

Prize Categories

This project is submitted for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

I have not claimed any additional partner prize category.

I'd love feedback from developers and small-business owners on how DukaanFlow AI could become more useful in real-world order management.

Live demo: https://utkarshydv27.github.io/DukaanFlow-AI/

Source code: https://github.com/utkarshydv27/DukaanFlow-AI

devchallenge #hf26challenge

I Built DukaanFlow AI: A Local-First AI Order Desk for Tiffin Sellers

Utkarsh Yadav — Thu, 15 Oct 2026 14:07:36 +0000

What I Built

I built DukaanFlow AI, a local-first AI order desk MVP designed for tiffin and home-food sellers who receive customer requests in Hindi, Hinglish, and English.

Small food businesses often handle delivery skips, menu questions, and subscription requests through messages. DukaanFlow AI explores how AI can help organize these requests while keeping the seller in control.

Key features:

Classifies customer requests into useful categories.
Supports an optional local Ollama model using Qwen2.5 1.5B.
Uses conservative rule-based fallback logic.
Requires seller confirmation before changing order records.
Treats one-day delivery skips separately from recurring subscription cancellations.

Demo

Live website: https://utkarshydv27.github.io/DukaanFlow-AI/

The website includes an interactive sample-message demo. This demo uses simple browser-side rules and is illustrative; it is not connected to the Python backend or a live AI model.

Code

GitHub repository: https://github.com/utkarshydv27/DukaanFlow-AI

The project is open source. You can explore the code, review the tests, and suggest improvements.

How I Built It

I used Python, Flask, SQLite, and an optional local Ollama setup with Qwen2.5 1.5B.

The MVP follows a simple workflow:

A customer request is entered.
The request is classified using the available local model or fallback rules.
The seller reviews the suggested action.
The seller confirms before an order record is changed.

I also created a responsive static website to explain the project and demonstrate sample request classification. The local test suite passed 19 tests during development.

Why Open Innovation Matters

I wanted to explore how open-weight models can make AI experimentation more accessible to small projects and developers.

Local inference can offer more control over where processing happens and may reduce dependence on hosted AI APIs. However, it still has hardware, electricity, and setup costs. It also needs real-world evaluation before we can claim that it performs better than other approaches.

For me, open innovation means being able to inspect, test, adapt, and improve the tools we build.

My Agent Session (Optional)

I used an AI coding assistant during development to help with implementation, debugging, documentation, and project organization. I reviewed the changes and tested the application during development.

My First User (Optional)

This is an early MVP. I have not yet validated it with a real food seller, so I am not claiming user feedback or real-world adoption.

Prize Categories

DukaanFlow AI explores local-first AI and open-weight models through a practical workflow for small food businesses. Its focus is on accessible experimentation, transparent limitations, and human confirmation before consequential order changes.

The project is still an MVP. WhatsApp Cloud API integration is not live, and real-world seller testing remains future work.

Built by Utkarsh Yadav

TouchGrass AI: Less Scrolling, More Living 🌿

Utkarsh Yadav — Fri, 09 Oct 2026 15:12:25 +0000

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

What I Built

I built TouchGrass AI, a local AI-powered nature mission planner that encourages people to spend less time scrolling and more time outdoors.

Users can choose their preferred outdoor activity, available time (15, 30, or 60 minutes), and difficulty level. The app generates a personalized nature mission using a locally running AI model.

The project includes a Flask backend, a simple web interface, input validation, and browser local storage for tracking self-reported progress.

Demo

Demo video: https://youtu.be/SX3HJ4AzR5Q
GitHub repository: https://github.com/utkarshydv27/TouchGrassAI
Original project article: https://dev.to/ut_yadav_18820e71996/-touchgrass-ai-less-scrolling-more-living-2dpi

Code

The complete source code is available on GitHub:

https://github.com/utkarshydv27/TouchGrassAI

The repository contains the Flask application, frontend files, and automated tests.

How I Built It

I used Python, Flask, HTML, CSS, JavaScript, and Ollama with the Qwen 2.5 1.5B model.

The Flask backend validates user preferences and sends requests to the locally running Ollama service. The frontend displays the generated nature mission and uses browser local storage to track self-reported progress.

I added automated tests covering the home page, invalid inputs, successful mission generation, and Ollama service failures. All 6 tests passed.

Why Does Open Innovation Matter?

Open innovation makes AI development more accessible. By using open-source tools and a locally runnable model, I could build and test an AI-powered application without relying on a paid hosted AI API.

Others can inspect the code, run the project locally, learn from the implementation, and contribute improvements. TouchGrass AI explores how AI can encourage healthier offline habits instead of simply increasing screen time.

Thanks for checking out TouchGrass AI! 🌿