DEV Community: Anshika Singh

Phantom AI

Anshika Singh — Tue, 27 Oct 2026 10:32:30 +0000

👻 Phantom AI — The Haunted Story Generator

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

What I Built

Phantom AI is a spooky interactive website that brings horror stories to life through the theme of haunted machines, mysterious messages, and forgotten memories.

Users can enter their own story ideas, choose a horror mood, and generate creepy stories. The project combines a dark, neon-inspired interface with an offline story generator and an optional integration with Ollama for locally running open-weight AI models.

I chose this idea because machines are a big part of our lives, but imagining what happens when a machine starts behaving in mysterious ways makes technology feel a little spooky!

Demo

👻 Try Phantom AI:

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

Code

💻 GitHub Repository:

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

The project is built using three separate files:

index.html — Website structure
style.css — Dark theme, animations, and visual design
script.js — Story generation and interactive features

How I Built It

I built Phantom AI using HTML, CSS, and JavaScript.

HTML provides the website structure, CSS creates the spooky atmosphere with purple neon effects and floating animations, and JavaScript handles user input, horror moods, story generation, and copying stories.

The project includes a rule-based offline story generator and an optional integration with Ollama to run an open-weight language model locally.

The local AI integration is designed to generate original stories from user prompts without relying on a hosted AI API. It requires Ollama and a compatible model to be installed and running.

Why Does Open Innovation Matter?

Open innovation gives developers the freedom to experiment, customize technology, and build projects without depending entirely on closed AI services.

With locally running open-weight models, developers can explore AI while keeping prompts on their own machines instead of sending them to an external AI provider. They can also experiment with different models and change how their applications behave.

Another important part of this project is its offline story generator, which provides a basic experience without an internet connection or an AI model.

For me, this project is an opportunity to explore how open technologies can make AI more accessible, customizable, and privacy-friendly.

My Agent Session

I used AI assistance to help plan the project structure, write the HTML, CSS, and JavaScript, and prepare the project documentation.

An agent session recording can be added here if available.

The Spirit of It

Imagine opening an old computer late at night and seeing a message appear on the screen:

"YOU LEFT ME HERE."

That small moment inspired Phantom AI. I wanted to turn a simple website into an interactive experience where technology, imagination, and horror meet.

Sometimes, the creepiest stories begin with a machine that should have been switched off.

Prize Categories

This project explores the open-source AI theme through its optional local-model integration.

Add specific partner prize categories here only if the project meets their eligibility requirements.

Made with curiosity, code, and a little bit of darkness. 👻

LazyFlow AI

Anshika Singh — Tue, 20 Oct 2026 04:59:42 +0000

🦥 LazyFlow AI — Do Less, Breathe More

What if productivity wasn't about doing more, but about making everyday tasks easier?

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

💡 What I Built

Meet LazyFlow AI, a lightweight productivity assistant designed for people who want to get things done without making their day unnecessarily complicated.

We all have those days when our to-do lists feel endless, assignments seem overwhelming, and even deciding where to start takes too much energy.

LazyFlow AI is built around one simple idea: make the first step easier.

📝 Smart To-Do Planner: Add tasks, track your progress, and keep your responsibilities organized.

⚡ Lazy Mode: Break overwhelming tasks into smaller, more manageable steps.

📄 Quick Summarizer: Turn long text into a shorter version so you can review information more easily.

🌙 Wind-Down Planner: Get a gentle evening routine based on how you're feeling.

🤖 Local AI Integration: Connect an open-weight AI model through Ollama to generate personalized task breakdowns, summaries, and routines.

The goal isn't to avoid work. It's to reduce the unnecessary effort involved in organizing it.

🚀 Demo

🌐 Live Website: https://anshikasingh139.github.io/LazyFlow-AI/

Explore the dashboard, try the productivity tools, and see how LazyFlow makes everyday planning simpler.

The basic tools work directly in the browser. The generative AI features require a compatible local model and a working Ollama connection.

💻 Code

🔗 GitHub Repository: https://github.com/AnshikaSingh139/LazyFlow-AI

The project is built with three core files:

index.html — Website structure and dashboard.
style.css — Responsive layout, styling, and animations.
script.js — Task management, productivity tools, fallback logic, and optional local AI integration.

I kept the frontend lightweight so that the project is easy to understand, modify, and extend.

🛠️ How I Built It

