DEV Community: Naman Srivastava

Phantom AI — A Ghost Living Inside Your Machine

Naman Srivastava — Tue, 27 Oct 2026 17:57:06 +0000

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

🕯️ What I Built

What if a ghost lived inside your computer—not as a character in a game, but as an AI you could actually talk to?

Introducing Phantom AI, an interactive, spooky AI chatbot inspired by the mysterious atmosphere of Halloween and the Ghost in the Machine theme.

Phantom AI combines a haunted terminal-inspired interface with an AI-powered conversational experience. Users can interact with different ghost personalities, ask questions, and generate eerie stories.

The project explores how open-weight AI models can power creative applications while giving developers more control over the technology behind them.

My goal was to create something that is not just visually spooky but also demonstrates a practical use of open-source AI.

🔮 Demo

👻 Try Phantom AI:

https://namansrivastava1.github.io/Phantom-AI/

Explore the interface and experience the concept of an AI entity living inside a machine.

Note: The GitHub Pages deployment serves the frontend. AI functionality that depends on a locally running Ollama instance requires that local setup and may not work directly on the public website.

💻 Code

🔗 GitHub Repository:

https://github.com/namansrivastava1/Phantom-AI

The project uses HTML, CSS, and JavaScript for its interface and interactions, with Ollama providing a connection to a locally running AI model.

The code is intended to be a starting point for developers interested in experimenting with local AI and creative web applications.

⚙️ How I Built It

I built Phantom AI using familiar web technologies and a local AI inference approach.

Technology stack:

HTML5: Structures the chatbot interface.
CSS3: Creates the dark visual theme, glowing elements, and atmospheric effects.
JavaScript: Handles user interactions, conversation flow, and requests to the AI.
Ollama: Runs the AI model locally and exposes a local API.
Qwen3: The configured open-weight model for generating conversational responses.

The application is designed to send prompts to a local Ollama instance rather than relying on a remote AI API.

The idea is simple: the frontend creates the experience, while the locally running model brings the ghost to life.

This architecture also gives developers room to experiment with different compatible models and character instructions.

🌐 Why Does Open Innovation Matter?

For me, open innovation is about having the freedom to understand, experiment with, and adapt the technology we build upon.

Using a local AI model creates several opportunities:

🔒 Greater control over data

When configured for local inference, prompts can remain on the user's computer instead of being sent to a remote AI provider. This gives users greater control over their conversations.

🧠 Freedom to experiment

Developers can experiment with model choices, system prompts, personalities, and response behavior without tying the entire application to one proprietary AI API.

📡 Potential for offline use

After the model and required software have been downloaded, local inference can work without an internet connection, provided the application and its dependencies are available locally.

🛠️ Learning by building

Working with local AI makes the underlying architecture more tangible. Instead of treating AI as a black-box API, developers can explore how models are loaded, prompted, and integrated into applications.

There are trade-offs: local inference requires compatible hardware, model downloads consume storage, and performance depends on the model and device.

That trade-off is worth exploring because it gives developers more ownership of their applications.

🤖 My Agent Session

I used AI-assisted development to help design and build the project.

If I publish a DevRelay agent session for this project, I'll add it here so others can explore the development process.

🕯️ The Spirit of It

Halloween is a time for strange stories, unexplained signals, and things that seem to exist between the digital and the real.

Phantom AI takes that atmosphere and turns it into an interactive experiment.

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

What makes the project interesting to me is the idea that an open-weight model can be given a personality, placed inside a creative interface, and run on a developer's own machine.

Perhaps the most interesting question isn't whether a ghost can live inside a computer.

It's what we can build when the intelligence inside that computer is open to experimentation.

🏆 Prize Categories

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

This project explores the use of open-weight AI and local inference in a creative application.

🚀 Final Thoughts

Phantom AI is my experiment in combining creative frontend development with open-source AI.

I'm excited to keep improving it, explore different local models, and see what other developers can create with similar tools.

If you try the project or have ideas for making it better, I'd love to hear your feedback!

The machine is listening. 👻

SlowMate AI: Do Less. Move Forward.

Naman Srivastava — Thu, 22 Oct 2026 20:24:05 +0000

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

What I Built

