DEV Community: Sandeep Verma

GhostCode 👻 — Resurrecting Forgotten Code with Gemma 4

Sandeep Verma — Fri, 30 Oct 2026 17:10:03 +0000

GhostCode 👻 — Resurrecting Forgotten Code with Gemma 4

Submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

👻 What I Built

What if forgotten code could tell its own story?

Every line of code has a purpose, but over time, many software projects become abandoned, undocumented, or difficult to understand. Valuable algorithms get buried inside forgotten repositories, outdated programming practices make maintenance challenging, and developers often spend hours trying to understand someone else’s code.

For Hacktoberfest 2026 Week 4, themed “Ghost in the Machine,” I wanted to explore a different interpretation of the theme.

Instead of building a traditional Halloween chatbot, I decided to bring forgotten technology back to life.

That’s how GhostCode was born.

🚀 Introducing GhostCode

GhostCode is an AI-powered code archaeology and modernization platform that helps developers understand, explore, and revive legacy source code using Google’s Gemma 4 open-weight AI model.

It transforms confusing or outdated code into understandable explanations and suggests modern improvements.

The idea is simple:

Paste → Analyze → Understand → Modernize

✨ Key Features

👻 1. Code Resurrection

Users can paste or upload source code and let Gemma 4 analyze it.

GhostCode explains the code’s purpose, identifies important functionality, and provides suggestions for improvement.

🔍 2. AI Code Archaeologist

GhostCode helps uncover the logic hidden inside old or undocumented programs.

It can explain functions, identify potentially outdated programming practices, and highlight possible compatibility issues.

⚡ 3. Modernization Lab

This feature helps developers transform legacy code into cleaner, more maintainable implementations.

Users can compare original code with AI-generated modernization suggestions and understand the reasoning behind the changes.

💬 4. Ghost Chat

An interactive AI assistant that allows users to ask questions about their source code.

For example:

What does this function do?
Why is this code outdated?
How can I improve this algorithm?
Can you explain this code to a beginner?

GhostCode uses the provided source code as context to generate relevant explanations.

🎨 5. Futuristic Developer Experience

GhostCode features a modern developer-focused interface with a dark futuristic theme, glowing accents, interactive code panels, and subtle Halloween-inspired visuals.

The design reflects the challenge’s mysterious atmosphere while keeping the application practical and accessible.

🎯 The Problem It Solves

Developers frequently encounter code that is difficult to understand because of missing documentation, outdated syntax, or unfamiliar programming patterns.

GhostCode aims to reduce that barrier by making code exploration more approachable.

It is designed for students, beginner programmers, open-source contributors, and developers working with legacy projects.

The goal isn’t just to generate better code.

It’s to help developers understand the code they’re working with.

⸻

🎥 Demo

GhostCode runs locally with Gemma 4 through Ollama.

The demonstration showcases the complete code resurrection workflow:

Open the GhostCode application.
Paste or upload legacy source code.
Analyze the code using Gemma 4.
Explore the AI-generated explanation.
Generate modernization suggestions.
Ask follow-up questions through Ghost Chat.

The project demonstrates how a locally running open-weight model can support practical software development tasks without requiring a paid AI API.

⸻

💻 Code

GhostCode is developed as an open-source project.

GitHub Repository: https://github.com/sandeepji11/GhostCode

The repository contains the frontend, backend, AI integration, and instructions for running the application locally.

The project is designed to be accessible to developers who want to explore local AI-powered programming tools.

⸻

🛠️ How I Built It

I built GhostCode using a combination of modern web technologies and locally hosted open-weight AI.

🧠 AI Model — Google Gemma 4

At the heart of GhostCode is Google Gemma 4 2B, running locally through Ollama.

The model powers the application’s code analysis, explanations, modernization suggestions, and contextual chat capabilities.

Rather than depending on a proprietary cloud API, GhostCode sends requests to a locally hosted model.

This makes it possible to experiment with AI-powered development workflows while retaining greater control over how source code is processed.

⚙️ Technology Stack

Component Technology
Frontend React + Vite
Styling Tailwind CSS
Backend Python + FastAPI
AI Model Google Gemma 4 2B
AI Runtime Ollama
API Communication REST APIs
Development Environment Visual Studio Code
AI Coding Assistance GitHub Copilot
Version Control Git + GitHub

🔄 How GhostCode Works

The application follows a straightforward architecture:

Step 1 — Code Input

The user pastes or uploads source code through the React frontend.

Step 2 — Backend Processing

The frontend sends the code and selected operation to the FastAPI backend.

Step 3 — AI Analysis

The backend prepares a task-specific prompt and communicates with the locally running Gemma 4 model through Ollama.

Step 4 — AI Response

Gemma 4 generates an explanation, analysis, modernization suggestion, or answer to a question.