I used HTML, CSS, and JavaScript to build the website, with a nature-inspired interface and a minimal, calming design.

For the AI component, I designed an optional integration with Ollama and Gemma 3 1B, allowing a compatible model to run locally instead of requiring every request to go through a hosted AI API.

Here's how the application works:

A user enters a task, some text, or their current mood.
JavaScript prepares a prompt for the relevant tool.
If Ollama is available and configured correctly, the application sends the prompt to the local model.
The model generates a response, which is displayed in the interface.
If local AI is unavailable, the application falls back to simpler browser-based functionality.

The fallback features are intentionally basic. For example, the summarizer uses sentence selection rather than generative AI when a model isn't available.

This approach allowed me to build a usable prototype without making a hosted AI service mandatory.

One important detail: The deployed GitHub Pages version is a static website. Local AI requests run on the user's own computer only when the local model is installed, running, and accessible to the browser.

🌍 Why Does Open Innovation Matter?

For me, open innovation is about having more control over the technology we build with.

Using an open-weight model creates opportunities to experiment with local inference, customize prompts, and explore different models without depending entirely on a proprietary AI API.

Here's why that matters for LazyFlow AI:

🔐 Privacy and control: When prompts are processed by a properly configured local model, they can stay on the user's machine instead of being sent to a hosted AI provider.

💸 Less dependence on paid APIs: The project doesn't require a paid AI API key for its basic features or its optional local-model integration.

🔧 Freedom to experiment: Developers can change prompts, try compatible models, and adapt the application to different productivity needs.

💻 Local-first possibilities: Running AI locally opens the door to more private, customizable applications and, with additional offline support, experiences that depend less on an internet connection.

Of course, local AI still uses computing resources, and the current website loads Google Fonts externally. The project isn't completely offline yet.

I wanted to explore how open-weight AI could make a small, practical tool more flexible without making the technology unnecessarily complicated.

🦥 The Lazy Payoff

Imagine opening your to-do list and seeing five tasks that all feel equally urgent.

Instead of spending extra time figuring out where to begin, LazyFlow can help turn one task into a series of smaller actions.

That is the payoff I'm aiming for: less time organizing the work, less friction getting started, and more freedom to work at your own pace.

The project is still an early prototype, so I don't have verified time-saving measurements yet. I'd love to improve it further by adding smarter task prioritization, a low-energy mode, and better offline support.

🏆 Prize Categories

Project focus:

Open-Weight AI
Local AI / Local Inference
Productivity Automation

I'll align these with the challenge's official partner categories where applicable.

🌱 What's Next?

I'd like to explore:

A dedicated Low-Energy Mode that prioritizes one manageable task.
Better AI-generated summaries.
A focus timer with flexible breaks.
Improved offline support.
More options for selecting locally installed models.

LazyFlow AI started with a simple thought: productivity tools don't always need to push us to do more. Sometimes, they should help us make things easier.

You relax. LazyFlow handles the busywork. 🦥🌿

Thanks for checking out my project!

HustleMate AI

Anshika Singh — Thu, 15 Oct 2026 17:57:13 +0000

HustleMate AI 🚀 — Your Side Hustle Partner

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

Starting a side hustle is exciting. Managing everything that comes with it? Not so much.

Freelancers, creators, and small business owners often have to write content, create product descriptions, calculate prices, and prepare client proposals—all while trying to grow their business.

I built HustleMate AI to make those everyday tasks a little easier.

💡 What I Built

HustleMate AI is an AI-powered toolkit designed to help freelancers, creators, and small business owners manage the practical side of their hustle.

Instead of switching between multiple tools, users can access several useful features from one dashboard:

✍️ AI Content Writer: Generate content ideas and drafts for your projects.
🛍️ Product Listing Generator: Create product descriptions for online stores.
💰 Pricing Calculator: Estimate prices using costs, platform fees, and a target profit margin.
📄 Client Proposal Generator: Create a starting draft for professional client proposals.
⚙️ AI Settings: Configure the local AI endpoint and model.

The goal is simple: spend less time on repetitive business tasks and more time building something valuable.

Who is it for? Freelancers, student entrepreneurs, content creators, and people exploring their first side hustle.

🌐 Demo

Try the live website:

👉 https://anshikasingh139.github.io/HustleMate-AI-/

💻 Code

The project is open source and built with HTML, CSS, and JavaScript.

