DEV Community: Pallav Ghatval

GhostShell: Summoning a Ghost in Your Terminal with Local AI 👻

Pallav Ghatval — Tue, 27 Oct 2026 19:27:52 +0000

👻 GhostShell: Summoning a Ghost in Your Terminal with Local AI

What if your terminal had a ghost living inside it? One that understands your commands, whispers warnings, and tells eerie stories—all powered by AI running on your own machine.

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

What I Built

GhostShell is a haunted terminal assistant powered by a locally running open-weight language model.

Instead of being just another chatbot, GhostShell gives the command line a personality. It can explain shell commands, provide spooky commentary, and help users understand potentially dangerous operations before they run them.

Imagine typing a command and receiving a response like:

👻 The machine remembers what you are about to do.

rm -rf important_folder

"I see you are about to erase something from existence. Are you certain this is the ghost you wish to summon?"

The idea combines Halloween aesthetics with a practical developer tool: an AI assistant that makes learning the terminal more engaging without sacrificing user privacy.

Demo

Live demo / demonstration video: [Add your demo link here]

The demo will show:

Asking GhostShell to explain a terminal command.
Receiving spooky, context-aware commentary.
Getting a warning about a potentially destructive command.
Running the AI locally without sending prompts to a cloud AI provider.

The demo link will be added once the application is implemented and tested.

Code

GitHub repository: [Add your GitHub repository URL here]

The repository will contain the source code, setup instructions, model configuration, and examples for running GhostShell locally.

How I Built It

GhostShell is designed around open-weight AI and local inference.

Technology stack

Python: Core application and terminal interaction.
Qwen through Ollama: Local language-model inference.
Rich: Styled terminal output, colors, panels, and a spooky command-line interface.
Git: Version control and open-source collaboration.

How it works

The user enters a command or asks a question.
GhostShell passes the relevant text to the locally running model.
The model generates an explanation, warning, or spooky response.
The application formats the response in the terminal.

The first version focuses on command explanations and user-submitted commands. Any future shell monitoring will be opt-in, with explicit safeguards against silently executing commands.

Safety by design

GhostShell is intended to explain commands, not execute arbitrary AI-generated instructions.

Potentially destructive commands should be highlighted, and the user remains in control of execution. The AI's output is advisory, not a substitute for understanding what a command does.

Why Does Open Innovation Matter?

For GhostShell, open innovation is not just a technology choice. It is part of the project's purpose.

1. A ghost that doesn't need the internet

With a compatible model downloaded and configured, GhostShell can generate responses locally without sending each prompt to a remote inference API.

That means it can continue working in offline environments, provided the model and required dependencies are already installed.

2. Privacy belongs to the developer

Terminal commands can reveal usernames, directory structures, project names, internal hostnames, and sometimes credentials.

A local model gives developers more control over where this information goes. GhostShell is designed to keep prompts on the user's machine instead of requiring a third-party AI service.

Users must still take care not to expose sensitive information through logs or other application components.

3. Freedom to change the model

A closed API can tie an application to a particular provider, model, pricing structure, and set of usage limits.

With a local open-weight model, developers can experiment with compatible models, adjust prompts, and change the assistant's behavior without redesigning the entire application.

4. More control over experimentation

Local inference makes it easier to experiment with the assistant's personality, response format, and command-explanation behavior. Developers can inspect the code, modify the logic, and contribute improvements.

Local inference is not automatically free: hardware, electricity, storage, and model licensing still matter. But it can reduce recurring per-request API costs.

For a terminal assistant, that trade-off is especially interesting. The terminal is already a local developer environment, so bringing AI closer to the machine is a natural fit.

My Agent Session

[Add a DevRelay agent-session link or embed your saved session here, if available.]

I want the development process to be transparent: the repository and demonstration should show how the model is invoked, how prompts are constructed, and how the application handles potentially dangerous commands.

The Spirit of It

The terminal has always felt like a place where a few characters can do extraordinary things.

A single command can create something, fix a broken system, or erase hours of work. GhostShell gives that familiar environment a little Halloween personality.

