DEV Community: Kartikey Patel

GHOST//SIGNAL 👻: The Machine Remembers — Building a Privacy-First Ghost Story Generator with Open-Source AI

Kartikey Patel — Tue, 27 Oct 2026 04:19:29 +0000

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

👻 GHOST//SIGNAL — The Machine Remembers

What if a machine could remember the stories that the world has forgotten?

What I Built

I built GHOST//SIGNAL, a spooky, terminal-inspired storytelling experience inspired by the theme Ghost in the Machine.

Imagine entering an abandoned computer lab at midnight. The screens are off, the room is silent, and suddenly a forgotten machine begins receiving signals from somewhere it cannot explain.

What would it tell you?

GHOST//SIGNAL lets users create atmospheric ghost stories by selecting a setting, entering a mysterious detail, and choosing one of three storytelling moods:

👁️ Eerie: Unsettling encounters and unexplained signals.
🕯️ Melancholic: Memories, forgotten voices, and stories that deserve to survive.
🌼 Folklore: Marigolds, old traditions, and the connection between the past and present.

The project combines a dark, futuristic interface with interactive storytelling. Its visual design takes inspiration from haunted terminals, mysterious transmissions, and the idea that memories can outlive the machines that preserve them.

The current prototype uses a lightweight JavaScript story engine. My next step is to connect it to a locally running open-weight AI model so that stories can be generated more dynamically.

Demo

Live Demo:https://kartikeypatel9621-source.github.io/Ghost_Signal/

The experience is designed to be simple:

Choose a mysterious location.
Enter a strange event or unexplained detail.
Select a storytelling mood.
Receive a ghostly transmission.
Copy the story and share it.

The static prototype can run locally without a hosted AI API. Actual AI-powered generation will require the local-model integration described below.

Code

GitHub Repository:https://github.com/kartikeypatel9621-source/Ghost_Signal.git

The project currently contains four files:

index.html — The main interface and page structure.
style.css — The dark visual theme, responsive layout, and animations.
script.js — Story generation, mood selection, and copy functionality.
README.md — Setup instructions, project documentation, and the planned local-AI integration.

I chose a simple web stack to keep the interface easy to understand, modify, and extend.

How I Built It

I built the initial prototype using HTML, CSS, and vanilla JavaScript.

The interface includes a transmission panel, interactive mood selectors, a story output area, and a copy-to-clipboard feature. The current story engine uses local templates rather than a remote generation API.

For the open-source AI direction, I plan to integrate Ollama with a compatible open-weight language model.

The intended architecture is:

User Input → Local Backend → Open-Weight Language Model → Generated Story → Browser Interface

The backend will send the user's selected setting, strange detail, and mood to the locally running model. The model's response will then appear in the interface.

My planned implementation focuses on:

Running an open-weight model locally.
Generating stories dynamically instead of relying only on predefined templates.
Keeping personal prompts on the user's own machine.
Allowing model and prompt customization.
Supporting offline inference after the required model files have been downloaded.

I have not yet completed or tested this model integration, so the current version should be considered a prototype rather than a finished AI-powered application.

Why Does Open Innovation Matter?

I think open innovation matters because AI should be something people can understand, adapt, and run—not just something they access through a closed service.

GHOST//SIGNAL explores that idea through storytelling.

Imagine turning this project into a private family-memory archive. Someone could preserve stories about their grandparents, favorite songs, family traditions, or meaningful moments without needing to upload those personal memories to an external AI provider.

With a suitable locally running open-weight model, that vision becomes more practical.

Privacy and ownership

Personal memories can be sensitive. Local inference can allow stories and prompts to remain on a device controlled by the user instead of being sent to a third-party inference service.

Freedom to experiment

Developers can change prompts, adjust storytelling rules, and experiment with compatible models. The experience does not have to remain tied to a single provider's API.

Offline possibilities

