DEV Community: shivam sharma

👻 GhostWriter AI — Stories from the Other Side

shivam sharma — Wed, 28 Oct 2026 22:36:43 +0000

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

What I Built

GhostWriter AI is a horror story generator that turns a simple idea into an atmospheric nightmare.

What if the machine you trusted was hiding something? What if an abandoned computer suddenly started communicating with you? Or what if the technology surrounding you knew things it should never know?

I built GhostWriter AI to explore the unsettling boundary between artificial intelligence and horror storytelling. Users provide a story seed, choose a horror genre, select a length, and let AI bring their idea to life.

Features include:

👻 Five horror genres: Supernatural, Psychological, Cosmic, Gothic, and Tech Horror.

✍️ Custom story prompts: Turn a simple premise into an original horror story.

📖 Story continuation: Extend an existing story while maintaining continuity.

📋 Copy and download: Keep your generated stories as plain-text files.

🎃 Halloween theme switch: A circular pumpkin toggles between light and dark modes. The pumpkin glows when light mode is active.

🌫️ Atmospheric UI: A haunted-library background, drifting particles, translucent panels, and responsive layouts.

The goal was to build more than a basic AI wrapper. I wanted the experience itself to feel like entering a mysterious digital manuscript.

Demo

👻 Try GhostWriter AI: https://ghostwriterai-hectoberfect.netlify.app/

The frontend and serverless backend are deployed together on Netlify.

Try this prompt:

A thief breaks into an abandoned smart city to steal its central AI core. At midnight, every locked building announces his full name—even though he has never been there before.

Select Tech Horror, choose Short, and generate your own nightmare.

Code

🔗 GitHub repository: https://github.com/Shivam-Sharma2009/GhostWriterAI

The project is built with React, Vite, JavaScript, CSS, Netlify Functions, and the Google Gemini Developer API.

The backend handles AI requests server-side so the API key is not exposed in the browser.

How I Built It

I built GhostWriter AI using React and Vite for the interface, with Netlify Functions handling the backend requests.

The application follows this architecture:

React + Vite → Netlify Functions → Gemini Developer API

Here is how the main pieces work:

Frontend: React manages the story prompt, genre and length selections, manuscript display, loading states, and user feedback.

Serverless backend: Netlify Functions validate the input and send the generation request to Gemini.

AI generation: Gemini generates the story according to the supplied premise and selected horror style.

Story continuation: The existing story is passed to the backend so the AI can continue it with new material.

Secure configuration: The API key is stored in Netlify environment variables rather than embedded in frontend code.

Deployment: Netlify hosts the frontend and backend functions, while GitHub stores the source code.

For this implementation, I used the Gemini Developer API rather than running an open-weight model locally. The surrounding development stack uses open-source tools, but I am not claiming local inference or that Gemini itself is open-source.

Why Does Open Innovation Matter?

Open innovation makes it possible for individual developers to experiment, learn from existing tools, and turn ideas into working applications without building every component from scratch.

For GhostWriter AI, I could focus on the experience—story generation, genre-specific prompts, continuity, and the interface—while relying on established frontend frameworks, serverless infrastructure, and version control.

Public source code also makes the project easier for other developers to inspect, learn from, improve, and extend.

There is still room to take this project further: integrating an open-weight language model, adding configurable inference providers, improving rate limiting, and enabling community contributions.

I see this project as a starting point for experimentation, not the end of the journey.

The Spirit of It

The scariest part of technology is not always what it can do. Sometimes, it is what we do not understand about it.
some image are

I wanted GhostWriter AI to capture that feeling: an ordinary prompt becoming a story about a machine, a hidden presence, or something that should not exist.

And the small Halloween pumpkin? It is a reminder that even a simple interface detail can make a project feel like its own little world.

Every story starts with an idea. The machine supplies the nightmare. 🎃

Prize Categories

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

I am not claiming an additional partner prize category without verifying its eligibility requirements.

Built with curiosity, code, and a little darkness. 👻

Live demo: https://ghostwriterai-hectoberfect.netlify.app/

Source code: https://github.com/Shivam-Sharma2009/GhostWriterAI

FormSaathi AI 🇮🇳: Turning Government Notices into Clear Next Steps

shivam sharma — Sun, 25 Oct 2026 11:33:38 +0000

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

What I Built

I built FormSaathi AI 🇮🇳, a web application that helps people understand government notices, scholarship announcements, and public-service circulars without manually digging through long paragraphs.

Users can paste notice text or upload an image. The application extracts text using OCR and organizes information into important points, dates, document mentions, and practical next steps. It supports both English and Hindi.

The goal is to reduce the effort required to understand complicated notices and make important information easier to find.

Demo

🚀 Live Demo: https://formsaathi-ai-user.vercel.app/

The frontend and backend are deployed on Vercel.

Code

💻 GitHub Repository: https://github.com/Shivam-Sharma2009/FormSaathi-AI