Meet SlowMate AI, a local-first productivity assistant designed for people who feel overwhelmed by their to-do lists and struggle to decide where to start.

Instead of asking users to organize everything themselves, SlowMate lets them dump their thoughts, unfinished tasks, or daily responsibilities into one place. They can select their available energy level and time, and the AI turns that input into a small, realistic action plan.

What makes SlowMate useful?

Brain Dump: Write down everything on your mind without worrying about organization.
Energy-Aware Planning: Generate plans based on your current energy and available time.
Small, Actionable Steps: Break overwhelming tasks into manageable actions.
Progress Tracking: Mark steps as complete and celebrate small wins.
Local-First History: Keep recent plans in your browser using local storage.

The idea is simple: productivity shouldn't always mean doing more. Sometimes, it means making the next step easier.

Demo

🦥 Try SlowMate AI: https://namansrivastava1.github.io/SlowMate-AI/

The website provides the interface for turning a messy task list into a calmer, more manageable plan. AI generation requires Ollama and the configured local model to be running on the user's computer.

Code

💻 GitHub Repository: https://github.com/namansrivastava1/SlowMate-AI

The project is built with HTML, CSS, and JavaScript, with no frontend framework required.

Explore the repository to see how the interface, task-planning workflow, and local AI connection fit together.

How I Built It

I built SlowMate AI using three core web technologies:

HTML: Structures the application and its task-planning interface.
CSS: Creates a responsive, calming interface inspired by the slow and steady nature of a sloth.
JavaScript: Handles user interactions, local AI requests, task completion, and browser-based history.

For the AI layer, SlowMate uses Ollama to run Qwen2.5 3B, an open-weight language model, locally.

Rather than sending task descriptions to a hosted AI API, the application connects to the Ollama service running on the user's own computer. The model generates a practical plan based on the task description, energy level, and available time.

This architecture makes the project more than a static productivity dashboard: the open-weight model is responsible for the central task-planning experience.

The frontend is deployed on GitHub Pages, while AI inference runs locally. Users need to install Ollama, download the model, and configure the local browser connection before they can use AI generation.

Why Does Open Innovation Matter?

For SlowMate, open innovation is about control, privacy, and flexibility.

1. Privacy by design

Task descriptions can contain personal information about studies, work, or everyday responsibilities. Running inference locally means those descriptions do not need to be sent to a third-party AI provider.

Recent plans are also stored in the user's browser rather than in a remote application database.

2. More control over the AI

Using an open-weight model gives developers more flexibility to experiment with model versions, prompts, and local configurations instead of depending entirely on one closed AI provider.

3. Potentially lower ongoing costs

Once the model has been downloaded, local inference does not require a per-request hosted AI API fee. However, it still uses the computer's processing power and electricity, and users need hardware capable of running the model.

4. A path toward offline productivity

After the model and required software have been installed, local inference can work without an internet connection. The hosted website still needs to be loaded or available locally, and the initial setup requires downloading the necessary files.

For this project, open innovation makes a private, customizable productivity assistant possible without making a hosted AI API the center of the architecture.

The Lazy Payoff

SlowMate is built around a small but important question:

What if getting started took less effort than putting the task off?

Instead of manually sorting a long list, deciding priorities, and planning every step, users can describe the situation once and let the model suggest a manageable starting point.

The goal isn't to automate every part of life. It's to remove enough friction that taking the first step feels possible.

I haven't assigned a numerical time-saving claim because the actual benefit depends on the task and the quality of the model's output. Measuring the time required to organize a task list manually versus using SlowMate would be a useful next experiment.

What's Next?

Some improvements I'd like to explore include:

A lightweight local backend to simplify browser-to-Ollama communication.
Exporting generated plans to Markdown.
Recurring routines and task categories.
An optional focus timer for short work sessions.
Testing different open-weight models to compare planning quality and response time.

SlowMate is a small step toward a different kind of productivity: less pressure, less friction, and more realistic progress.

Slow is still a speed. 🦥

devchallenge #hf26challenge

SoloSeller AI — Your Product. Your Words. Your Local AI.

Naman Srivastava — Thu, 15 Oct 2026 09:22:04 +0000

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

What I Built