Once a model and its dependencies are installed, local inference can work without an internet connection. That could make this experience useful even when connectivity is unavailable.

Accessibility and cost control

Local inference avoids per-request charges from a hosted model API, although it still requires suitable hardware and consumes electricity. The project's basic browser prototype is also free to run.

Building something that lasts

A story archive should not disappear simply because an online service shuts down or changes its pricing. Open-source software and appropriately licensed model weights can give communities more freedom to preserve and extend their tools.

Of course, local models have trade-offs, including hardware requirements, speed, and output quality. The goal is not to claim that open models are always better. It is to give users meaningful choices about how their AI works and where their data goes.

My Agent Session

I have not yet recorded a session with DevRelay.

Once I have a completed AI integration and an actual agent session, I can add the session link or embed it here using the format required by the challenge.

The Spirit of It

The inspiration behind GHOST//SIGNAL is simple:

Not every ghost wants to scare you. Some just want to be remembered.

For Halloween, that idea becomes a machine receiving signals from an unknown source.

For Día de los Muertos, it becomes something more personal: a place where memories, stories, and traditions can be preserved and passed on.

Technology cannot replace the people we have lost, and an AI model cannot truly become someone who is gone. But technology can help us preserve the words, stories, and memories that connect generations.

I wanted to explore that boundary between something artificial and something deeply human.

Perhaps the most haunting thing a machine can say is not “I am watching you.”

Perhaps it is:

“You told me this story once. I kept it safe.”

Prize Categories

I will select the partner prize categories that match the completed implementation and the challenge's eligibility requirements.

Potentially relevant areas include open-weight models, local inference, and open-source AI tooling, depending on the final integration and the official category rules.

GHOST//SIGNAL — The Machine Remembers.

A little haunted. A little human. Built around the idea that the stories we care about should remain ours.

Hacktoberfest #OpenSourceAI #GhostInTheMachine #LocalAI #Ollama #WebDevelopment

🦥 SlowMate — Your Local AI Sidekick for a Slower, Smarter Life

Kartikey Patel — Tue, 20 Oct 2026 11:11:13 +0000

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

What I Built

🦥 SlowMate — Your Local-First AI Sidekick

SlowMate is a lightweight AI productivity assistant designed to make everyday tasks easier and less overwhelming.

We all have tasks we keep postponing, from finishing assignments and replying to messages to organizing our daily responsibilities. SlowMate helps turn those messy thoughts into small, manageable action steps so users can spend less energy figuring out where to start.

✨ Key Features

🧠 Smart Task Breakdown: Turn overwhelming tasks into simple, actionable steps.
🌿 Personalized Responses: Choose between Gentle, Focused, and Playful modes.
🔒 Privacy-Focused AI: Connect to a locally running open-weight model through Ollama.
💻 Local Inference: Process personal task descriptions on your own computer when local AI is configured.
📋 Copyable Plans: Easily copy generated plans and use them wherever you organize your tasks.
⚡ Lightweight Interface: A responsive web app built with HTML, CSS, and JavaScript.

The goal is simple: help people do less unnecessary thinking about their tasks and make starting easier.

Demo

Live Demo:https://kartikeypatel9621-source.github.io/SlowMate/

