DEV Community: Satyam Godara

GhostShell: A Haunted Terminal Powered by Open-Source AI 👻

Satyam Godara — Tue, 27 Oct 2026 20:43:55 +0000

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

What I Built

Meet GhostShell, a haunted terminal assistant that brings a little supernatural personality to everyday software development.

What if your terminal could talk back?

What if, after running a command, your computer responded like an ancient digital spirit that had been trapped inside your repository for years?

GhostShell combines a spooky terminal experience with a locally running open-weight language model. It can react to developer commands, comment on Git activity, and explain errors while staying in character as a mysterious AI haunting your machine.

Instead of connecting to a proprietary AI API, GhostShell uses a model running locally on the developer's computer.

The result is a small experiment in making local AI both useful and fun.

The interaction above is an illustrative example.

Code

The project includes the terminal interface, AI inference layer, personality configuration, and command-processing logic.

How I Built It

GhostShell is built around local AI inference.

The initial stack consists of:

Python: Core application and terminal interaction.
Ollama: Runs the language model locally.
Qwen2.5 3B: An open-weight model used for generating responses, subject to its model license.
Rich: Provides formatted terminal output.
Git: Supplies real repository context for development-related interactions.

The application collects the relevant command and output, constructs a prompt, and passes it to the locally running model. The generated response is then displayed in the terminal.

The model's personality is controlled through a system prompt, allowing it to behave like a spooky digital entity without sacrificing its usefulness as a coding assistant.

Why Does Open Innovation Matter?

For GhostShell, open innovation is not just a technology choice. It changes where the application runs, where its data goes, and how much control its users have.

1. Local inference and privacy

Terminal output can contain sensitive paths, environment details, and other information developers may not want to send to an external service.

Running the model locally gives users more control over their development data.

2. Offline capability

After the model and required dependencies have been downloaded, GhostShell can generate responses without requiring an internet connection.

That means the experience doesn't have to disappear when the network does.

3. Freedom to experiment

The model is not permanently tied to one hosted AI provider. Developers can experiment with compatible models, change prompts, adjust the personality, and modify the inference pipeline.

4. Lower running costs

Local inference avoids per-request API charges. The trade-off is that users supply their own computing resources, and running a model still consumes electricity.

For a small developer tool, that trade-off can be worthwhile.

Open innovation makes GhostShell something developers can inspect, modify, and extend rather than simply consume as a hosted service.

My Agent Session

The Spirit of It

Halloween is usually associated with ghosts, haunted houses, and things hiding in the dark.

For developers, there are other kinds of ghosts.

Abandoned repositories. Forgotten commits. Dependencies that nobody remembers adding. Bugs that return just when everything seems to be working.

GhostShell gives those familiar experiences a playful personality.

But beneath the horror aesthetic is a practical idea: AI does not always need to live in a remote service. Sometimes, it can live right on your own machine, where you can inspect it, experiment with it, and decide how it behaves.

The machine isn't haunted.

It just finally has something to say.

Prize Categories

Built with Python, local inference, and a little Halloween spirit. 👻

ClipMate AI: Work Less, Organize Smarter

Satyam Godara — Tue, 20 Oct 2026 05:12:55 +0000

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

🦥 ClipMate AI: Work Less, Organize Smarter

What I Built

We all have those tiny tasks that don't seem like much individually but keep interrupting our workflow — organizing text, cleaning up copied content, summarizing long notes, and rewriting information just to make it usable.

I built ClipMate AI, an AI-powered clipboard assistant designed to make working with text a little less tedious.

The idea is simple: instead of manually cleaning, organizing, or summarizing text every time I copy something, I want a lightweight tool that helps me do it with minimal effort.

With ClipMate AI, the goal is to make everyday text management easier by combining a simple clipboard workflow with open-source AI.

The inspiration behind it is the theme itself: why spend energy on repetitive tasks when a tool can handle the boring parts for you?

The project is designed around a lightweight web interface and a backend that manages clipboard operations, with AI capabilities intended to handle repetitive text-processing tasks.

How I Built It

I approached this project with one goal: keep the experience simple while making the underlying AI flexible.

The core idea is to combine a lightweight clipboard application with an open-source language model that can process text according to the user's needs.

The planned workflow is straightforward:

Capture: Paste or save text into the clipboard.
Choose: Select an action, such as summarizing, cleaning up, or organizing the text.
Process: Send the text to an open-weight model running through a local inference setup.
Use: Copy the result and get back to work without manually doing every step.

The application can use an open-weight model through a local inference runtime such as Ollama, with a model selected according to available hardware and the quality required.

The existing clipboard workflow provides the foundation, while the AI layer can be developed independently so that the model can be replaced without redesigning the entire application.

Why Does Open Innovation Matter?

For me, open innovation is about having control over the tools we build with — not just access to an API.

1. Privacy by design

Clipboard content can contain personal notes, code snippets, emails, or other sensitive information. Running inference locally can keep that text on the user's own machine instead of sending it to a third-party AI provider.

2. Freedom to experiment

Open-weight models make it possible to experiment with different models, prompts, and inference settings. If one model is too slow or produces poor summaries, it can be replaced with another that better fits the use case.

