DEV Community: DEV KUMAR CHAUBEY

PHANTOM.exe: Building a Ghost Inside Your Terminal | Hacktoberfest Week 4

DEV KUMAR CHAUBEY — Fri, 30 Oct 2026 21:34:30 +0000

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

What I Built

I'm building PHANTOM.exe — The Ghost Living Inside Your Terminal.

The idea is to create a local-first AI developer companion that lives inside the terminal and helps developers with everyday programming tasks.

Think of a mysterious digital presence that can explain code, help debug errors, review implementations, and teach programming concepts — without depending on a closed cloud-based AI service.

I interpreted the "Ghost in the Machine" theme as a digital consciousness living inside a developer's terminal.

Instead of building another conventional chatbot, I wanted to experiment with a more personal and atmospheric terminal experience.

The project is currently under active development.

Demo

The project is currently being developed locally. I haven't published a video demo yet.

For now, you can follow the project through its public GitHub repository:

GitHub: https://github.com/vash57/PHANTOM

Code

Explore the project repository:

PHANTOM.exe — GitHub Repository

The source code and development updates will be maintained in this repository.

How I Built It

The project is being developed with a lightweight, local-first architecture.

My planned technology stack includes:

Python — Core application and terminal interface.

Ollama — Local model inference.

Gemma — Open-weight AI model.

JSON — Local conversation memory.

Rich — Terminal rendering and visual presentation.

I'm using OpenCode as my AI coding agent to help with implementation, debugging, and development.

The goal is to keep the application independent of mandatory cloud APIs and make it usable on a developer's own machine.

Why Does Open Innovation Matter?

Open innovation makes experimentation accessible.

A developer should be able to explore AI-powered tools without being restricted to expensive subscriptions, closed APIs, or sending personal source code to external services.

By building around local inference and open-weight models, PHANTOM aims to give developers more control over their tools, data, and computing environment.

It also creates opportunities for other developers to inspect the code, contribute improvements, experiment with different models, and build upon the idea.

For me, this project is an exploration of what becomes possible when AI development is more open and accessible.

This section is intentionally omitted for now.

The Spirit of It

There is something interesting about the idea of a ghost living inside a machine.

A terminal is usually just a place where developers type commands and execute programs. I wanted to experiment with turning that familiar environment into something that feels a little more alive.

PHANTOM is my attempt to give that idea a personality while keeping its actual purpose practical: helping developers build, learn, and solve problems.

The ghost is fictional. The AI running behind it is real.

Thanks for checking out PHANTOM.exe!

Why Does Open Innovation Matter?

Open innovation matters because AI development should not be limited by expensive subscriptions, closed APIs, or access restrictions.

With PHANTOM.exe, I want to explore how open-weight models and local inference can make AI-powered developer tools more accessible, private, and customizable.

Using Ollama and Gemma makes it possible to experiment with running AI directly on a developer's machine, without requiring every conversation or piece of code to be sent to an external cloud service.

Unlike a closed API, this approach gives developers more control over model selection, experimentation, customization, and how their data is handled.

Open source also means other developers can inspect the implementation, suggest improvements, contribute features, and build upon the project.

For me, open innovation is not just about making code publicly available. It is about giving people the freedom to experiment, learn, collaborate, and create without unnecessary barriers.

My Agent Session

I used DevRelay to publish my PHANTOM.exe development session, documenting the AI-assisted development process, implementation decisions, and project progress.

Public Agent Session: https://dev.to/agent_sessions/phantomsession-cc0xbp

The Spirit of It

The idea behind PHANTOM.exe came from imagining something unusual: what if your terminal wasn't just a place where you typed commands, but a place where a ghost quietly lived, watched your code, and was always ready to help?

I wanted to bring a little personality into the developer experience. Instead of building another ordinary AI chatbot, I imagined a mysterious companion that could help developers debug errors, understand unfamiliar code, review projects, and explore ideas — all from inside the terminal.

The "Ghost in the Machine" theme made this idea feel even more interesting. PHANTOM represents that invisible intelligence living inside a machine, turning an ordinary terminal into something that feels alive.

For me, the most exciting part isn't just making an AI assistant work. It's exploring how open-weight models and local AI can give developers a companion they can run, customize, and eventually make their own.

PHANTOM.exe is still evolving, but the vision is simple: your terminal may look empty, but something is always there to help.

Prize Categories

Best Use of Gemma
Best Use of Entire

LazyFile: Let Local AI Clean Up Your Downloads