Step 5 — Results

The backend returns the response to the frontend, where the user can review the results.

🧩 System Architecture

         ┌─────────────────────┐
         │       USER          │
         │  Paste/Upload Code  │
         └──────────┬──────────┘
                    │
                    ▼
         ┌─────────────────────┐
         │   React Frontend    │
         │   GhostCode UI      │
         └──────────┬──────────┘
                    │
                    ▼
         ┌─────────────────────┐
         │   FastAPI Backend   │
         │   Python REST API   │
         └──────────┬──────────┘
                    │
                    ▼
         ┌─────────────────────┐
         │       Ollama        │
         │  Local AI Runtime   │
         └──────────┬──────────┘
                    │
                    ▼
         ┌─────────────────────┐
         │    Gemma 4 2B       │
         │   Code Analysis     │
         │   Modernization     │
         │   Contextual Chat   │
         └──────────┬──────────┘
                    │
                    ▼
         ┌─────────────────────┐
         │   AI-Generated      │
         │      Results        │
         └─────────────────────┘

🤖 Building with GitHub Copilot

I developed GhostCode independently using Visual Studio Code and GitHub Copilot as my AI coding assistant.

Copilot helped accelerate frontend development, backend implementation, and integration work.

However, the application itself is powered by Gemma 4 through Ollama.

This distinction is important: GitHub Copilot assisted with development, while Gemma 4 performs the application’s core AI tasks.

💡 Technical Approach

I focused on creating a complete user workflow rather than building a generic chatbot.

Each major AI feature serves a different purpose:

Code Resurrection focuses on understanding source code.
Code Archaeologist explores implementation details.
Modernization Lab suggests improvements.
Ghost Chat enables interactive learning.

Together, these features create a practical AI-powered code exploration experience.

⸻

🌍 Why Does Open Innovation Matter?

Open innovation is central to GhostCode.

Many AI-powered development tools depend on proprietary APIs, external servers, or usage-based pricing.

While those services can be useful, they can also introduce barriers for students, independent developers, and open-source contributors.

Using Gemma 4 through Ollama allowed me to explore a different approach.

🔐 1. Greater Control Over Source Code

Source code can contain sensitive business logic or unpublished work.

With local inference, GhostCode can process code on the user’s own machine without sending it to an external AI inference provider.

This offers developers greater control over their data.

💸 2. No Per-Request AI API Fees

GhostCode does not require a paid cloud AI API.

Once the model and dependencies are installed, users can run AI inference locally without per-request API charges.

Local computing resources and electricity are still required.

🧑‍💻 3. Accessibility for Students

As a student developer, I believe powerful AI tools should be accessible to people who are learning to code.

Open-weight models make it possible to experiment with AI applications without immediately depending on commercial AI services.

⚙️ 4. Customization and Experimentation

Open-weight models provide opportunities to experiment with prompts, inference settings, and local deployment.

Developers can customize the application for different programming languages and code analysis tasks.

🤝 5. Supporting Open-Source Development

GhostCode is inspired by the idea that useful software should not be forgotten simply because it is old or poorly documented.

By helping developers understand legacy code, tools like GhostCode can support learning, maintenance, and contributions to existing projects.

Open innovation made it possible to build GhostCode around a locally controlled AI model rather than making external AI services a requirement.

⸻

👻 The Spirit of It

The theme “Ghost in the Machine” immediately made me think about abandoned software.

Somewhere on GitHub, there are repositories that haven’t been updated in years.

Their original developers may have moved on, their documentation may be incomplete, and their code may no longer run on modern systems.

But those projects can still contain valuable ideas.

I wanted GhostCode to explore a simple question:

What if we could give forgotten code a second life?

Imagine discovering an old Python script.

At first glance, its syntax looks unfamiliar.

You paste it into GhostCode.

Gemma 4 explains what it does, identifies outdated practices, and suggests how the same idea could be implemented today.

Suddenly, something that seemed difficult to understand becomes approachable.

For me, that’s the spirit of this project.

The ghost isn’t a supernatural character.

The ghost is the knowledge hidden inside forgotten code.

And AI helps us rediscover it.

⸻

🚀 Future Scope

GhostCode is an initial step toward a more comprehensive AI-powered code archaeology platform.

Future improvements could include:

GitHub Repository Analysis

Analyze complete repositories instead of individual source files.

AI-Generated Documentation

Automatically create documentation for undocumented projects.

Interactive Code Evolution Timeline

Visualize how programming practices and implementations have evolved.

Multi-File Code Understanding

Analyze relationships between functions and modules across a project.

Automated Test Suggestions

Generate suggested tests for modernized code.

Expanded Language Support

Improve analysis for additional programming languages.

Local Model Selection

Allow developers to choose between compatible open-weight models based on their hardware.