The repository contains the frontend, Express backend, OCR functionality, and AI-provider integration.

How I Built It

I built FormSaathi AI using:

Frontend: HTML, CSS, and JavaScript
Backend: Node.js and Express.js
OCR: Tesseract.js
Deployment: Vercel
AI inference integration: Hugging Face Inference Providers with an OpenAI-compatible API interface

I wanted to develop the project without downloading large language models onto my laptop, so I chose a cloud-based workflow.

The intended AI workflow is to summarize notices, identify important dates and document requirements, and produce a numbered action checklist. The application also checks supporting evidence against the supplied notice text to help users verify the extracted details.

The open-weight model integration is currently being debugged, and live inference has not yet been verified. The deployed application uses a rule-based fallback when the inference provider is unavailable.

Why Does Open Innovation Matter?

Open innovation gives students and independent developers more opportunities to experiment with AI without requiring expensive hardware or building everything from scratch.

For FormSaathi AI, open-weight models offer the possibility of greater flexibility in model selection, inference providers, and future deployment choices.

I want to keep the project adaptable rather than permanently tied to one AI vendor. Open ecosystems make it easier to learn, experiment, and improve a project as it grows.

My Agent Session

I haven't published a DevRelay agent session for this project yet. I hope to add one as development continues.

The Lazy Payoff

Instead of manually scanning a long notice to locate dates, document requirements, and important instructions, users can use FormSaathi AI to organize the information in one place.

The first deployed version is available. My next goal is to get live open-weight inference working reliably and measure the time saved through real-world testing.

Prize Categories

I will verify the partner-specific eligibility requirements before claiming any prize category.

Built by a student developer working to make complicated public information easier to understand. 🇮🇳

Feedback and contributions are welcome!

AHGV Local AI Tutor: A Privacy-Focused AI Study Assistant

shivam sharma — Sun, 18 Oct 2026 18:31:36 +0000

AHGV Local AI Tutor: A Privacy-Focused AI Study Assistant 🎓

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

What I Built

AHGV Local AI Tutor is an AI-powered study assistant designed to help students learn from their own study materials instead of repeatedly searching through lengthy documents.

Students can provide PDF, Markdown, and text files, or paste their notes directly. The application helps turn those materials into useful learning resources.

Key features

Smart summaries: Convert lengthy study materials into concise summaries.
Revision notes: Generate structured notes for exam preparation.
MCQ generation: Create multiple-choice questions for self-assessment.
Context-aware Q&A: Ask questions about uploaded study materials and receive answers grounded in relevant content.
Lightweight retrieval: Find relevant passages using lexical retrieval before generating answers.
Student-focused workflow: Bring notes, explanations, and revision tools into one place.

The intended users are college students, independent learners, and tutors who need a practical way to organize study material and prepare for examinations.

The long-term goal is to make useful AI-assisted learning accessible without requiring students to maintain expensive hardware or purchase multiple study tools.

Demo

🌐 Project: https://ahgv-learning.vercel.app

The companion project is available online. The AHGV Local AI Tutor repository contains the code for the study-assistant implementation.

Code

💻 GitHub Repository: https://github.com/Shivam-Sharma2009/AHGV_PROJ

The project uses a React and Vite frontend with a Python FastAPI backend. Supporting technologies include Pydantic, HTTPX, PyPDF, and pytest for validation and testing.

I am building this as a practical learning project, with an emphasis on keeping the architecture lightweight and making the code understandable and extensible.

How I Built It

I built AHGV Local AI Tutor around a simple workflow:

Input: Accept study material from PDF, Markdown, text files, or pasted notes.
Processing: Extract and prepare the text for retrieval.
Retrieval: Identify relevant passages using lexical matching.
AI assistance: Use the retrieved context to support summaries, revision material, quizzes, and question answering.
Output: Present the results in a student-friendly interface.

The frontend uses React 19 and Vite. The backend uses FastAPI and Uvicorn, with Pydantic for data validation, HTTPX for HTTP communication, and PyPDF for PDF processing.

My goal is to support open-weight AI models while keeping the application practical on limited hardware. Because my laptop has limited storage, running a local model through Ollama has been a constraint. I am exploring lightweight deployment options rather than requiring every student to download a large model.

The next step is to make the open-weight inference path fully reproducible and document the model and deployment requirements clearly.

Why Does Open Innovation Matter?

Open innovation makes AI development more accessible to students and independent developers who do not have access to expensive GPUs or large cloud budgets.

For a project like AHGV Local AI Tutor, open-weight models can provide greater control over model selection, deployment, and customization. They

AHGV Learning: Turn Any Lecture Into Your Personal AI Tutor 🎓

shivam sharma — Fri, 16 Oct 2026 13:11:24 +0000

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

What I Built

AHGV Learning — Your Personal AI Lecture Tutor 🎓

Students often spend hours watching online lectures but still struggle to understand difficult concepts, find specific explanations, and revise what they have learned.