SoloSeller AI is an AI-powered product listing generator designed to help small businesses, independent sellers, and aspiring entrepreneurs create professional product listings without spending hours writing descriptions.

The Problem

Many small business owners have great products but struggle to present them effectively online. Writing compelling descriptions, identifying product highlights, and selecting relevant search keywords can be time-consuming, especially for sellers managing everything themselves.

Hiring professional copywriters or subscribing to expensive AI services isn't always practical for a small business.

The Solution

SoloSeller AI aims to simplify product listing creation using open-source AI and a clean, beginner-friendly interface.

The workflow is straightforward:

Enter your product details.
Generate a suggested product title and description.
Organize key product highlights.
Prepare relevant search keywords.
Review and customize the listing before publishing.

Who Is It For?

Small business owners selling products online.
Handmade product creators and independent sellers.
Students starting their first online businesses.
Entrepreneurs who want affordable content creation tools.

The Side Hustle Potential

SoloSeller AI could evolve into a practical tool for online sellers, with future opportunities for bulk listing generation, marketplace-specific formatting, and customizable listing templates.

The goal is to make useful AI technology accessible to sellers without requiring expensive subscriptions.

Code

💻 GitHub Repository:

https://github.com/namansrivastava1/SoloSeller-AI

The project is publicly available on GitHub for developers interested in exploring, improving, and contributing to the idea.

namansrivastava1 / SoloSeller-AI

How I Built It

SoloSeller AI uses a lightweight web technology stack with an architecture designed around locally running open-weight language models.

Technology Stack

HTML5: Provides the structure for the product listing interface.
CSS3: Creates the responsive layout, modern styling, and user experience.
JavaScript: Handles user interactions, product information, and listing generation workflows.
Ollama: Provides a way to run supported open-weight language models locally.
GitHub Pages: Hosts the static frontend.
GitHub: Supports version control and open-source collaboration.

How the AI Workflow Is Designed

The core idea is to transform basic product information into useful e-commerce content through local language-model inference.

A typical workflow involves collecting product details, preparing a structured prompt, sending it to a locally running model through Ollama, and presenting the generated content for review.

This approach allows the AI processing component to operate on the user's own computer rather than requiring a commercial cloud AI service.

Development Approach

I focused on three priorities:

Simplicity: Build an interface that small sellers can understand without technical knowledge.
Accessibility: Use familiar web technologies that are easy to maintain and extend.
Open AI architecture: Explore how locally running models can support practical business applications.

One of the important technical considerations is that GitHub Pages serves static files, while Ollama runs separately. Connecting the two requires local configuration and appropriate browser access settings.

Why Does Open Innovation Matter?

Open innovation is central to the idea behind SoloSeller AI.

Most small sellers don't need an enormous AI platform. They need a reliable tool that solves a specific problem without unnecessary complexity or recurring costs.

1. Lower Barriers to Entry

Open-weight models allow developers to experiment with AI-powered applications without depending entirely on paid inference APIs.

2. Greater Privacy and Control

With local inference, product details can be processed on the user's device instead of being sent to an external commercial AI provider.

3. Freedom to Experiment

Developers can explore different compatible models, adjust prompts, and improve the generation workflow based on real seller requirements.

4. Community-Driven Improvement

Open-source development creates opportunities for contributors to improve the interface, add languages, optimize prompts, and develop new features.

5. Practical AI for Small Businesses

The biggest opportunity isn't necessarily building another general-purpose chatbot.

It's taking powerful AI technology and making it useful for everyday problems.

SoloSeller AI explores that opportunity through product listing creation.

Open innovation matters because useful AI tools should be accessible, adaptable, and understandable — not limited to developers or businesses that can afford expensive infrastructure.

What's Next?

SoloSeller AI is an early-stage project, and there is plenty of room to improve it.

Some features I would like to explore include:

Product image understanding.
Multiple languages for local and international sellers.
Marketplace-specific listing templates.
Bulk product listing generation.
Different writing tones and brand styles.
Easier local model setup.
Exporting generated listings in reusable formats.

My long-term vision is to make SoloSeller AI a practical, affordable AI assistant for independent online sellers.

Final Thoughts

SoloSeller AI started with a simple question:

What if small online sellers could use AI to create better product listings without depending on expensive cloud services?