3. Less dependence on paid APIs

Once the required model is downloaded, local inference can avoid per-request API charges. Hardware, electricity, and setup still have costs, but there is no need to pay a hosted model provider for every text-processing request.

4. More control over the experience

A closed API determines which models and configurations are available. An open approach gives developers more freedom to customize prompts, inspect the surrounding code, choose deployment options, and build a workflow that fits their needs.

For a small productivity tool, that flexibility matters. I don't want a simple clipboard operation to become dependent on a paid service or an external server when it can potentially run locally.

My Agent Session

I would love to share the development process behind this project.

DevRelay Agent Session: [Add your saved DevRelay session link here]

This section is optional. If you save your session with DevRelay, you can embed it here using the agent-session syntax supported by the challenge.

The Lazy Payoff 🦥

The biggest payoff is reducing the small interruptions that accumulate throughout a day.

Instead of repeatedly cleaning up copied text or manually turning long notes into short summaries, the goal is to make those actions available with a single interaction.

Even saving a few seconds per task can add up when the same task happens dozens of times.

And the best part? With a suitable local model and compatible hardware, the AI functionality can work without a continuous internet connection after the initial setup and model download.

Less repetitive work. More time for the things that actually need attention.

That's my version of being a sloth: automate the boring parts, conserve your energy, and keep moving at your own pace.

Thanks for checking out my project! I'd love to hear how others are using open-source AI to automate everyday tasks while keeping their tools flexible, accessible, and under their control.

Hacktoberfest #OpenSourceAI #AI #BuildInPublic #DevRelay

LocalStudy Buddy: An Open-Source AI Study Partner Built for a Friend

Satyam Godara — Sun, 11 Oct 2026 10:14:03 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built LocalStudy Buddy, an AI-powered study assistant designed to help a friend prepare for exams without spending hours manually revising lecture notes.

The idea came from a simple problem: studying from lengthy notes can be overwhelming, especially when you need quick explanations and practice questions before an exam.

LocalStudy Buddy helps users understand their study material, ask questions, and practice what they've learned using AI.

My goal was to build something small but genuinely useful for someone I know, rather than just another AI chatbot.

How I Built It

I built the application using React for the frontend and Node.js for the backend, with an open-weight language model powering the AI features through Ollama.

The planned core features include:

AI-powered explanations: Ask questions about study material.
Quick revision: Turn lengthy notes into concise summaries.
Practice quizzes: Generate questions to test understanding.
Local inference: Run the model locally instead of depending on a hosted AI API.

The project focuses on keeping the experience simple and making open-source AI useful in an everyday situation.

The final implementation and technology details will reflect the features actually completed.

Why Does Open Innovation Matter?

Open innovation matters because AI should be something developers can understand, experiment with, and adapt to real problems—not just consume through a closed API.

Using an open-weight model that supports local inference gives this project several potential advantages:

Privacy: Study notes can remain on the user's device when inference and storage are configured locally.
Flexibility: Developers can experiment with different models and choose the one that works best.
Accessibility: Local inference can reduce recurring API costs, although hardware and electricity still have costs.
Control: The application can be adapted to the user's specific learning needs without depending entirely on a proprietary AI service.

For me, the most important part is that open-source AI makes it easier to turn an idea into a tool tailored to a real person.

Instead of building something just to demonstrate AI, I wanted to explore how it could make a friend's everyday studying a little easier.

TrailMate AI: An Open-Source AI Companion That Gets You Outside

Satyam Godara — Sun, 11 Oct 2026 09:28:08 +0000

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

What I Built

I built TrailMate AI, a small outdoor companion designed to turn a little curiosity into time spent outside.

Users can choose an activity such as a nature walk, birdwatching, gardening, or a mindful outdoor break. They can specify how much time they have and where they plan to go, and TrailMate generates a simple outdoor micro-adventure with practical steps and observation prompts.

The idea is simple: use AI to help someone decide what to do outdoors, then encourage them to put their phone away and enjoy the experience.

Demo

Screenshot:

Code

GitHub repository: https://github.com/Satyam-Godara/Trailmate-Ai.git

The project includes a React frontend, a Node.js/Express API, and instructions for running the AI locally.

How I Built It

I built TrailMate AI using React, Vite, Node.js, and Express. For AI inference, it connects to Ollama and uses the open-weight qwen2.5:3b model by default.

Instead of sending prompts to a hosted commercial AI API, the backend sends them to the local Ollama service. The model generates a short outdoor activity plan based on the user's selected activity, available time, location description, and interests.

The app is designed as a small, self-hostable project that developers can modify to use another locally available model.

Why Does Open Innovation Matter?

Open innovation makes TrailMate AI easier to inspect, experiment with, and adapt.

Running an open-weight model locally gives users more control over where their prompts are processed. Developers can experiment with different models and prompts without being locked into one hosted AI provider or paying per-request API charges.

It also makes the project a learning opportunity: anyone can inspect the code, run the model on their own machine, and build on the idea.

The initial model download requires internet access, but inference can run locally once the model is installed. The goal is to make AI a tool for real-world exploration rather than another reason to stay on a screen.

.

Satyam Godara — Wed, 07 Oct 2026 06:14:19 +0000