DEV Community: Mohammed Abid Ali

Afterlight — The Ghost Is the Thread, Not the Impersonation

Mohammed Abid Ali — Tue, 27 Oct 2026 17:35:51 +0000

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

What I Built

Afterlight is a local-first family memory archive built around a simple idea: memories should stay personal, even when AI helps us revisit them.

A family is full of small details that might seem ordinary at the time: a recipe passed down through generations, a familiar saying, a song someone used to hum, or a little ritual that made a house feel like home.

Over time, those details become scattered across notes and recollections. Afterlight brings them together in one private archive and uses a locally running open-weight model to help users discover connections between them.

The inspiration behind the project is the idea of a ghost in the machine: an echo of someone's presence found in the things they left behind.

But there is an important boundary.

Afterlight does not impersonate someone who has died, invent conversations with them, or claim to know what they would say. It reflects on recorded memories and shows the original sources so the family can decide what those memories mean.

The starter archive uses fictional stories, allowing people to explore the experience without exposing real family memories.

The demo should show the fictional archive, a question about a remembered detail, the retrieved source notes, and the AI-generated reflection alongside those sources.

Code

GitHub Repository: mohammedabidali1956/Afterlight

The repository includes the application, a fictional starter archive, setup instructions, and a demo guide.

How I Built It

Afterlight uses Python, SQLite, HTML, CSS, and JavaScript, with Ollama providing local model inference.

The core workflow is:

Family Memories
      ↓
Local SQLite Archive
      ↓
Keyword-Based Retrieval
      ↓
Ollama + Open-Weight Model
      ↓
Structured Reflection
      ↓
Original Source Notes + AI Interpretation

SQLite stores the archive locally. When a user asks a question, the application retrieves relevant notes and passes the selected excerpts to the locally running model.

The model produces a short reflection about the retrieved memories. The application then checks proposed quotations against the original text before displaying them, keeping the source material distinct from AI-generated interpretation.

The application is designed to run on the user's own computer without a cloud database, account system, proprietary AI API key, or third-party Python package. Gemma 3 (1B) is the recommended starting model, and the Ollama integration allows users to choose another installed model.

Why Does Open Innovation Matter?

Family memories are deeply personal. Sending them to an external AI service simply to find connections between them introduces a privacy trade-off that should not be necessary for this experience.

Afterlight keeps the archive and model processing local. Once the model has been downloaded, its retrieval and reflection workflow can operate without an internet connection.

Open-weight AI also gives users more control over the experience. They can inspect the prompts, choose a compatible model, or turn off AI processing without losing access to their stored memories.

The original stories remain the source of truth. AI is a way to explore connections between them, not a replacement for the people who remember them.

There are limitations: local inference still requires suitable hardware, and the prototype's SQLite database is not encrypted. Local processing reduces the need to send family stories to a cloud model, but it does not make the application automatically secure on a shared computer.

For this project, open innovation makes privacy-conscious experimentation possible without making a family archive dependent on a proprietary model provider.

The Spirit of It

Imagine finding an old recipe card in a kitchen drawer.

The handwriting is familiar. One instruction uses an unusual phrase. A note elsewhere mentions the same dish being prepared whenever it rained.

Afterlight helps bring those fragments together. It can retrieve the original notes and offer a possible connection between them, while leaving the meaning of those memories to the family.

It does not claim to bring someone back. It does not speak in their voice. It helps preserve the small details that might otherwise be forgotten.

That distinction is the heart of Afterlight: the ghost is the thread connecting the memories, not an AI pretending to be the person.

The demo archive contains fictional stories, so this is the intended experience rather than a claim that a real family has already experienced that moment.

Prize Categories

Best Use of Gemma

Afterlight uses Gemma 3 (1B) as its recommended open-weight model for the local reflection step. The model works with retrieved memory excerpts to generate structured reflections, while the application keeps source notes visible and checks generated quotations against the originals.

Gemma is part of the core experience rather than an unrelated chatbot feature.

I am entering Afterlight in the Best Use of Gemma category.

Nudge — Turn Messy Thoughts Into Tasks with Local Gemma AI

Mohammed Abid Ali — Sat, 24 Oct 2026 16:47:51 +0000

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

What I Built