These improvements could make GhostCode more useful for open-source maintainers and developers working with complex legacy systems.

⸻

🏆 Prize Categories

I am submitting GhostCode for:

Best Use of Gemma

GhostCode uses Google’s Gemma 4 open-weight model as the foundation of its AI functionality.

The model is central to code analysis, modernization, and interactive explanations rather than being an optional addition.

⸻

🙌 Final Thoughts

Building GhostCode for Hacktoberfest 2026 was an opportunity to combine open-source AI, software development, and a creative interpretation of the challenge theme.

I wanted to build something that was more than a Halloween-themed interface.

I wanted to create a tool that could help developers learn from the past and make older software easier to understand.

GhostCode represents that idea.

Because sometimes, the best way to build the future is to resurrect the past. 👻

Thanks to the Hacktoberfest and DEV Community organizers for creating this challenge and encouraging developers to experiment with open-source AI.

Built with React, FastAPI, Ollama, and Gemma 4.

Developed with assistance from GitHub Copilot.

Made for Hacktoberfest 2026 — Ghost in the Machine.

⸻

Hacktoberfest #OpenSource #Gemma #AI

🦥 SlothOS AI — Work Less, Live More: A Privacy-First Productivity Assistant Powered by Local Gemma 3

Sandeep Verma — Fri, 23 Oct 2026 12:55:02 +0000

🦥 SlothOS AI — Work Less, Live More! | A Local AI Productivity Assistant

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

What I Built

🦥 Meet SlothOS AI — Your AI-Powered Productivity Companion!

What if being lazy could actually make you more productive?

We spend a surprising amount of time doing repetitive digital tasks: organizing files, reading lengthy documents, creating task lists, and figuring out what to do next.

These activities are important, but they shouldn’t require so much manual effort.

That’s why I built SlothOS AI, a privacy-conscious, local-first productivity assistant powered by Gemma 3 (1B) through Ollama.

SlothOS brings multiple AI-powered productivity tools into a single dashboard, helping users automate everyday tasks without depending on a paid cloud AI API.

The philosophy behind the project is simple:

🦥 Work Less. Live More. Let AI Handle the Boring Stuff!

🎯 The Problem I’m Solving

Students, developers, and professionals regularly face repetitive tasks:

📂 Manually organizing files and documents.
📄 Reading lengthy PDFs to identify important information.
📝 Converting unstructured notes into actionable tasks.
⏰ Deciding which tasks should be prioritized.
🔄 Switching between multiple productivity applications.

These activities take time away from learning, creativity, and meaningful work.

SlothOS AI aims to reduce that busywork through local AI automation.

🚀 Key Features

🗂️ 1. Smart File Organizer — Say Goodbye to Digital Clutter!

Have you ever opened your Downloads folder and wondered how it became so messy?

SlothOS AI helps users organize uploaded files through AI-powered classification.

How it works:

Upload files to SlothOS.
The backend analyzes the files.
Gemma 3 suggests appropriate categories.
Preview the organization suggestions.
Apply the organization to local file copies.

Example:

Before:

Downloads/
├── notes.pdf
├── assignment.py
├── screenshot.png
├── project_report.pdf
└── tasks.txt

After:

Organized/
├── Documents/
│ └── project_report.pdf
├── Study Materials/
│ └── notes.pdf
├── Programming/
│ └── assignment.py
├── Images/
│ └── screenshot.png
└── Other/
└── tasks.txt

These categories illustrate the intended workflow; actual suggestions depend on AI classification.

🦥 Lazy Benefit: Less manual file sorting and a cleaner digital workspace.

📄 2. AI Document Summarizer — Read Less, Understand More!

Reading lengthy documents can be time-consuming, especially when you’re only looking for important information.

SlothOS AI uses local AI to generate concise summaries of text-based PDF documents.

How it works:

Upload a PDF document.
PyMuPDF extracts the text.
FastAPI sends the relevant text to Gemma 3 through Ollama.
The model generates a summary.
SlothOS displays the result.

What it helps with:

Understanding lecture notes.
Reviewing project documentation.
Summarizing technical reports.
Identifying important concepts.

🦥 Lazy Benefit: Spend less time searching through documents and more time understanding their contents.

🧠 3. Lazy Task Planner — Turn Chaos into Clarity!

Sometimes the hardest part of being productive is figuring out where to begin.

The Lazy Task Planner converts natural-language notes into structured tasks with suggested priorities.

Example input:

I need to complete my Python assignment, prepare for my robotics interview, finish my presentation, and revise mathematics.

Example output:

Task Priority
Prepare for robotics interview 🔴 High
Complete presentation 🔴 High
Finish Python assignment 🟡 Medium
Revise mathematics 🟡 Medium

The priorities are suggestions generated by the model.