AHGV Learning is an AI-powered interactive learning assistant that helps students learn from YouTube lectures. It brings lecture-based question answering and revision tools into a single learning workspace.

With AHGV Learning, users can:

🎥 Load YouTube lectures with available captions.
💬 Ask questions about lecture content and receive AI-generated explanations.
⏱️ Use transcript timestamps to connect answers with lecture material.
🧠 Generate multiple-choice quizzes for revision.
📝 Extract key points from lectures.
🔐 Create an account and sign in using Supabase authentication.

The project is designed for college students, self-learners, tutors, and educators. Potential customers include individual learners, coaching centres, and educational content creators who need more interactive learning tools.

The goal is simple: help students understand what they watch, not just finish watching it.

Demo

🚀 Live application: https://ahgv-learning.vercel.app

The frontend is deployed on Vercel, and the Python backend is deployed on Render.

Note: YouTube caption retrieval depends on caption availability and access restrictions. Some videos may not load successfully in the hosted environment.

Code

💻 GitHub repository: https://github.com/Shivam-Sharma2009/AHGV_PROJ

The project is built with a separate frontend and backend, making it easier to maintain and extend its learning features.

How I Built It

I built AHGV Learning using a modern web stack with AI-powered transcript processing.

Technology stack:

Frontend: React, Vite, JavaScript, CSS
Backend: Python, FastAPI, Uvicorn
AI integration: Google Gemini API
Authentication: Supabase Auth
Frontend hosting: Vercel
Backend hosting: Render

The application retrieves available YouTube captions and uses transcript context to support question answering. The backend includes timestamp-aware transcript retrieval and uses Gemini to generate explanations, quizzes, and key points.

The frontend communicates with the FastAPI backend through HTTP API requests, while Supabase manages authentication.

One of the main engineering challenges is making transcript retrieval reliable in a hosted environment, where external services may restrict requests from cloud-provider IP addresses.

Why Does Open Innovation Matter?

Open innovation allows developers to learn from existing technologies, share improvements, and build useful applications without reinventing every component.

For an educational project like AHGV Learning, open development can encourage contributions to transcript processing, accessibility, multilingual learning, documentation, and the overall user experience.

It also creates opportunities to experiment with alternative AI models and inference approaches as the project evolves.

My vision is to make lecture-based learning more interactive, accessible, and adaptable to different learning needs.

Project: AHGV Learning

Live demo: https://ahgv-learning.vercel.app

Source code: https://github.com/Shivam-Sharma2009/AHGV_PROJ

devchallenge #hacktoberfest #opensource #AI #education #react #python

Sport fit

shivam sharma — Tue, 06 Oct 2026 11:10:01 +0000

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

What I Built

I built SportFit, a gamified, AI-powered web platform designed to motivate people to step away from their screens, get active, and explore their surroundings.

SportFit gets people into the real world through features like AR Campus Quests, which gamify real-world walking by assigning location-based missions, and FitCoin Rewards, which incentivizes users to work out in groups using GPS. It also includes an AI Form Guard to ensure users are exercising safely and effectively wherever they are.

This platform is for anyone looking to build healthier habits, from students exploring their campus to fitness enthusiasts wanting real-time form correction. Crucially, it includes a dedicated PW Care and Accessibility section with an AI Voice Coach, ensuring that fitness and movement are accessible to physically challenged individuals and those relying on screen readers or voice navigation.

Demo

sportfit-innovexa-the-techlets.vercel.app

Code

https://github.com/Shivam-Sharma2009/sportfit-innovexa-the-techlets

How I Built It

SportFit is built using vanilla HTML, CSS, and JavaScript, prioritizing a lightweight, accessible, and responsive user experience.

To bring the project to life, I integrated several open-source technologies:

AI Form Guard (Open-Source Local Inference): I utilized the open-source Human.js library, which runs TensorFlow.js pose-detection models entirely locally in the browser. This powers a real-time exercise counter and form corrector (for push-ups, squats, lunges, and curls) using local webcam inference without any server latency.
AI Voice Coach: I leveraged the browser's native Web Speech API and SpeechSynthesis to create a hands-free, interactive voice coach that guides users through workouts and allows them to navigate the platform using voice commands.
Gamification & Logic: Custom JavaScript handles the logic for the AR Campus Quests and Fatigue Detection modules.

Why Does Open Innovation Matter?

Open innovation is the backbone of SportFit. By using open-source libraries like Human.js that execute models locally, I was able to build a privacy-first application. Users' webcam feeds never leave their devices, ensuring complete privacy during their workouts.

This local inference approach also means zero network latency, which is critical for real-time form correction. A closed API would have introduced lag, required ongoing subscription costs, and raised massive privacy concerns regarding video data. Open-source AI made it possible to deliver a premium, responsive, and secure fitness coaching experience directly in the browser.

My Agent Session

Prize Categories

Week 1: Touch Grass
Maintainer/Contributor (if applicable)