GITHUB Repo Link: [https://github.com/kartikeypatel9621-source/SlowMate.git}

The interface includes an interactive task planner, customizable response styles, and a results panel that displays the suggested action plan.

Note: The project currently includes a demo fallback. The local AI experience requires Ollama and a compatible model to be configured.

Code

GitHub Repository: [Add your GitHub repository URL here]

The project is built using:

HTML5
CSS3
Vanilla JavaScript
Ollama API for optional local AI integration
Qwen2.5 3B as the example open-weight model

The project includes index.html, style.css, script.js, and README.md.

How I Built It

I built SlowMate as a lightweight web application using HTML, CSS, and vanilla JavaScript.

The interface allows users to enter a brain-dump, choose a response style, and generate a small action plan.

For the AI component, I integrated an optional connection to Ollama, which can run compatible open-weight models locally. The example configuration uses Qwen2.5 3B.

The application sends the user's task description to the local Ollama API and asks the model to return structured JSON containing a short summary, actionable steps, and an encouraging message.

If the local model is unavailable, the application uses a rule-based fallback so users can still explore the interface.

My next step is to test the local model integration thoroughly and improve the application with additional features.

Why Does Open Innovation Matter?

Open innovation matters because productivity tools can involve personal thoughts, unfinished work, and private reminders.

Using a locally running open-weight model gives users greater control over where their data is processed. Instead of depending entirely on a hosted AI API, users can run inference on their own computers after downloading the model and configuring the required software.

It also makes experimentation easier. Developers can switch between compatible models, customize prompts, and explore different approaches without redesigning the entire application around one closed API.

Depending on the model and setup, local inference can also work without an internet connection after the necessary files have been downloaded.

For SlowMate, open AI is about more than generating suggestions. It is about building a tool that users can adapt, run locally, and potentially use without recurring per-request API costs.

My Agent Session

Not available yet.

I plan to document a future development session showing how the application is built, how local model integration works, and how the assistant turns an overwhelming task into a manageable plan.

The Lazy Payoff

SlowMate is designed to reduce the mental effort involved in deciding where to begin.

Instead of staring at a long list of unfinished tasks, users can enter their thoughts and receive a short, practical plan.

For example, a student who feels overwhelmed by an assignment can start with a five-minute action instead of trying to complete everything at once.

I haven't measured real-world time savings yet, so the current payoff is a design goal rather than a verified result.

The philosophy behind SlowMate is simple: you don't need to finish everything today; you just need an easier first step.

Prize Categories

Potentially relevant category: Open-Source AI / Local AI

I'll confirm the official partner prize categories and eligibility before finalizing this section.

🦥 SlowMate — Less overwhelm. More progress. Your AI, your pace.

SideKick AI: An Open-Source AI Assistant for Your Side Hustle

Kartikey Patel — Fri, 16 Oct 2026 07:01:34 +0000

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

✳ SideKick AI — Your Open-Source AI Business Assistant

What I Built

I built SideKick AI, a business assistant concept designed for freelancers, content creators, online sellers, and small business owners who want to spend less time on repetitive writing tasks and more time growing their businesses.

Running a small business often means writing product descriptions, creating social media posts, responding to clients, and planning marketing campaigns. These tasks take time, and relying entirely on paid AI APIs can introduce ongoing costs.

SideKick AI brings these workflows together in one simple workspace.

✨ Key Features

🛍️ Product Description Generator: Turn basic product details into structured listing drafts.
📱 Social Media Assistant: Generate caption drafts and content ideas.
✉️ Business Email Writer: Create professional email drafts and client follow-ups.
📈 Marketing Idea Generator: Brainstorm promotional campaigns and business ideas.
📋 Copy & Download: Copy generated drafts or save them as text files.

My goal is to make useful AI assistance more accessible to people building businesses with limited time and resources.

The project is currently a frontend prototype with template-based demo generation. Connecting a real open-weight AI model is the next major development milestone.

Demo

The frontend prototype can currently be run locally.

To try it:

Clone or download the project.
Open the project folder in VS Code.
Launch index.html using the Live Server extension.
Explore the workspace and try the available content-generation tools.

Live demo:https://kartikeypatel9621-source.github.io/Side-Hustle/

A deployed demo will be added once the project is ready for public testing.

Code

GitHub Repository: https://github.com/kartikeypatel9621-source/Side-Hustle.git

The project currently uses:

index.html — Website structure.
style.css — Responsive styling and interface design.
script.js — Interactive functionality, template-based demo generation, and the planned backend integration point.
README.md — Project documentation and development roadmap.

The frontend is built with HTML, CSS, and JavaScript. The proposed backend will use Python and FastAPI to connect the application to an open-weight language model.

How I Built It

I started by building the frontend with HTML5, CSS3, and JavaScript.

I designed the interface around a simple workflow: select a business task, describe the requirements, choose a writing tone, and generate a draft.

I also implemented interactive feature cards, form validation, copy-to-clipboard functionality, and text-file downloads.

The current generation mechanism uses JavaScript templates rather than an actual language model.

My next step is to build a Python and FastAPI backend and integrate a compatible open-weight model, potentially through Ollama. This would enable SideKick AI to generate responses using an actual language model rather than predefined templates.

The intended architecture is:

User → SideKick AI frontend → FastAPI backend → Open-weight language model → Generated content

I plan to evaluate the model's quality, inference speed, hardware requirements, and suitability for business-writing tasks before choosing the final implementation.

Why Does Open Innovation Matter?

I believe small businesses and independent creators should have more control over the AI tools they depend on.

Many people building a side hustle cannot justify expensive subscriptions for every tool they use. They need practical solutions that fit their budgets and workflows.

Open-weight models offer an opportunity to build AI applications with greater flexibility.

🔐 Privacy and Data Control

With a properly configured local model and backend, business information could be processed on the user's own device instead of being sent to a third-party AI provider.

💰 Cost Flexibility

Running a model locally or self-hosting it could reduce dependence on per-request API pricing. Actual savings would depend on hardware, electricity, hosting, and usage.

🔄 Freedom to Experiment

Using open-weight models would let developers compare and replace models, customize prompts, and explore different approaches without redesigning the whole application.

🛠️ Building for Specific Needs

A small online seller and a freelancer do not necessarily need the same AI workflow. Open innovation makes it easier to experiment with specialized prompts and business-specific tools.

For SideKick AI, the long-term vision is to make these advantages available to people who want practical AI assistance without being tied to a single provider.

I am still working toward implementing and testing the actual open-weight AI integration, so local inference, offline functionality, and privacy benefits are goals rather than verified capabilities of the current prototype.

Prize Categories

Theme: Side Hustle

Project focus: Open-source AI for freelancers, creators, and small businesses.

I will select any applicable partner prize categories after confirming that the completed project meets their specific requirements.

What's Next?

My next milestone is to connect an open-weight model and test SideKick AI with a real freelancer or small business owner.

I want to find out whether the tool genuinely saves time, whether the generated content is useful enough to publish after editing, and which features people would actually pay for.

Build small. Solve real problems. Keep innovation open. ✳

Thanks for checking out SideKick AI!

FRIENDLY: A Private, Local-First AI Companion Built for a Friend

Kartikey Patel — Thu, 08 Oct 2026 08:35:52 +0000

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

What I Built

I built FRIENDLY — a local-first AI companion designed for one person, not everyone.

The idea came from a simple problem: the people we care about often have their own routines, goals, stress, study/work pressure, and small everyday problems, but most AI assistants treat everyone the same.

FRIENDLY is designed to become a more personal companion by remembering useful preferences, goals, routines, and context about its user.

It can help with things like:

📚 Personalized study and productivity support
🧠 Understanding the user's goals and preferences
💬 AI conversations and everyday assistance
🎯 Tracking personal goals
📝 Remembering useful information
🌱 Personalized suggestions for the user's day
🔒 Keeping the experience local-first and privacy-focused

For this challenge, I built it around the idea of building something genuinely useful for a friend or loved one, rather than creating another generic chatbot.

The goal is simple:

An AI that knows the person it's helping — while keeping their data under their control.

Demo

The project is currently available as an interactive web prototype.

Demo: Add your deployed link here

Video Demo: Add your demo video here

The demo showcases the personalized dashboard, AI companion chat, memory system, goals, daily recommendations, and the local-first AI concept.

Code

GitHub: https://kartikeypatel9621-source.github.io/friend-ai/

The project is built with a lightweight web stack so that the interface remains easy to understand, modify, and extend.

FRIENDLY_AI/
├── index.html
├── style.css
└── script.js

How I Built It

FRIENDLY is built around the idea of open-source AI + local inference.

The frontend uses:

HTML
CSS
JavaScript
Browser local storage for personal memory
Local AI inference through Ollama
Open-weight models such as Llama, Qwen, and Mistral

Instead of sending every conversation to a proprietary cloud AI service, the project can connect to a model running locally on the user's own computer.

The architecture is intentionally simple:

User
  ↓
FRIENDLY Web Interface
  ↓
Local AI Layer
  ↓
Ollama
  ↓
Open-Weight AI Model
  ↓
Personalized Response

This also means the underlying model can be changed.

For example, the same application can potentially use different open-weight models depending on the user's hardware, requirements, or preference.

The project also includes a Demo Mode, allowing the interface to work even when a local model is not running.

Why Does Open Innovation Matter?

Open innovation is especially important for a personal AI companion because personal data is personal.

A closed AI API can be powerful, but it often means depending on a remote service, its pricing, availability, policies, and infrastructure.

With open-weight models and local inference, FRIENDLY can move much closer to a personal AI that actually belongs to the user.

Open innovation makes several things possible:

🔒 Privacy

Personal conversations, preferences, goals, and memories can remain on the user's device when local inference is used.

💻 Offline & Local Computing

A sufficiently capable laptop can run an AI model without requiring every interaction to travel to a cloud service.

🔄 Model Freedom

Users aren't locked into a single AI provider. Different open models can be tested and swapped depending on the use case.

🛠️ Customization

Developers can experiment with prompts, models, memory systems, fine-tuning, and different AI architectures.

💰 Lower Long-Term Cost

Running an open model locally can reduce dependence on per-request API costs, especially for applications involving frequent personal interactions.

For FRIENDLY, this isn't just a technical choice.

Open AI makes the core idea possible: creating a personal AI companion that can be controlled and customized by the person using it.

My Agent Session

Optional.

I will add my DevRelay agent session here if included in the final submission.

Prize Categories

Open Source AI / Open Innovation
Local AI / Privacy-focused AI
AI for Personal Productivity
Build for a Friend

🧠 🌳 TrailSense AI: Using Open AI to Get People Outdoors

Kartikey Patel — Wed, 07 Oct 2026 19:41:40 +0000

🌿 TrailSense AI — Turn Screen Time Into Green Time

This is a submission for the "Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass" (https://dev.to/challenges/hacktoberfest-week1-2026-10-05)

What I Built

TrailSense AI is an outdoor exploration companion designed to encourage people to put their phones down and actually explore the world around them.

The idea is simple:

«Use AI to make the screen the shortest part of the experience.»

Instead of endlessly scrolling or interacting with an AI chatbot indoors, TrailSense gives users real-world exploration missions such as:

🌿 Find three different leaf shapes
🐾 Find evidence of wildlife
🌸 Find something with natural symmetry
🐦 Stop and identify the sounds around you
🌳 Find evidence of something changing over time
🔎 Discover something you normally walk past

Users can complete missions, earn XP, track discoveries, maintain outdoor streaks, and generate an expedition report.

The project is aimed at students, walkers, hikers, nature enthusiasts, and anyone who wants technology to encourage more time outdoors rather than more screen time.

Demo

🌐 Live Website:
https://kartikeypatel9621-source.github.io/TrailSense-AI/

The project is fully deployed and can be explored directly in the browser.

Code

💻 GitHub Repository:
https://github.com/kartikeypatel9621-source/TrailSense-AI

The project is intentionally lightweight and currently built entirely with:

HTML
CSS
JavaScript

No React, backend, database, or build system is required for the current prototype.

How I Built It

TrailSense AI is built as a browser-first application using vanilla HTML, CSS, and JavaScript.

The frontend contains:

A futuristic outdoor exploration dashboard
AI-generated mission interface
Nature Scanner
AI companion chat interface
Voice Explorer
XP and level system
Discovery tracking
Outdoor streaks
Expedition reports
LocalStorage-based progress persistence
Responsive mobile design

Open AI Architecture

The project is designed around an open-weight AI architecture.

The JavaScript application contains dedicated integration points for connecting an open-weight language model and vision model.

The intended architecture is:

             TRAILSENSE AI
                   │
          ┌────────┴────────┐
          │                 │
      AI Explorer      Nature Scanner
          │                 │
          ▼                 ▼
   Open-weight LLM    Open-weight Vision
          │                 │
          └────────┬────────┘
                   ▼
            Outdoor Mission
                   │
                   ▼
             Real World 🌿

The AI can eventually handle tasks such as:

Generating personalized outdoor missions
Answering questions about nature
Analyzing outdoor observations
Understanding uploaded nature photographs
Creating personalized expedition summaries

The current public prototype includes the complete frontend experience and AI integration points, while the real open-weight model connection is the next development step.

Why Does Open Innovation Matter?

For TrailSense, open innovation isn't just about making something "AI-powered."

It changes how the product can work.

A traditional closed AI application might look like:

Phone
↓
User's photo / observation
↓
Closed cloud API
↓
AI provider
↓
Result

TrailSense is designed to eventually support:

Phone
↓
User's observation
↓
Open-weight model
↓
Local inference
↓
Result

This opens up several possibilities.

🔒 Privacy

Nature observations, photographs, voice recordings, and exploration data don't necessarily need to be sent to a third-party AI provider.

📡 Offline Potential

With a suitable local inference runtime and model, TrailSense can eventually work in places where there is little or no internet connectivity.

That's particularly important for hiking trails, forests, parks, and remote outdoor locations.

🔄 Model Freedom

Because the system is designed around open models, developers can experiment with different models instead of being locked into one proprietary AI provider.

🧪 Experimentation

Open models make it possible to experiment with:

Fine-tuning
Prompt engineering
Specialized nature models
Smaller models for mobile devices
Local inference
Different vision models

💸 Lower Running Costs

Local inference can eliminate recurring per-request API costs once the required model is available on the user's hardware.

The goal is therefore not simply:

«"Let's put AI into an outdoor app."»

It's:

«"Let's use open AI to build an outdoor experience where intelligence can eventually travel with the explorer instead of requiring the explorer to stay connected to a server."»

The Touch Grass Philosophy 🌱

The biggest design decision in TrailSense is that AI shouldn't become the destination.

Most AI products encourage users to spend more time interacting with a screen.

TrailSense tries to reverse that relationship.

The intended loop is:

AI gives you a mission
↓
You put the phone away
↓
You go outside
↓
You observe something
↓
You return to the app
↓
AI helps you understand it
↓
You go explore again

The screen starts the adventure.
The real world is the destination.

Prize Categories

Primary category:

🌿 Touch Grass / Open-Source AI

TrailSense is specifically designed around the Week 1 theme by using AI to encourage outdoor exploration and reduce passive screen time.

🚀 What's Next?

The current prototype is only the beginning.

My next goals are:

[ ] Connect a real open-weight LLM
[ ] Add real open-weight image recognition
[ ] Add local/offline inference
[ ] Add bird-call recognition
[ ] Add GPS-based exploration missions
[ ] Add personalized AI missions
[ ] Add real expedition history
[ ] Test TrailSense during an actual outdoor expedition
[ ] Improve the experience based on real-world usage

I'd especially like to take TrailSense outside, use it during a real walk, and document what works and what doesn't.

🌿 Final Thought

Technology doesn't always have to compete with the real world.

Sometimes, the best thing an AI can do is give you a reason to stop looking at it.

TrailSense AI — Let AI lead you outside. 🌎🌿