🦥 Lazy Benefit: Less time manually creating and prioritizing task lists.

🦥 4. Sloth Mode — One Click, Multiple Insights!

Sloth Mode is the feature that best represents the theme of this challenge.

Instead of manually reading a document, summarizing it, identifying tasks, and deciding what to do next, users can upload a PDF and request multiple AI-generated insights.

Sloth Mode is designed to provide:

📄 A concise document summary.
✅ Important action items.
🎯 Suggested priorities.
🚀 Recommended next steps.

One document. One workflow. Multiple useful insights.

🦥 Lazy Benefit: Reduce the repetitive analysis required to turn information into action.

👥 Who Can Benefit?

🎓 Students: Summarize study materials, organize assignments, and plan tasks.

💻 Developers: Organize files, review documentation, and structure development work.

👨‍💼 Professionals: Summarize reports, identify action items, and organize daily activities.

🦥 Everyone Else: Spend less time managing digital clutter.

⸻

Demo

📸 SlothOS AI — Application Screenshots

SlothOS AI currently runs locally using React, FastAPI, Ollama, and Gemma 3.

Instead of a deployed demo or video, I’m sharing screenshots of the application along with the GitHub repository, which includes instructions for running it locally.

🖥️ 1. Main Dashboard

The SlothOS dashboard provides a central interface for accessing the AI-powered productivity tools.

It also displays the connection status of the local AI backend.

📄 2. AI Document Summarizer

The Document Summarizer allows users to upload text-based PDFs and generate summaries using local AI.

🗂️ 3. Smart File Organizer

The Smart File Organizer provides AI-generated file categories and a preview of the proposed organization.

🧠 4. Lazy Task Planner

The Lazy Task Planner converts unstructured notes into actionable tasks with suggested priorities.

🦥 5. Sloth Mode

Sloth Mode analyzes PDF documents to generate summaries, action items, and suggested priorities.

🔗 Explore the Project

GitHub Repository: SlothOS AI — Source Code and Setup Instructions

The repository contains the project code, installation instructions, and technical documentation.

⸻

Code

💻 SlothOS AI — GitHub Repository

🔗 View SlothOS AI on GitHub

SlothOS AI is built using a React frontend, a Python FastAPI backend, and Gemma 3 running locally through Ollama.

📂 Project Structure

SlothOS-AI/
│
├── backend/
│ ├── main.py
│ ├── requirements.txt
│ └── workspace/
│
├── frontend/
│ ├── public/
│ ├── src/
│ │ ├── App.jsx
│ │ ├── index.css
│ │ └── main.jsx
│ ├── package.json
│ └── vite.config.js
│
├── .gitignore
└── README.md

⚡ Run SlothOS AI Locally

Step 1: Clone the repository

git clone https://github.com/sandeepji11/SlothOS-AI.git
cd SlothOS-AI

Step 2: Install the AI model

Install Ollama, then run:

ollama pull gemma3:1b

Make sure Ollama is running.

Step 3: Start the backend

cd backend
python3 -m venv venv
source venv/bin/activate
python -m pip install -r requirements.txt
python -m uvicorn main:app --reload --host 127.0.0.1 --port 8000

Step 4: Start the frontend

Open another terminal from the project root:

cd frontend
npm install
npm run dev -- --port 5175

Step 5: Open SlothOS AI

Visit:

http://localhost:5175

The complete setup instructions are available in the GitHub README.

⸻

How I Built It

🧠 Building a Local-First AI Productivity Assistant

For this project, I wanted to explore how open-weight AI models could power useful productivity applications without relying on a cloud-based language model API.

I selected Gemma 3 (1B) and used Ollama to run the model locally.

The application is divided into three main components:

React Frontend: Provides the interactive dashboard and productivity tools.
FastAPI Backend: Handles document processing, file operations, API requests, and communication with the AI model.
Ollama + Gemma 3: Performs local AI inference for summarization, classification, task extraction, and document analysis.

🏗️ System Architecture

              👤 USER
                 |
                 v
         🖥️ React Dashboard
                 |
                 v
         ⚙️ FastAPI Backend
                 |
      +----------+----------+
      |          |          |
      v          v          v
  File Tools   PDF Tools  Task Tools
      |          |          |
      +----------+----------+
                 |
                 v
           🤖 Ollama
                 |
                 v
         🧠 Gemma 3 (1B)
                 |
                 v
          AI-Generated
             Results
                 |
                 v
         🖥️ React Dashboard

🛠️ Technology Stack

Technology Purpose
React Frontend dashboard
Vite Frontend development
Tailwind CSS Interface styling
Lucide React UI icons
Axios API communication
Python Backend processing
FastAPI REST API
Ollama Local AI inference
Gemma 3 (1B) AI language processing
PyMuPDF PDF text extraction
GitHub Source code and collaboration