DEV KUMAR CHAUBEY — Sat, 24 Oct 2026 06:41:25 +0000

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

What I Built

I have always found one small computer task unnecessarily repetitive: keeping the Downloads folder organized.

PDFs get mixed with screenshots, source code files sit alongside ZIP archives, and useful documents become harder to find over time. Sorting everything manually takes attention away from the work that actually matters.

That is why I built LazyFile, an offline-first AI-powered file organizer designed around a simple idea: let the computer do the repetitive work, but keep the human in control.

LazyFile scans a folder, categorizes files, suggests cleaner organization, and creates a preview of the proposed changes. Instead of blindly moving everything, it lets users review and approve the suggestions they want to apply.

What makes LazyFile useful?

Smart categorization: Organizes files into 14 categories, including Documents, Finance, Images, Code, Archives, and more.

AI-assisted suggestions: Optionally uses a local Ollama model to improve filenames and category suggestions.

Offline fallback: A deterministic rule-based engine keeps the core workflow useful without an AI model or cloud service.

Preview before action: Users can inspect the source, destination, category, and reason before making changes.

Safety first: Collision checks, path validation, dry-run mode, and safeguards against overwriting files.

Undo support: Reverses supported operations when the recorded file state still matches.

Lightweight by design: Python standard library for the backend and plain HTML, CSS, and JavaScript for the interface, with no mandatory pip packages.

The principle is simple: AI proposes. You decide. LazyFile handles the repetitive part.

Demo

Watch the LazyFile demo to see how it scans a folder, suggests file organization, and lets users preview changes before applying them.

YouTube Demo: https://youtu.be/0UX9EkAf8S0

Code

Explore the complete source code, implementation, and setup instructions for LazyFile on GitHub.

GitHub Repository: https://github.com/vash57/LazyFile

How I Built It

I built LazyFile using Python's standard library, HTML, CSS, and JavaScript to keep the application lightweight and easy to run.

For AI-powered suggestions, LazyFile supports Ollama, which allows users to run open-weight language models locally instead of relying on a cloud AI API.

The application has two modes:

Rule-based mode: Categorizes files using extensions and filename keywords. It works offline without requiring an AI model.
Local AI mode: When Ollama is available, a locally running model can suggest file categories and cleaner filenames. The suggestions are validated before they are presented to the user.

I designed LazyFile so that AI is an optional enhancement rather than a mandatory dependency. This makes the application more practical for users with limited hardware resources.

The backend uses Python's built-in HTTP server, while the frontend is built with plain HTML, CSS, and JavaScript. No external Python packages are required for the core functionality.

The AI coding agent helped me implement and refine the project, but the file organization logic, local AI integration, and safety workflow are part of the LazyFile application itself.

Post not found or has been removed.

Why Does Open Innovation Matter?

Open innovation matters to LazyFile because file organization often involves personal documents, invoices, assignments, and other sensitive information.

By building LazyFile around local processing and open-weight AI, I wanted to give users more control over where their data goes and how their files are organized.

A closed, cloud-based AI API would typically require sending file metadata to an external service for AI-powered suggestions. With Ollama, users can instead run compatible open-weight models on their own machines, keeping the AI processing local.

Open-source tools also gave me the flexibility to design LazyFile around my actual hardware constraints. Rather than requiring a large model or expensive cloud infrastructure, I made AI optional and kept a lightweight rule-based engine as the foundation.

This means users can inspect the logic, modify the categorization rules, choose a compatible local model, and use the application without depending on a single proprietary AI provider.

For me, open innovation is about making useful AI automation more accessible, transparent, and adaptable. LazyFile demonstrates that a small, local-first tool can reduce repetitive work without requiring users to hand over control of their files to a cloud service.

My Agent Session

The Lazy Payoff

Prize Categories

HustleCraft AI: Open-Source AI Toolkit for Freelancers & Side Hustlers

DEV KUMAR CHAUBEY — Sun, 18 Oct 2026 17:52:48 +0000

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

What I Built

I built HustleCraft AI, an open-source AI toolkit designed for freelancers, indie hackers, and small business owners. It provides automated AI proposal generation, client project pitches, and high-converting WhatsApp/Social media ad copies to save hours of manual work and help scale their side hustles.

Demo

Check out the video walkthrough of HustleCraft AI in action:

Code