I built Nudge, a small local-first AI assistant that turns messy thoughts into actionable tasks.

Sometimes, important things to do get buried in messages, notes, and random thoughts. You remember that something needs to be done, but organizing everything into individual tasks takes extra effort.

Nudge aims to remove that friction.

Instead of manually breaking a long note into separate tasks, you can enter something like:

"Tomorrow I need to finish my DBMS assignment, call Rahul tonight about the project, and pay Ahmed ₹500 on Friday."

Nudge uses Gemma to turn that unstructured text into organized tasks with:

Task title — What needs to be done.
Deadline — When it needs to be completed.
Priority — High, medium, or low.
Category — College, personal, finance, and more.

The result is a structured list that is easier to understand and act on.

The idea behind Nudge is simple: spend less time organizing what you need to do and more time actually doing it.

Demo

Video Demo: Watch Nudge on YouTube

The video demonstrates the core workflow: entering a messy natural-language note and turning it into structured tasks using local AI.

Code

GitHub Repository: Nudge — Hacktoberfest 2026

The project is intentionally small so the main AI workflow is easy to understand, run, and modify.

How I Built It

Nudge is built with Python, Streamlit, Ollama, and Gemma 3 (1B).

The workflow is straightforward:

Messy Natural-Language Note
          ↓
    Nudge (Streamlit)
          ↓
       Ollama
          ↓
     Gemma 3 (1B)
          ↓
      Structured JSON
          ↓
      Actionable Tasks

Gemma handles the core language-processing task: identifying separate actions, interpreting deadlines, assigning priorities, and categorizing tasks.

The application requests structured JSON from the model and parses the response before displaying the resulting tasks.

I deliberately avoided adding a complex agent framework, a database server, or multiple AI services. Nudge focuses on one useful job instead of becoming another general-purpose chatbot.

The current version accepts text entered by the user; it does not automatically read WhatsApp messages or transcribe voice notes.

Why Does Open Innovation Matter?

For Nudge, open-weight AI makes local inference possible without depending on a proprietary hosted LLM API.

The notes people enter can contain personal plans, payment details, relationships, and other private information. With Nudge running locally through Ollama, the text used for AI processing can stay on the user's computer rather than being sent to a third-party LLM provider.

It also avoids per-request charges from a hosted LLM API. Users still need a computer capable of running the model, and the initial setup requires installing Ollama and downloading Gemma.

Another advantage is flexibility. Because Nudge uses an open-weight model through Ollama, the model can be replaced or upgraded without rebuilding the entire application around a single proprietary provider.

For a small utility like this, open innovation makes it possible to experiment with useful AI features while keeping the architecture simple, the processing local, and the ongoing API cost at zero.

The Lazy Payoff

The effort Nudge is designed to save is the repetitive work of reading an unstructured note, identifying each task, figuring out its deadline, and organizing everything manually.

One piece of text becomes a structured task list instead of a collection of things to remember.

The benefit is not about automating an entire life. It is about removing one small, recurring source of friction.

I have not conducted a timed comparison or collected formal user feedback, so I cannot honestly claim a specific number of minutes saved. Measuring how long it takes to organize the same note manually versus using Nudge would be a useful next step.

Prize Categories

Best Use of Gemma

Nudge uses Gemma 3 (1B) as its core language-understanding engine.

Rather than adding AI as a decorative chatbot, the project depends on Gemma to transform unstructured text into actionable tasks. Local inference through Ollama is central to the application's privacy-focused design.

I am entering Nudge in the Best Use of Gemma category.

I Built a Local AI Listing Writer for Used-Mobile Sellers

Mohammed Abid Ali — Sun, 18 Oct 2026 13:38:13 +0000

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

What I Built

I built ListingMate, a local-first AI listing writer designed for used-phone sellers and small mobile shops.

Selling used phones involves more than just setting a price. Sellers need to write clear product descriptions, list specifications, explain the phone's condition, and create attractive listings for WhatsApp and online marketplaces.

ListingMate makes this process simpler.

The seller enters the phone's details, such as:

Brand and model
RAM and storage
Physical condition and battery health
Price and included accessories
Known defects or issues

ListingMate uses an open-weight AI model to turn these details into a polished product title, a structured description, and a short listing ready to share with potential buyers.