⚙️ How It Works

Step 1 — User Input

Users upload files, submit PDFs, or enter natural-language notes through the React interface.

Step 2 — Backend Processing

FastAPI receives the request and prepares the information for processing.

For PDF documents, PyMuPDF extracts the text.

For file organization, the backend analyzes uploaded files and prepares classification information.

Step 3 — Local AI Inference

FastAPI communicates with Ollama, which runs Gemma 3 locally.

The model processes the input and generates a response.

Step 4 — Structured Results

The backend returns the AI-generated information to the frontend.

Step 5 — User Review

The user reviews the generated summary, task list, or organization suggestions.

💡 Why I Chose Gemma 3 (1B)

I wanted a relatively lightweight model that could run locally and support practical AI workflows.

Gemma 3 (1B) allowed me to experiment with:

Local text generation.
Document summarization.
Natural-language task extraction.
AI-powered file classification.
Structured document insights.

Using a smaller model also introduces limitations, including response quality and context constraints. Those trade-offs are part of what I wanted to explore through this project.

🧩 Challenges During Development

One challenge was integrating the React frontend with the Python FastAPI backend.

Because both applications run on different local ports, I needed to configure the API communication and CORS settings correctly.

Another challenge was integrating the local Gemma model through Ollama and ensuring the backend could detect whether the model was available.

I also had to handle PDF text extraction, file uploads, and AI-generated responses in a way that made sense for each productivity feature.

Working through these challenges helped me understand how to build an AI-powered full-stack application around local inference.

⸻

Why Does Open Innovation Matter?

🔓 Making AI More Accessible, Private, and Customizable

Open innovation played a central role in building SlothOS AI.

I wanted to create an application where AI processing could happen on the user’s computer rather than requiring every request to be sent to a remote service.

Using Gemma 3 through Ollama made this possible.

🔒 1. Greater Control Over Privacy

SlothOS processes AI requests locally.

This means documents can be analyzed without sending their contents to an external AI inference provider.

For an application designed to handle notes, assignments, and personal documents, this is an important advantage.

Local processing doesn’t guarantee complete security, but it reduces dependency on external AI services.

🌐 2. Offline AI Capabilities

Once Ollama and Gemma 3 are installed, the core AI features can operate without an internet connection.

This makes local-first AI applications useful in environments with limited connectivity.

💰 3. Reduced API Costs

Local inference avoids recurring per-request cloud AI fees.

For students and independent developers, this can make experimentation more accessible.

The trade-off is that the model uses local computing resources.

🛠️ 4. Freedom to Experiment

Using a locally running model allows me to experiment with prompts, model configurations, and application workflows.

I can modify how SlothOS processes documents, generates tasks, or classifies files without depending on a proprietary cloud AI endpoint.

🤝 5. Community Collaboration

By publishing the project on GitHub, I can share the implementation, receive feedback, and welcome contributions.

Developers can explore the architecture and suggest improvements.

🌍 Why This Matters to Me

I believe useful AI tools should be approachable for students, developers, and people who want more control over their applications.

Not every AI project needs a large cloud-hosted model.

Sometimes, a smaller local model can be a useful starting point for solving everyday problems.

SlothOS AI is my attempt to demonstrate that idea through practical productivity workflows.

Note: Gemma is an open-weight model distributed under its own terms, rather than under a conventional open-source software license.

⸻

The Lazy Payoff

🦥 Less Busywork. More Meaningful Work.

The goal of SlothOS AI is not to eliminate work.

It’s to reduce repetitive activities that consume time and attention.

Here’s how the application is designed to help:

Task Traditional Approach SlothOS Approach
Organizing files Manually inspect and sort files AI-generated categories and organization
Summarizing PDFs Read and manually identify key points AI-generated document summaries
Planning tasks Manually structure and prioritize notes AI-generated tasks and priorities
Reviewing documents Summarize and identify next steps separately Sloth Mode combines multiple insights

🎯 What Makes It Lazy?

SlothOS reduces the number of manual steps required to organize information.

Instead of switching between different tools, users can access multiple AI-powered productivity features from one dashboard.

The project is designed to help students spend more time learning, developers spend more time building, and professionals spend less time on repetitive document processing.

I haven’t measured exact time savings yet, so I don’t want to claim an unsupported percentage or number of hours saved.

However, the workflows demonstrate how local AI can reduce repetitive steps.

💡 My Biggest Takeaway

The best productivity tools don’t just help us do more. They help us spend less effort on repetitive tasks.

That is the kind of laziness I wanted to reward.

⸻

Final Thoughts

🦥 Work Less. Live More.

Hacktoberfest Week 3 challenged developers to build something that rewards laziness.

I interpreted that challenge as an opportunity to simplify everyday digital workflows using local AI.

