DEV Community: Subhadip Gayen

👻 Phantom Terminal — Every Error Leaves a Ghost Behind

Subhadip Gayen — Tue, 27 Oct 2026 04:58:15 +0000

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

🧪 What I Built

Phantom Terminal is a spooky, AI-powered debugging assistant designed to make debugging more interactive, understandable, and fun.

Inspired by the theme Ghost in the Machine, I imagined a mysterious terminal hidden inside an abandoned laboratory, where every programming error leaves behind a ghost waiting to explain what went wrong.

Developers can paste an error message, code snippet, or technical question into the haunted terminal. The application analyzes the input, explains the likely cause, suggests a practical fix, and recommends what to investigate next.

👻 Key Features

Haunted Terminal UI: A retro-futuristic interface inspired by mysterious computer terminals and phosphor-green displays.
AI-Powered Debugging: Browser-based inference using Transformers.js and an open-weight language model.
Rule-Based Fallback: Helpful explanations for common programming errors when the AI model is unavailable.
Possessed Mode: Adds spooky personality to debugging explanations while keeping the technical advice clear.
Suggested Fixes: Presents practical solutions with copy-to-clipboard support.
Interactive Examples: Lets users experiment with common JavaScript, Python, networking, and server errors.
Privacy-Conscious Architecture: Debugging input is processed in the browser rather than sent to the Express backend for inference.

The main idea is simple: debugging does not have to feel like fighting invisible forces. Sometimes, you just need to find the ghost responsible.

🎬 Demo

Source Code: Phantom Terminal on GitHub

The project can be run locally using Node.js and Express.

To try it:

Clone the repository.
Install the dependencies.
Start the Express server.
Open the application in your browser.
Submit a sample error and explore the debugging results.

A publicly deployed demo and video demonstration are not available yet.

💻 Code

Explore the complete project repository:

👉 github

The project uses a straightforward structure:

server.js — Express server and static-file hosting.
public/index.html — Terminal interface.
public/style.css — Visual design, animations, and responsive styling.
public/app.js — Debugging logic, browser-side model integration, and user interactions.
package.json — Project dependencies and scripts.

The architecture separates browser-based inference from the server, keeping the application lightweight and avoiding unnecessary transmission of debugging input.

🛠️ How I Built It

I built Phantom Terminal using beginner-friendly web technologies combined with open-source AI.

Technology stack:

HTML5
CSS3
Vanilla JavaScript
Node.js
Express.js
Transformers.js
Xenova/flan-t5-small as the initial browser-model candidate

The frontend provides the interactive terminal experience, while Express serves the application and exposes a health endpoint.

For AI inference, the application attempts to load the model in the browser. When available, the model can generate text-based assistance. When the model cannot load, a separate rule-based fallback provides explanations for supported error patterns.

This fallback is important because a debugging assistant should remain useful even when model downloads fail or network access is unavailable.

The model is a small general-purpose text-generation model, not a specialized programming model. Its output should therefore be reviewed and tested rather than treated as guaranteed-correct code.

🌍 Why Does Open Innovation Matter?

Open innovation makes projects like Phantom Terminal possible for developers who want to experiment with AI without depending entirely on paid inference APIs.

Using open-weight models and browser-based inference creates opportunities to:

Experiment without requiring a paid AI API key.
Learn how AI inference can be integrated into a real web application.
Build alternative debugging workflows with greater control over application architecture.
Reduce unnecessary transmission of potentially sensitive source code.
Combine AI-generated assistance with transparent, independently implemented fallback logic.

Open-source tools also make it easier for students and independent developers to inspect, modify, extend, and share their work.

For me, the most valuable part is the freedom to experiment, learn, and build something useful without making a commercial AI service the only path forward.

👻 The Spirit of It

Programming errors can feel mysterious.

A variable disappears. A server refuses to start. An undefined value suddenly breaks an entire application.

For a moment, it feels as though something invisible is haunting your code.

That idea inspired Phantom Terminal.

Instead of treating errors as meaningless red text, I wanted to give them a personality and turn debugging into an experience that feels curious, atmospheric, and approachable.

The ghost is a metaphor for the hidden cause behind every bug.

Every error leaves a ghost behind. Your job is to discover it.

🏆 Prize Categories

This project explores browser-based open-weight AI, AI-assisted developer tooling, and an interactive debugging experience.

I will select the applicable partner prize categories according to the official challenge requirements before submitting.

🚀 What's Next?

There is plenty of room to improve Phantom Terminal:

More specialized debugging models.
Better support for additional programming languages.
Animated ghost interactions.
Downloadable debugging reports.
Expanded error-pattern libraries.
Automated browser testing and improved model-loading diagnostics.

My goal is to keep the project approachable for beginners while making it useful enough for everyday debugging experiments.

Thanks for checking out Phantom Terminal!

If you find the idea interesting, feel free to explore the repository, suggest improvements, or contribute.