This project is my attempt to explore that idea using web technologies and open-source AI.

There is still more to build, test, and improve, but that's what makes open-source development exciting.

Your product. Your words. Your local AI.

If you're interested in the project, feel free to explore the repository, share feedback, or contribute!

⭐ GitHub: https://github.com/namansrivastava1/SoloSeller-AI

opensource #ai #javascript #hacktoberfest

NatureNudge AI: Less Scrolling, More Living 🌿 | An Open-Source AI Project for Touch Grass

Naman Srivastava — Fri, 09 Oct 2026 11:44:47 +0000

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

What I Built

🌿 NatureNudge AI — Less Scrolling, More Living

NatureNudge AI is a nature-inspired web application designed to help people spend less time on their screens and more time exploring the world around them.

The idea is simple: sometimes, we want to go outside but don't know what to do with the free time we have. NatureNudge turns that free time into a small outdoor adventure.

Users can choose their available time, surroundings, interests, and preferred activity intensity. The application then suggests activities such as discovering different leaf shapes, observing birds, finding natural patterns, taking a mindful walk, or caring for plants.

The website also includes an outdoor progress dashboard that tracks completed adventures, logged outdoor minutes, and consecutive days of activity.

I built NatureNudge around one principle: technology should inspire real-world experiences, not become the experience itself.

The current version includes a responsive frontend and a working demo mission generator. Integrating an open-weight AI model for dynamically generated, personalized adventures is the next step in development.

Demo

🌐 Live Website: https://namansrivastava1.github.io/NatureNudge-AI/

Explore the interface, select your preferences, generate an outdoor mission, and try the progress-tracking features.

Code

💻 GitHub Repository: https://github.com/namansrivastava1/NatureNudge-AI

The project uses HTML, CSS, and JavaScript for the frontend, with a planned Java backend and local open-weight AI integration.

Feel free to explore the code, share feedback, or suggest improvements!

How I Built It

I started with a simple question: What if AI helped people spend less time using technology?

Instead of building another chatbot that keeps users engaged with a screen, I wanted to create something that uses technology to encourage people to step away from it.

I built the frontend using:

HTML5 for the structure and content.
CSS3 for the responsive layout and nature-inspired visual design.
JavaScript for interactive preferences, demo mission generation, completion confirmation, and local progress tracking.

For the AI component, my planned architecture uses Ollama with an open-weight language model such as Qwen2.5. The intended backend will use Java and Spring Boot to connect the website to the locally running model.

The model will receive the user's preferences and generate a structured outdoor mission with a title, description, duration, and actionable steps. This will replace the current predefined demo missions.

The project is currently at the frontend prototype stage, so the local AI integration is still under development.

Why Does Open Innovation Matter?

For me, open innovation means having the freedom to understand, experiment with, and adapt the technology behind a project instead of depending entirely on a closed API.

NatureNudge could benefit from open-weight AI in several ways:

Privacy: Local inference can keep users' preferences and prompts on their own devices.
Offline potential: Once the model and application are installed, mission generation can work without an internet connection.
Flexibility: I can experiment with different models, customize prompts, and evaluate which model produces the most useful outdoor activities.
Lower API costs: Local inference avoids per-request charges from commercial AI APIs, although it still uses computing resources and electricity.
Learning and experimentation: Building the integration myself gives me an opportunity to understand how AI inference, backend development, and frontend applications work together.

These benefits depend on the final implementation. My goal is to make open-weight AI a functional part of NatureNudge rather than simply adding an AI label to a conventional website.

I also want the screen to be the shortest part of the experience. The real outcome isn't how long someone uses NatureNudge; it's whether they discover something interesting outside.

My Agent Session

This section is optional. I haven't included a session link because I don't yet have a saved DevRelay session to share.

Once I have a relevant development session, I'll add it here.

Prize Categories

Primary theme: Touch Grass 🌿

Open-Source AI: Intended entry, pending implementation of the open-weight model integration.

I'll update this section to reflect the applicable partner categories once the relevant integrations are completed.

Built with curiosity, a little code, and the belief that sometimes the best thing an app can do is tell you to put your phone away.

NatureNudge AI — Build with AI. Explore with curiosity. Live beyond the screen. 🌱