Through SlothOS AI, I explored how Gemma 3, Ollama, React, and FastAPI could work together to build a productivity assistant that supports file organization, document summarization, task planning, and document analysis.

This project also helped me learn more about full-stack development, local AI inference, and the practical trade-offs of smaller language models.

SlothOS is still an evolving project, and I plan to continue improving its functionality, reliability, and user experience.

🚀 What’s Next?

Future improvements include:

Support for larger PDFs.
Persistent task storage.
More flexible file organization.
Support for additional local AI models.
Improved automation workflows.
Better error handling and testing.
A possible desktop application.

⭐ Explore SlothOS AI

GitHub Repository: SlothOS AI

Built by: Sandeep Verma

Challenge: Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady

Thanks for reading!

If you find SlothOS AI interesting, feel free to explore the repository, share feedback, or suggest improvements.

🦥 Work Less. Live More.

⚡ SellSpark AI: Building a Local AI Product Listing Generator with Qwen 2.5

Sandeep Verma — Sun, 18 Oct 2026 11:37:06 +0000

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

⚡ SellSpark AI — Turn Product Details Into Powerful Listings

What I Built

I built SellSpark AI, an AI-powered product listing generator designed to help small businesses, freelancers, and independent online sellers create professional marketing content quickly and efficiently.

🎯 The Problem

Small online sellers often struggle to create attractive product descriptions, engaging social media captions, and effective marketing content.

Writing these manually takes time, while hiring professional copywriters or subscribing to paid AI services can be expensive for small businesses.

💡 The Solution

SellSpark AI transforms basic product information into ready-to-review marketing content using a locally running open-weight AI model.

Users simply enter their product details, select their preferred writing style and selling platform, and let AI generate the content.

✨ Key Features

🛍️ AI Product Titles: Generates attractive product titles.
📝 Product Descriptions: Creates professional marketing descriptions.
⭐ Key Selling Points: Highlights important product features.
📱 Social Media Captions: Generates engaging Instagram captions.
#️⃣ Hashtag Generator: Creates relevant marketing hashtags.
🎨 Multiple Writing Styles: Professional, Friendly, Luxury, Creative, and Minimalist.
🛒 Platform Selection: Amazon, Flipkart, Instagram, Etsy, Shopify, and more.
📋 Copy-Friendly Output: Easily copy generated content.
📥 Download Listings: Save generated descriptions as text files.
🔒 Local AI Processing: Product information is processed locally through Ollama.

💰 Who Would Pay for It?

SellSpark AI is designed for:

Small e-commerce businesses
Instagram sellers
Handmade-product sellers
Independent online store owners
Freelancers managing product listings

A future version could offer premium features such as bulk listing generation, saved brand styles, multilingual content, and advanced product templates.

These features could form the basis of an affordable subscription service for small businesses.

Demo

I tested SellSpark AI using a sample product:

Product: Lavender Bliss Candle

Category: Handmade Products

Features: Handmade, soy wax, lavender fragrance, reusable glass jar

Price: ₹299

Target Audience: Gift buyers and home decor lovers

Writing Style: Luxury

Selling Platform: Instagram

SellSpark AI successfully generated:

An attractive product title
A professional product description
Key product features
An Instagram marketing caption
Relevant hashtags

The application also allows users to copy and download their generated listings.

The prototype runs locally using Streamlit and Ollama.

Here are the samples
Homepage

Input

AI generated output

Code

The complete project is available on GitHub.

🔗 GitHub Repository:

https://github.com/sandeepji11/sellspark-ai

🛠️ Tech Stack

Technology	Purpose
Python	Backend application logic
Streamlit	Interactive web interface
Ollama	Local AI model inference
Qwen 2.5 (1.5B)	Open-weight language model
Requests	Communication with the Ollama API

The project includes installation instructions and information about running the application locally.

How I Built It

I developed SellSpark AI using Python, Streamlit, Ollama, and the open-weight Qwen 2.5 (1.5B) language model.

Step 1: Setting Up Local AI

I installed Ollama and configured the Qwen 2.5 (1.5B) model to run locally on my MacBook.

The model can generate responses without requiring a paid AI API.

Step 2: Building the Interface

I used Streamlit to create an interactive web application where users can enter product information, select writing styles, and choose selling platforms.

The interface includes a product input form and an AI-generated results section.

Step 3: Connecting the AI Model

I connected the Streamlit application to Ollama through its local REST API.

When users submit product details, the application constructs a structured prompt and sends it to the locally running Qwen model.

The AI generates product titles, descriptions, selling points, captions, and hashtags.

Step 4: Improving Output Quality

I refined the prompts to discourage unsupported product claims, invented specifications, and inaccurate marketing information.

I also configured the model with a low temperature to encourage more consistent outputs.