The goal is simple: help small sellers create professional listings faster without paying for a separate AI subscription.

Accuracy matters, too. ListingMate is designed to use the information supplied by the seller rather than inventing specifications, claiming nonexistent features, or hiding known defects.

Demo

The demonstration will show a seller entering the details of a used phone and generating a ready-to-share listing.

Code

GitHub Repository:
The project is designed to be small and easy to run locally, with a straightforward workflow from product details to generated listing.

How I Built It

ListingMate uses Gemma 3 (1B), Google's open-weight model, running locally through Ollama.

The application uses Python and Streamlit for its interface and sends the seller's product details to the locally running model.

The core workflow is:

Phone Details
     ↓
ListingMate (Streamlit)
     ↓
Ollama
     ↓
Gemma 3 (1B)
     ↓
Structured Product Listing
     ↓
Copy and Share

Gemma handles the language-generation task: organizing specifications, improving readability, describing the reported condition, and formatting the information for potential buyers.

The application is intentionally focused. It does not need a complex agent framework, a cloud database, or a collection of AI services to perform its main task.

The model is instructed to preserve the seller's supplied facts and to avoid introducing unsupported product claims.

Why Does Open Innovation Matter?

For a small seller, AI is only useful if the cost and complexity make sense for the business.

A proprietary AI API can introduce usage charges and send business information to an external service. ListingMate explores a different approach by running its language model locally.

Product details can include inventory information, selling prices, and notes about a device's condition. With local inference, these details do not need to be sent to a third-party LLM API for description generation.

Running Gemma through Ollama also gives the application flexibility. The model can be changed or upgraded without making the entire product dependent on one proprietary AI provider.

This approach does not eliminate every operating cost: the computer still needs sufficient resources to run the model. However, it avoids per-request charges from a hosted LLM API.

For an independent shop producing multiple listings, that trade-off could make AI-assisted writing more practical.

Prize Categories

Best Use of Gemma

ListingMate uses Gemma 3 as its core text-generation model rather than treating AI as an optional chatbot feature.

The model transforms raw product details into useful, structured sales listings while following constraints intended to prevent unsupported claims.

I am entering ListingMate in the Best Use of Gemma category.

FieldQuest: The Local-First Outdoor Adventure Companion

Mohammed Abid Ali — Sun, 11 Oct 2026 12:00:46 +0000

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

FieldQuest: The Local-First Outdoor Adventure Companion

What I Built

Modern life has tethered us to algorithmic feeds, glowing rectangles, and endless notifications. Many of us genuinely want to explore the outdoors, but outdoor apps often exacerbate screen addiction: requiring live turn-by-turn navigation, cloud logins, subscription tiers, and constant screen gaze.

FieldQuest (TouchGrass) is an AI-powered, local-first outdoor adventure companion built around a single core philosophy:

Plan before leaving. Explore while outside. Preserve memories afterward.

The AI supports your outdoor journey without becoming another reason to stare at a screen.

How FieldQuest Works:

Plan at Home (Desktop or Mobile): Enter your starting location (via GPS or map click), choose a destination, select your available time (30, 60, or 120 minutes), difficulty, and observational interests (Nature, Bird Song, Flora, Photography, Mindfulness, Local History).
Verified Pedestrian Route: FieldQuest queries the OpenStreetMap / OSRM Foot Profile API to compute a real, walkable route with genuine geometry, distance, and turn steps. FieldQuest strictly forbids inventing imaginary trails.
Local AI Mission Design: An open-weight Gemma 3 (1B) model running locally via Ollama personalizes 3 to 4 observational challenges (e.g. noticing leaf vein architectures, counting bird calls, or framing natural patterns) along with a safety checklist.
Offline Field Mode: Export an Adventure Pack JSON or take the installed PWA outside. Turn off Wi-Fi or enable Airplane Mode. While outside, you check off missions, write raw field observations, and capture photos using your camera (auto-compressed to <=1280px JPEG directly in IndexedDB).
Truthful Adventure Journal: Return from your outing and import your completed pack back to your computer. Gemma 3 synthesizes a grounded, reflective Adventure Journal based strictly on what you actually observed and recorded. No hallucinated species, no fabricated weather, and no invented achievements.