🔗 GitHub Repository: https://github.com/AnshikaSingh139/HustleMate-AI-

Feel free to explore the code, suggest improvements, or contribute!

🛠️ How I Built It

I built HustleMate AI using three core web technologies:

HTML for the structure and interface.
CSS for the responsive layout and dashboard styling.
JavaScript for navigation, form handling, pricing calculations, AI requests, and output management.

For the AI-powered features, I designed the application to connect to Ollama, which allows users to run an open-weight language model locally.

The default configuration uses the qwen2.5:3b model through Ollama's local API.

This approach lets users generate content using a model running on their own machine rather than requiring a paid, cloud-hosted AI API by default.

The pricing calculator also works independently of the AI features, so users can still calculate prices without running a language model.

🌱 Why Does Open Innovation Matter?

I believe AI tools should be accessible to people who are just getting started—not only to businesses that can afford expensive subscriptions.

Open-weight models and tools such as Ollama make it possible to experiment with AI, customize the experience, and run inference locally.

For HustleMate AI, this opens up some interesting possibilities:

More control: Users can choose which supported local model to run.
Local inference: AI requests can be processed on the user's own machine when configured correctly.
Lower dependency on paid APIs: The application does not require a paid, cloud-hosted AI API by default.
Room to experiment: Developers can modify the prompts, interface, and model configuration.
Learning through building: The project gave me an opportunity to explore how open AI models can be integrated into a practical web application.

Open innovation matters because it gives more people the freedom to build, experiment, and improve technology for their own needs.

🏆 Prize Categories

Add the specific partner prize categories you are entering, based on the official challenge rules.

Building HustleMate AI has been an opportunity to explore how open-source tools and open-weight models can help people take their first steps toward building a side hustle.

It's a starting point, and there's plenty more I'd love to add.

Your hustle. Your AI. Your growth. 🚀

Hacktoberfest #OpenSourceAI #SideHustle #Ollama #BuildInPublic

Touch-Grass AI Nature Companion

Anshika Singh — Sat, 10 Oct 2026 17:42:48 +0000

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

What I Built

I built Touch-Grass-AI-Nature-Companion, an outdoor adventure companion designed to help people spend less time on screens and more time in nature.

Touch-Grass-AI-Nature-Companion AI helps users discover outdoor activities, take daily nature challenges, track their outdoor progress, and generate personalized outdoor adventure plans.

The project includes:

Outdoor activity suggestions
A 20-minute screen-free challenge timer
An outdoor activity progress tracker
An AI-powered adventure planner
A responsive interface built with HTML, CSS, and JavaScript

The goal is simple: use technology to encourage people to disconnect from their screens and reconnect with the real world.

Demo

I built and tested the project locally.

Screenshots and a video demonstration can be added here.

Code

The project uses three separate frontend files:

index.html — Website structure
style.css — Responsive styling and user interface
script.js — Timer, activity tracking, and AI integration

GitHub repository: [Add your GitHub repository link here]

How I Built It

I built Touch-Grass-AI-Nature-Companion AI using HTML, CSS, and JavaScript.

For the AI component, I chose Ollama to run an open-weight language model locally on my computer.

The AI planner is designed to generate personalized outdoor activity plans based on the user's mood, available time, and preferred location.

The project is designed to use Gemma through Ollama. The AI functionality requires the local model and Ollama service to be installed and running.

The timer and progress tracker work directly in the browser using JavaScript.

Why Does Open Innovation Matter?

Open innovation makes Touch-Grass-AI-Nature-Companion AI more accessible, flexible, and privacy-friendly.

By using an open-weight model through Ollama, I can experiment with local AI inference instead of depending on a paid, closed AI API.

This approach offers several advantages:

Privacy: Prompts can be processed locally instead of being sent to a third-party AI provider.
Flexibility: I can experiment with different compatible models.
Accessibility: Local inference can avoid per-request API charges.
Learning: Working with open AI tools helps me understand how AI applications work beyond simply calling a hosted API.

The project also demonstrates that AI can be used to encourage healthier offline habits instead of keeping people glued to their screens.

My goal is to make the screen the starting point of an outdoor adventure, not the destination.

My Agent Session

Optional: Add a DevRelay agent session if available.

Prize Categories

Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass.

Thanks for checking out Touch-Grass-AI-Nature-Companion AI! 🌿