You can explore the complete source code and project structure directly in the GitHub repository:
[https://github.com/vash57/HustleCraft]

How I Built It

The project is built using a lightweight Python standard library HTTP server (server.py) for the backend. The frontend features modern HTML5, CSS3 (Glassmorphism, Particle Canvas background, dark mode zinc-950 theme inspired by 21st.dev and ThreeUI), and vanilla JavaScript. For the intelligence layer, open-weight models (Gemma/Llama) are integrated via cloud API endpoints to keep local resource usage minimal.

Why Does Open Innovation Matter?

Using open-source and open-weight models made it possible to run this toolkit with near-zero hosting costs and complete data privacy. Unlike closed, heavy paid APIs, an open architecture allows micro-SaaS creators to maintain affordable pricing for everyday freelancers while giving full control over prompts, fine-tuning, and data handling.

My Agent Session

Developed with OpenCode assistance, integrating smooth UI animations, tracing panels, and responsive components. ## My First User
Tested with local freelancers who noted that the automated proposal drafting significantly sped up their client outreach workflow.

Prize Categories

Best Use of Gemma
Best Use of Render
Best Use of Mastra
Best Use of MongoDB Atlas -->

OfflineMode — A Local AI Companion

DEV KUMAR CHAUBEY — Thu, 08 Oct 2026 20:15:29 +0000

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

What I Built

Demo

🎥 Watch the short demo to see how OfflineMode works:

https://youtu.be/W4Wb3xgDhjo?si=UDLfdU9dBBVBp23g

Code

💻 GitHub

Check out the code:

https://github.com/vash57/OfflineMode

How I Built It

Open-Source AI OfflineMode uses Google's Gemma 4 E2B through Ollama for local AI responses.

The project was built with OpenCode as the AI coding assistant, while Ollama handles the local inference.

Why Does Open Innovation Matter?

Open innovation made it possible to build OfflineMode around local, open-weight AI instead of depending on a closed API.

Using Gemma 4 E2B with Ollama gives the project local inference, better privacy, and more control over how AI is used. OpenCode also helped during development by making it easier to build and iterate on the project.

A closed API could provide the AI responses, but it would make the project more dependent on an external service. With open tools, the AI can become part of the user's own environment — which fits the core idea of OfflineMode: use technology as a bridge to real life, not as the destination.

My Agent Session

https://dev.to/agent_sessions/offlinemode-week-1-building-an-offline-ai-chatbot-with-ollama-opencode-session-2llwjg

Prize Categories

Best Use of Gemma
Best Use of GitHub Copilot

AbeyYaar : An AI Friend for Studnts,Built with Python, Ollama & Gemma 4

DEV KUMAR CHAUBEY — Mon, 05 Oct 2026 06:38:49 +0000

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

What I Built

I built AbeyYaar, an AI companion for students.

The idea came from something pretty simple. As students, we have a lot of things going on apart from studies — placements, internships, resumes, career choices, learning new skills, managing money, and sometimes just dealing with everyday problems.

I wanted to build something that could be more than just a chatbot that gives an answer. Something that feels a little more like having a friend you can ask when you're confused about something or just need a second opinion.

AbeyYaar is being built around these kinds of situations. It can help with career and placement preparation, resumes, learning roadmaps, decisions, budgeting, and normal conversations.

I'm building it step by step, so not everything is finished yet. The main goal for now is to get the core idea working and then keep improving it with more useful features.

Demo

I made a short video showing AbeyYaar in action, including the conversation flow and how it works with local AI.

Watch the demo on YouTube : https://youtu.be/nXyBLYLtmDI

Code

The complete source code for AbeyYaar is available on GitHub.

View the AbeyYaar repository on GitHub

How I Built It

I built AbeyYaar mainly with Python and used Ollama to run Gemma 4 locally.

I wanted to try local AI instead of just connecting the project to a closed AI API. Ollama makes it possible for me to run the model on my own machine and use it from the Python application.

The basic flow is simple. A user sends a message, AbeyYaar tries to understand what the user is asking, checks for safety, and then routes the request through the agent and the relevant tools before generating a response with Gemma.

I have kept the project divided into different parts for things like intent detection, memory, safety, Ollama, and student-focused tools. This makes it easier for me to keep adding new features as I continue working on the project.

The main technologies I used are Python, Ollama, Gemma 4, HTML, CSS and JavaScript.

Why Does Open Innovation Matter?

For me, open innovation makes it possible to experiment and learn without being completely dependent on a closed AI API.

With Gemma and Ollama, I can run the model locally and build the different parts of AbeyYaar around it. I can experiment with things like the