Demo

📸 Application Walkthrough

1. Route Planning & Waypoints	2. Verified Route & AI Missions

3. Offline Field Mode	4. Grounded Adventure Journal

Local Development URL: http://localhost:5173 (Local-First React PWA)

Code

The entire codebase is open-source under the MIT License:

GitHub Repository: https://github.com/mohammedabidali1956/FieldQuest
Architecture Highlights:
- src/lib/ollama.ts: Ollama /api/chat integration with Gemma 3 (1B), timeout handling, and safe fallback missions.
- src/lib/routing.ts: Pedestrian routing with caching and strict grounding (no hallucinated paths).
- src/lib/storage.ts: Native IndexedDB persistence for offline adventures and compressed photos.
- src/lib/adventureSchema.ts: Zod schema validation for AI JSON output and import/export packs.
- src/lib/imageUtils.ts: Client-side HTML5 canvas downscaling (max 1280px JPEG).
- src/pages/FieldModePage.tsx: High-contrast outdoor mode with autosave and offline indicators.
- src/pages/JournalPage.tsx: Grounded memory synthesis with print/PDF layout.

How I Built It

┌─────────────────────────────────────────────────────────────┐
│                       FIELDQUEST PWA                        │
├──────────────────────────────┬──────────────────────────────┤
│       1. PLAN & ROUTE        │      2. ADVENTURE PACK       │
│  - Browser GPS / Leaflet     │  - Real OSRM Foot Geometry   │
│  - Time / Difficulty Options │  - 3-4 Observational Missions│
│  - Outdoor Interest Chips    │  - Safety & Gear Checklist   │
├──────────────────────────────┼──────────────────────────────┤
│       3. FIELD MODE          │     4. ADVENTURE JOURNAL     │
│  - 100% Offline (Workbox)    │  - Grounded Gemma 3 (1B)     │
│  - IndexedDB Persistence     │  - Photo Gallery & Captions  │
│  - Camera Photo Compression  │  - Printable PDF / Markdown  │
└──────────────────────────────┴──────────────────────────────┘
                               │
               Local Inference via Ollama API
                               │
                 ┌─────────────┴─────────────┐
                 │     gemma3:1b (Local)     │
                 │  - Zero Cloud Telemetry   │
                 │  - Zero API Key Required  │
                 └───────────────────────────┘

1. Local Open-Source AI (Gemma 3 1B via Ollama)

I chose Google's open-weight Gemma 3 (1B) model deployed locally via Ollama. Gemma 3 1B is astonishingly fast, runs on modest hardware, and follows structured JSON schemas with high fidelity.

Inference Setup: Configured to call http://localhost:11434/api/chat using strict JSON schemas.
Resilience: If Ollama is offline or experiencing connectivity issues, FieldQuest never crashes. It immediately switches to intelligent curated observation challenges and a grounded factual journal template.

2. Grounded Geography & Safety Guardrails

OSRM Foot Routing Profile: To ensure the user stays on authentic pedestrian paths, routes are obtained directly from OpenStreetMap data via the OSRM foot engine.
Anti-Hallucination Prompting: Gemma 3 is explicitly instructed never to confirm biological species names unless verified by retrieved data, and the journal synthesis prompt is strictly conditioned on user-recorded facts.

3. Progressive Web App & Offline Storage

Built using React 19 + TypeScript + Vite with vite-plugin-pwa.
The PWA precaches its shell and static assets so Field Mode operates in full airplane mode.
Local storage uses IndexedDB (fieldquest_db) to store route points, checklist state, observations, and photo attachments. Photos are downscaled client-side to <=1280px JPEG to keep JSON exports compact.

Why Does Open Innovation Matter?

Open innovation—specifically open-weight foundation models and open geospatial data—fundamentally transformed how this project was conceived and built:

True Privacy in Intimate Outdoor Spaces: When people walk, hike, or reflect in nature, they should not have their precise GPS coordinates, personal thoughts, and candid photographs sent to third-party commercial cloud servers. With open-weight Gemma 3 running locally on the user's computer and an offline PWA on mobile, user data never leaves their control.
Zero Cost & Censorship-Free Exploration: Closed AI APIs charge per token and impose cloud rate limits. Open-weight models empower developers to build offline-first tools that remain free forever.
OpenStreetMap Power: OpenStreetMap is one of the greatest collaborative human achievements. Pairing open geospatial infrastructure with open-weight AI demonstrates how community-driven data and open AI models reinforce one another.