But beneath the spooky interface is a serious idea: AI tools should give developers more control over their machines and their data, not less.

This is my interpretation of the ghost in the machine—not a supernatural intelligence trapped in a computer, but an open, modifiable intelligence that developers can run, inspect, and shape themselves.

Prize Categories

[Select the applicable partner prize categories listed on the official challenge page. Remove this section if none apply.]

Built for the Hacktoberfest Open-Source AI Challenge — Week 4: Ghost in the Machine.

Hacktoberfest #OpenSource #AI #Python

SlothTask AI: Let Open-Source AI Handle the Boring Stuff 🦥

Pallav Ghatval — Fri, 23 Oct 2026 17:18:13 +0000

What I Built

Meet SlothTask AI, a local-first productivity assistant designed around one simple idea: repetitive digital housekeeping shouldn't consume our time and attention.

We all accumulate clutter—poorly named documents, crowded Downloads folders, and files we keep postponing organizing. SlothTask AI helps automate that work.

It can:

Organize files: Categorize documents into meaningful folders.
Suggest better filenames: Turn confusing filenames into descriptive ones.
Summarize documents: Generate short summaries so users can understand files faster.
Keep users in control: Preview proposed changes before applying them.

The goal isn't to make people work faster at everything. It's to help them spend less time on tasks that don't deserve their attention.

Demo

[Add your live demo or screen-recorded walkthrough here.]

The demo will show a cluttered folder, the AI-generated organization plan, and the resulting structure after approval.

Code

[Add your public GitHub repository URL here.]

The repository will include setup instructions, source code, example inputs, and instructions for running the application locally.

How I Built It

SlothTask AI is built around an open-weight language model running locally through Ollama.

The application uses Python to inspect files and perform controlled filesystem operations. The model handles language-based tasks, including document categorization, filename suggestions, and summarization.

The workflow is straightforward:

The user selects a folder to organize.
The application gathers basic file metadata and supported text content.
The local model generates structured suggestions.
The application validates the suggestions and displays a preview.
The user approves the changes before any files are moved or renamed.

The application separates AI reasoning from filesystem operations. The model proposes actions; Python validates and executes only permitted operations.

This design makes the system easier to inspect, test, and extend with additional models or organization rules.

Why Does Open Innovation Matter?

For SlothTask AI, open innovation is about control, privacy, flexibility, and accessibility.

1. Privacy by design

Documents can contain personal information, assignments, financial records, and other sensitive content. Running inference locally allows supported processing to happen on the user's machine instead of requiring every document to be sent to a third-party AI API.

2. Freedom to change models

An open-weight architecture makes it possible to experiment with different compatible models and compare their categorization accuracy, response time, and resource requirements without redesigning the entire application.

3. Fewer recurring API costs

Once the required model is downloaded, local inference doesn't require a per-request hosted-model API fee. Hardware, electricity, storage, and setup still have costs, but users can avoid recurring inference charges.

4. More control over the system

The application can combine model output with transparent Python rules, validation, and user approval. Developers can inspect and modify the workflow instead of relying entirely on a closed API's behavior.

Open-weight AI isn't automatically better than every closed model. Hosted models may provide stronger results or require less local hardware. The advantage here is that local processing and model flexibility align with the problem we're solving.

My Agent Session

[Optional: Add a DevRelay agent session link or embed your recorded session here.]

The Lazy Payoff

The real payoff is reducing the small, annoying decisions that accumulate throughout the week.

Instead of opening every document, inventing a filename, and deciding where it belongs, a user can review a single proposed organization plan.

The intended result is simple: fewer repetitive actions, less context switching, and a cleaner workspace.

I'll evaluate the workflow using a sample folder and compare the time required for manual organization against AI-assisted organization. I'll also check whether the suggested filenames and categories are accurate enough to be useful.

Prize Categories

[Add the applicable partner prize categories from the official challenge page after verifying eligibility.]

Final Thoughts

I like the idea behind Slow and Steady: useful technology doesn't always need to make us do more. Sometimes, the best tool is the one that quietly removes work from our day.