Since AI-generated content can still contain mistakes, users are encouraged to verify product details before publishing.

Step 5: Adding Practical Features

I implemented:

AI connection status detection
Multiple writing styles
Selling platform selection
Copy-friendly generated output
Downloadable text files
Error handling for unavailable AI services

Step 6: Testing

I tested the application with sample product information and confirmed that Qwen 2.5 could generate product listings through the Streamlit interface.

The application runs locally, with Ollama handling AI inference.

Why Does Open Innovation Matter?

Open innovation is central to SellSpark AI.

Instead of relying on a proprietary AI API, I built the application around Qwen 2.5, an open-weight language model, and Ollama, an open-source local inference tool.

This approach offers several important advantages.

🔒 1. Better Privacy

Small businesses may not want to send their product information or marketing strategies to external AI services.

SellSpark AI processes product details locally through Ollama, giving users greater control over their information.

💰 2. No Per-Request API Fees

Many commercial AI services charge based on usage.

By running Qwen locally, SellSpark AI avoids per-request AI API charges.

This makes it possible to experiment with a low-cost product aimed at small businesses.

Local inference still requires suitable hardware and electricity.

💻 3. Offline Functionality

After installing the required software, dependencies, and model, SellSpark AI can generate product listings without an internet connection.

This is useful for users who want an AI tool that does not depend on continuous access to a cloud service.

🧠 4. Model Flexibility

Using Ollama allows the application to support different compatible open-weight models.

Developers can experiment with alternative models and customize prompts without depending on a single proprietary AI provider.

🚀 5. Greater Control

Open-weight AI gives developers more flexibility to customize application behavior and explore specialized solutions for different industries.

For SellSpark AI, this creates opportunities to develop industry-specific writing styles, regional-language support, and custom product listing templates.

🌍 Open Innovation vs. Closed AI

The biggest advantage of the open-weight approach for this project is the ability to run the core AI functionality locally without a paid API.

A closed cloud API might offer stronger generation quality, but it would introduce external API dependencies and potentially recurring usage costs.

For a small-business-focused tool like SellSpark AI, local inference offers an interesting alternative focused on privacy, flexibility, and cost control.

🔮 Future Improvements

I plan to expand SellSpark AI with:

📸 Product image-based description generation
🌐 Multilingual product listings
📦 Bulk product listing generation
🎨 Custom brand writing styles
📊 Product listing management
🛒 Marketplace integrations
🤖 Support for additional open-weight AI models

My long-term goal is to turn SellSpark AI into an affordable and accessible marketing assistant for independent online sellers.

🎯 Final Thoughts

Building SellSpark AI helped me explore how open-weight AI can be used to create practical applications with real business potential.

The project demonstrates that developers can build useful AI-powered tools without relying entirely on proprietary cloud APIs.

SellSpark AI is a small step toward making AI-powered marketing tools more accessible to independent sellers and small businesses.

⚡ Built with Qwen 2.5, Ollama, Python, and Streamlit.

OpenSourceAI #SideHustle #Qwen #Ollama #ai #python #hacktoberfest

🌿 TerraQuest AI: Stop Scrolling, Start Exploring | Open-Weight AI Outdoor Adventure Generator

Sandeep Verma — Sun, 11 Oct 2026 18:07:14 +0000

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

🌿 What I Built

TerraQuest AI — Stop Scrolling. Start Exploring.

What if artificial intelligence could encourage us to spend LESS time using technology?

We usually associate AI with chatbots, productivity tools, and digital experiences.

But I wanted to explore a different possibility:

What if AI could inspire people to close their laptops, put away their phones, and discover the world around them?

That idea inspired me to build TerraQuest AI.

TerraQuest AI is an AI-powered outdoor adventure generator that creates personalized real-world missions using an open-weight language model.

🌍 The Problem

Digital entertainment is everywhere.

People spend hours scrolling through social media, watching videos, and interacting with screens.

But sometimes, the biggest challenge to going outside isn't finding time.

It's deciding what to do.

TerraQuest AI addresses this problem by turning outdoor exploration into a personalized adventure.

💡 The Solution

TerraQuest AI generates creative outdoor missions based on four user preferences:

📍 Location
⏱️ Available time
🌱 Interests
⚡ Difficulty level

For example, a user interested in nature might receive missions such as:

Find three different types of leaves.
Observe a bird and describe its behavior.
Discover an interesting natural pattern.
Spend five minutes enjoying the outdoors.

The application also includes:

📵 Touch Grass Mode

Once an adventure is generated, users are encouraged to put their devices away and complete their missions in the real world.

🏆 Adventure Achievements

Users can mark adventures as completed and unlock achievement badges.

🧠 Personalized AI Adventures

Instead of displaying predefined activities, TerraQuest AI generates missions using a locally running language model.