My Agent Session

This project was built pair-programming with Google DeepMind's Antigravity agentic coding assistant. The agent analyzed the Hacktoberfest prompt, scaffolded the Vite + TypeScript + PWA codebase, implemented the OSRM pedestrian routing module, integrated local Ollama inference with Gemma 3 (1B), set up IndexedDB offline persistence, verified the entire flow in an end-to-end browser subagent session, and ran focused Vitest unit tests.

Prize Categories

Primary Track: Touch Grass (Hacktoberfest Week 1) — AI that gets people off their screens and engaging with the real world.
Open Innovation: Demonstrating the power of local inference with open-weight Gemma 3 and OpenStreetMap data.

My Friend Keeps Forgetting Things Buried in WhatsApp and Voice Notes — So I Built Nudge

Mohammed Abid Ali — Sun, 04 Oct 2026 19:00:55 +0000

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

What I Built

I built Nudge, a small local-first AI assistant for a friend who often has multiple things to remember but keeps them buried in messy notes and messages.

Instead of manually organizing those thoughts, they can simply write something naturally, such as:

“Tomorrow I need to finish my DBMS assignment, call Rahul tonight about the project, and pay Ahmed ₹500 on Friday.”

Nudge uses Gemma 3 through Ollama to understand the note and turn it into clear, actionable tasks with deadlines, priorities, and categories.

For example:

Finish DBMS assignment — Tomorrow — High — College
Call Rahul about the project — Tonight — Medium — Personal
Pay Ahmed ₹500 — Friday — High — Finance

The goal isn't to build another complicated productivity app. It is to remove the friction between having a thought and turning it into an action.

Demo

Video Demo: Watch Nudge on YouTube

The demo shows a messy natural-language note being processed locally and transformed into structured, actionable tasks.

Code

GitHub Repository: mohammedabidali1956/Nudge-Hacktoberfest-2026-Build-for-a-Friend-Challenge

The project is intentionally small and focused so that the core AI workflow is easy to understand and reproduce.

How I Built It

Nudge is built around Gemma 3, Google's open-weight model, running locally through Ollama.

The core pipeline is:

User's Note
     ↓
Nudge (Streamlit)
     ↓
Ollama
     ↓
Gemma 3 (1B)
     ↓
Structured JSON
     ↓
Actionable Tasks

The application uses Python and Streamlit for the interface and communicates directly with the locally running Ollama instance.

Gemma handles the core natural-language understanding: identifying individual actions, interpreting relative deadlines such as “tomorrow” or “Friday,” assigning priorities, and categorizing tasks.

For example:

“Tonight call Rahul and tomorrow submit the DBMS assignment.”

becomes structured task data rather than a generic AI response.

I deliberately kept the architecture simple so that the open-weight model is the core of the product rather than an additional chatbot feature.

Why Does Open Innovation Matter?

For Nudge, local open-weight AI is not just a technology choice. It directly affects how the product can be used.

A friend's notes can contain personal plans, payments, relationships, and other private information. With Nudge's local-first architecture, that information does not need to be sent to a proprietary cloud AI API.

Instead, the workflow is:

Friend's Computer
       ↓
     Nudge
       ↓
    Ollama
       ↓
     Gemma

The AI processing can happen directly on the user's computer.

Using an open-weight model also means the AI layer is not permanently tied to a single closed provider. The model can be replaced or upgraded while keeping the core application architecture simple.

For this project, open AI made it possible to build a private, reproducible assistant that can run on a personal computer without requiring API keys or a proprietary AI service.

Prize Categories

Best Use of Gemma

Nudge is built around Gemma 3 as its core natural-language understanding engine.

Gemma performs the task extraction, deadline interpretation, prioritization, and categorization that make Nudge useful.

I am entering Nudge in the Best Use of Gemma category.

HacktoberFest 2k26

Mohammed Abid Ali — Fri, 02 Oct 2026 13:43:52 +0000