Stay curious. Debug carefully. And watch out for the ghosts in your machine. 👻

LazyDesk AI: Turn Messy Notes into Clear Next Steps

Subhadip Gayen — Tue, 20 Oct 2026 06:19:49 +0000

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

What I Built

LazyDesk AI is a lightweight productivity assistant that helps turn unorganized notes into a short summary, a list of actionable tasks, prioritized next steps, and one small first action.

Sometimes, the hardest part of getting work done isn't doing the work—it's figuring out where to start. We write down ideas, deadlines, reminders, and random thoughts, but turning them into an action plan takes extra effort.

LazyDesk AI aims to make that process simpler. Users can enter their notes and get a more organized view of what to do next.

It's built for students, developers, and anyone who wants to spend less time organizing their thoughts and more time acting on them.

Demo

The project is available as source code on GitHub. A publicly deployed demo or video demo can be added here once available.

Code

Explore the complete source code:

LazyDeskAI on GitHub

The repository includes the frontend, Express server, project configuration, and README.

How I Built It

I built LazyDesk AI using a simple web stack:

HTML, CSS, and JavaScript for the user interface and task-handling logic.

Node.js and Express for the server.

Transformers.js to run an open-weight text-generation model in the browser.

Xenova/flan-t5-small as the model for generating summaries.

One of the important design choices was keeping the AI workflow lightweight. Instead of sending notes to a separate paid inference API, the model runs in the user's browser through Transformers.js. The model files need to be downloaded on the first run, so an internet connection is required for that initial download.

The app uses the model to generate a summary. JavaScript rules handle task extraction and prioritization, while the interface displays the resulting tasks and a suggested first step.

This is a practical example of combining an open-weight model with ordinary application logic rather than trying to make AI handle every part of the workflow.

Why Does Open Innovation Matter?

Open innovation makes experimentation with AI more accessible.

For a student developer working with limited computing resources, a hosted, paid inference API isn't always the ideal starting point. Using an open-weight model through Transformers.js gave me a way to experiment with AI directly in the browser without building a separate inference service.

It also makes the architecture easier to inspect and learn from. Developers can examine the model integration, modify the task-processing rules, and build on the project without depending entirely on a closed AI API.

Open innovation doesn't remove every limitation—model size, download time, browser performance, and output quality still matter. But it creates more opportunities for developers to learn, experiment, and build useful tools with fewer barriers.

My Agent Session

I haven't included an agent session link yet. I'll add one if I capture and publish a session using the challenge's supported workflow.

The Lazy Payoff

The goal is to reduce the effort required to move from a page of notes to a clear starting point.

Instead of manually rewriting notes into a separate task list, users can try LazyDesk AI to generate a summary and organize actionable items in one place.

I haven't measured a verified time-saving figure or collected formal user-testing results yet, so I won't claim a specific number of minutes saved. Measuring how much time it actually saves would be a useful next step.

Prize Categories

I'll list the applicable partner categories according to the official challenge rules once I've confirmed which ones fit this project.

SellerBoost AI: Helping Small Sellers Create Better Product Listings

Subhadip Gayen — Tue, 13 Oct 2026 04:10:22 +0000

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

What I Built

SellerBoost AI is a project focused on helping small business owners and online sellers create better product listings with less effort.

Many small sellers know their products well but may struggle to write compelling descriptions, choose searchable titles, and identify useful keywords. SellerBoost AI aims to simplify that process.

The goal is to turn a few basic product details into marketplace-ready content, including:

Product titles
Product descriptions
Key selling points
SEO-friendly keywords
Different writing styles for different audiences

The potential customers are small online sellers, home-based businesses, and entrepreneurs who want to improve their product listings without hiring a copywriter.

The long-term business idea is a simple, affordable tool that saves sellers time when preparing product listings.

Demo

demo website: SellerBoostAI

Screenshots or demo video:

Code

GitHub repository: SellerBoost-AI

The project is being developed as a lightweight web application with a simple interface designed for sellers who want to create listing content quickly.

How I Built It

I built SellerBoost AI as a web-based project, focusing on a straightforward user experience and a practical problem faced by small sellers.

The interface collects product information such as the product name, target audience, and key features. The intended workflow is to transform those details into useful listing content.

I also explored connecting the application to a hosted language model without requiring users to run a large model locally.

AI implementation status: [Describe the model and provider actually used in the tested version. If live inference is not working yet, state that clearly and do not claim that AI generation is working.]

My goal is to keep the application accessible to developers and small sellers who may not have powerful hardware or a large budget.

Why Does Open Innovation Matter?

Open innovation can make AI experimentation more accessible to independent developers and small businesses.

Open-weight models and open-source tools can give developers more flexibility to understand, adapt, and build upon AI technology instead of depending entirely on a single proprietary platform.

For a project like SellerBoost AI, that flexibility matters. The long-term goal is to make useful listing assistance affordable and accessible to sellers who cannot justify expensive software subscriptions.