SlothTask AI explores how open-weight models can make everyday automation more private, flexible, and accessible.

Stay slow. Let the boring stuff run itself. 🦥

TrailMate AI: An Offline-First AI Companion That Gets You Outside 🌿

Pallav Ghatval — Sun, 11 Oct 2026 15:58:35 +0000

What I Built

TrailMate AI is a proposed offline-first nature companion designed to make outdoor walks more engaging, curious, and mindful.

We spend a lot of time looking at screens. What if AI could help us spend less time on them?

TrailMate is designed around a simple idea: use AI to prepare people for an outdoor experience, then let the real world become the main event.

Users will be able to choose a walk duration, receive nature observation missions, discover things to look for around them, and record their observations in a personal nature journal.

Think of challenges like:

Find three different leaf shapes.
Spend two minutes listening to the sounds around you.
Observe how sunlight changes across a tree.
Notice a small detail in nature that you would normally walk past.
Write down one thing you learned during your walk.

The goal isn't to turn nature into another screen-based game. It's to make the screen useful for a moment, then encourage people to put their phones away and explore.

Demo

Status: In development.

Live demo: [Add deployed demo URL]
Demo video: [Add video URL]
Screenshots: [Add screenshots after implementation]

I'll update this section with a working demonstration once the prototype is ready.

Code

Repository: [Add your public GitHub repository URL]

The project is intended to be built with a focus on reproducibility, local execution, and clear documentation.

The repository will include setup instructions, the application source code, model configuration, and instructions for running the AI locally.

How I Built It

My goal is to build TrailMate around open-weight AI rather than making a closed, remote AI API the core dependency.

Proposed architecture

Frontend: Next.js, TypeScript, and Tailwind CSS.

AI: A small Qwen instruction-tuned model, selected according to hardware requirements, output quality, and its applicable license.

Local inference: llama.cpp, using a compatible quantized model.

Nature knowledge: A small, curated local dataset containing observation ideas and basic educational information.

Persistence: Local browser storage for walk history and journal entries.

The application will combine predefined observation missions with locally generated prompts. The curated content will provide a predictable fallback if the model is unavailable or produces an unsuitable response.

Rather than asking a model to invent every fact about nature, the application will use a limited knowledge source and encourage users to verify uncertain observations.

An important technical goal is to keep inference on the user's device. Once the application, model, and required data are available locally, the core experience should not need an internet connection.

I'll document the actual model, quantization settings, hardware, and offline test results after implementation.

Why Does Open Innovation Matter?

For TrailMate, open innovation isn't just about choosing a different AI model. It changes how the product can be built and used.

1. Privacy by design

Outdoor journals can contain personal reflections and information about where someone spends their time. A local-first design can keep these records on the user's device instead of requiring a remote AI service to process every interaction.

2. Less dependence on closed APIs

A remote AI API can introduce usage limits, network dependencies, and ongoing costs. Local inference can reduce those dependencies, although it still requires compatible hardware, storage, and electricity.

3. Freedom to experiment

Open-weight models and open-source inference tools give developers more control over model selection, quantization, prompts, and execution.

That makes it easier to experiment with smaller models, compare their output quality, and adapt the application to different devices.

4. A more accessible approach to AI

A nature companion shouldn't require a constant internet connection just to generate a simple observation prompt. Local inference makes offline use a realistic design goal.

The broader lesson is that AI doesn't always need to be a cloud service. Sometimes, the most useful AI is the kind that quietly supports an activity happening somewhere other than a screen.

My Agent Session

[Add a DevRelay agent session link or embed after saving the actual session.]

This section is optional and will be completed if I capture a suitable development session.

Prize Categories

[Add applicable partner prize categories after checking the official challenge requirements, or remove this section if none apply.]

I'm building TrailMate AI as a solo project for the Touch Grass challenge.

The measure of success won't just be whether the model generates interesting text. It will be whether the application helps someone notice more of the world around them.

Build with AI. Step outside. Touch grass. 🌱