The goal is simple:

Spend less time scrolling. Spend more time exploring.

🎬 Demo

🌿 TerraQuest AI in Action

The application follows a simple workflow:

Open TerraQuest AI.
Enter your city.
Select your available time.
Choose your interests and difficulty level.
Click "Generate My Adventure".
Receive personalized outdoor missions.
Activate Touch Grass Mode.
Complete your adventure and unlock achievements.

📸 Application Screenshots

Homepage — Create Your Adventure

AI-Generated Outdoor Adventure

Touch Grass Mode

Adventure Achievements

💻 Running the Demo

TerraQuest AI currently runs locally using Streamlit and Ollama.

To try the application, follow the setup instructions in the GitHub repository linked below.

💻 Code

GitHub Repository

https://github.com/sandeepji11/terraquest-ai

The project includes the Python application and instructions for running it locally.

🛠️ Technology Stack

Technology	Purpose
Python	Core application logic
Streamlit	Interactive web interface
Ollama	Local AI model execution
Qwen2.5 1.5B	Personalized adventure generation
GitHub	Open-source code hosting

🧠 How I Built It

Step 1: Building the Interface

I used Python and Streamlit to create a simple, interactive web application.

The interface allows users to enter their location, select their available time, and choose the type of outdoor adventure they prefer.

I designed the application with a green-and-white theme inspired by nature.

Step 2: Integrating Open-Weight AI

The core of TerraQuest AI is the Qwen2.5 1.5B language model.

I used Ollama to run the model locally.

When users request an adventure, the application creates a prompt containing their preferences.

This prompt is sent to Ollama through its local API.

The model then generates a personalized outdoor mission.

The response is displayed directly inside the Streamlit application.

Step 3: Creating Touch Grass Mode

The goal of the challenge is to encourage people to spend less time looking at screens.

To support this goal, I created Touch Grass Mode.

After generating an adventure, users can start their mission and put their devices away.

The application encourages real-world participation rather than continuous digital engagement.

Step 4: Adding Achievements

I implemented a simple achievement system using Streamlit session state.

Users can track completed adventures and unlock badges.

The available achievements include:

🌱 Nature Explorer
🌿 Nature Enthusiast
🏆 Outdoor Champion

The current version stores progress temporarily during the application session.

Step 5: Testing

I tested the application by generating personalized outdoor missions with different input preferences.

The AI successfully generated adventure suggestions through the locally running language model.

🚧 Challenges

One challenge was integrating the locally running AI model with the Streamlit interface.

Another was designing the application around minimal screen time.

Rather than creating an experience that requires constant interaction, I focused on generating short missions that encourage users to step away from their devices.

🌱 Why Does Open Innovation Matter?

Open innovation is at the heart of TerraQuest AI.

I wanted to build an AI-powered application without depending entirely on proprietary cloud-based AI services.

Using an open-weight model made that possible.

🔒 Privacy

TerraQuest AI processes adventure-generation prompts locally through Ollama.

This means users do not need to send their prompts to a hosted language-model API.

💻 Local AI Inference

The core adventure-generation feature runs on a local machine.

Once the required model and dependencies are installed, it does not require an internet connection for AI inference.

🔄 Flexibility

Open-weight models allow developers to experiment with different model configurations.

TerraQuest AI can potentially support alternative models in future versions.

🌍 Accessibility

Open-weight AI gives developers opportunities to build intelligent applications without paying for every inference request.

💚 Why It Matters for This Project

TerraQuest AI demonstrates that AI doesn't always need to keep people engaged with technology.

Sometimes, AI can be most useful when it encourages people to disconnect.

The best AI experience might be the one that inspires you to close your screen.

🤖 My Agent Session

I used AI assistance during development to help plan the application, write Python code, troubleshoot errors, and improve the Streamlit interface.

The project uses Ollama and Qwen2.5 1.5B for its core adventure-generation functionality.

I did not record a DevReplay agent session for this version.

🏆 Prize Categories

No optional partner-technology prize category is being claimed for this submission.

🔮 Future Improvements

I would love to expand TerraQuest AI with:

🗺️ Nearby park and trail discovery
🌿 AI-assisted plant identification
📵 Offline adventure cards
🏅 Persistent achievements
🌎 Community outdoor challenges

These improvements could help transform TerraQuest AI into a more complete outdoor exploration companion.

🌍 Final Thoughts

Building TerraQuest AI helped me explore an interesting question:

Can artificial intelligence encourage people to disconnect from technology?

I believe it can.

AI doesn't always need to maximize the amount of time people spend using applications.

Sometimes, its greatest contribution is helping people discover meaningful experiences beyond their screens.

🌿 TerraQuest AI — Stop Scrolling. Start Exploring.

Thanks for reading!