This project has also helped me explore the practical challenges of building an AI-powered product, including model access, inference costs, and the trade-offs between a lightweight frontend and hosted AI services.

StudyBuddy AI: Building a Study Companion for a Friend 📚

Subhadip Gayen — Mon, 12 Oct 2026 05:12:26 +0000

The problem: Studying shouldn't feel overwhelming

Sometimes, the hardest part of preparing for an exam isn't learning a concept—it's figuring out where to start.

Long lecture notes, multiple topics, and limited revision time can make studying feel overwhelming. I wanted to explore whether a small AI-powered tool could make that process easier for a friend who struggles with revising lengthy study material.

That idea became StudyBuddy AI.

💡 The idea

StudyBuddy AI is a simple study companion that turns pasted notes into different revision formats.

Instead of reading the same notes repeatedly, a student can choose how they want to learn:

Summaries: Organize lengthy notes into key concepts and definitions.
Flashcards: Practise active recall with question-and-answer pairs.
Practice quizzes: Test understanding and review the answers.
Simple explanations: Break down difficult concepts into more approachable language.
Revision plans: Organize material into manageable study sessions.

The goal isn't to replace teachers, textbooks, or independent thinking. It's to give students another way to work with material they already have.

🤖 Open-source AI at the core

I built the interface using HTML, CSS, and vanilla JavaScript. For AI generation, the prototype connects to Ollama, which can run an open model locally on a computer.

The planned model is qwen2.5:3b.

I chose a local-first approach because study notes can contain personal information, and I wanted to explore a design that doesn't depend on a hosted AI API by default.

The application sends notes to the configured Ollama endpoint when the user requests generated material. The AI integration requires Ollama and the model to be installed and running; I will only describe it as verified after testing it successfully.

🛠️ What I built

The current prototype includes:

A responsive interface for desktop and mobile.
Five study modes.
Study-level options.
Copy and text-file export controls.
A configurable local AI endpoint.
Error messages for missing or unavailable AI services.

I also tried to keep the implementation beginner-friendly, with no frontend framework or build process required.

🌱 What I learned

This project reminded me that useful software doesn't always need to start with a huge feature list.

A focused tool that addresses one real problem can be a better starting point than an unnecessarily complicated application.

It also highlights an important limitation: AI-generated study material can contain mistakes. Students should verify important information against their original notes and course resources.

🔓 What's next?

Some features I'd like to explore next:

PDF text import.
Interactive, flip-style flashcards.
Saved study sessions.
Subject-specific revision templates.
Better accessibility and testing.
💚 Built for a friend

This project began with a simple thought: could I use open-source AI to make studying a little less stressful for someone I know?

I'm building StudyBuddy AI as a small experiment in using technology for a practical, everyday problem.

Project repository: StudyBuddy AI

This is an early prototype, and I'm looking forward to improving it through testing and feedback.

Hacktoberfest #OpenSource #AI #StudyTools

Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

Subhadip Gayen — Sat, 10 Oct 2026 07:10:01 +0000

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

What I Built

I built TouchGrass AI, an early-stage nature companion designed to encourage people to take breaks from their screens and spend more time outdoors.

The idea is simple: instead of spending more time scrolling, users can discover small outdoor missions that encourage them to explore the real world.

Features include:

Ready-made outdoor missions for quick breaks.
A simple nature journal to record observations.
A responsive interface built with HTML, CSS, and JavaScript.
An AI integration designed to generate outdoor missions using a locally running model.

The goal is to make technology a starting point for real-world experiences, rather than another reason to stay indoors.

Demo

The project is currently an early prototype. Ready-made missions can be used without connecting an AI model.

A live demo will be added after deployment.

Code
GitHub repository: TouchGrass AI

The repository contains the project source code and setup instructions.

How I Built It

I created the prototype using HTML, CSS, and JavaScript.

The AI integration is designed to use Ollama with the qwen2.5:3b model to generate outdoor missions locally. The AI connection still requires setup and testing.

The project also includes ready-made missions, so users can explore the core idea without configuring the AI component.

Why Does Open Innovation Matter?

Open innovation allows developers to experiment, learn, and build on existing work.

Using an open-weight model with local inference offers an alternative to relying entirely on hosted AI services. Depending on the setup, it can reduce recurring API costs and give users more control over where their prompts are processed.

I want TouchGrass AI to be a small example of how open-source AI can support everyday activities and encourage healthier relationships with technology.

Challenges and Learnings

One challenge was making the application useful even when the AI component is unavailable. Ready-made missions help users explore the main idea without depending on a working AI connection.

Building this prototype is also helping me learn about web development, local AI integration, and sharing projects through open source.

My Agent Session

Optional: Add a DevRelay session link if available.

Prize Categories

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

hi

Subhadip Gayen — Sat, 10 Oct 2026 06:20:24 +0000

hii

Subhadip Gayen — Sat, 10 Oct 2026 05:58:17 +0000