DEV Community: Thanzia Patel

Haunted Repo 💀 — Exploring the Graveyard of Forgotten Code with AI

Thanzia Patel — Fri, 30 Oct 2026 16:36:44 +0000

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

What I Built

What happens to code after it's deleted?

In Git, deleted files don't necessarily disappear forever. Their history can still exist in earlier commits.

While exploring ideas with ChatGPT for the Hacktoberfest 2026 Week 4: Ghost in the Machine challenge, I came across the idea of bringing forgotten code back to life.

That became the starting point for Haunted Repo — a developer-focused application that explores the forgotten history of a local Git repository and turns deleted files into a spooky, interactive experience.

It scans Git history to discover deleted files and brings them together in a Graveyard, where you can:

Explore a deleted file's source code and Git history.
Generate an AI-powered ghost story about its past.
Listen as the forgotten code tells its story through a ghost voice.
Summon the Reaper's Verdict for an AI-generated technical analysis and a spooky final judgment.

For the Halloween theme, I wanted to take this concept further by combining real Git history with storytelling, technical analysis, and a ghost voice to make the experience more interactive.

At its core, Haunted Repo is powered by Gemma 3 running locally through Ollama.

Demo

Here's a walkthrough of Haunted Repo, from scanning a local Git repository and discovering deleted files to hearing their ghost stories and revealing the Reaper's Verdict.

The demo shows the application running locally, with Gemma 3 through Ollama powering its AI features.

Code

The source code for Haunted Repo is available on GitHub.

The project uses:

React + Vite + Tailwind CSS for the frontend
Node.js + Express for the backend
Git CLI to explore repository history and discover deleted files
Ollama + Gemma 3 for local AI-powered features

The application runs locally, allowing developers to explore their Git repositories without sending their source code to a hosted AI service.

GitHub Repository: Haunted Repo

How I Built It

I built Haunted Repo using React, Vite, and Tailwind CSS for the frontend, with Node.js and Express handling the backend.

The application combines three main parts:

1. Exploring Git history

The backend uses Git commands to identify files deleted from a local repository. Users can select a file from the Graveyard and investigate its previous source code and commit history.

2. Bringing forgotten code to life with local AI

I integrated Gemma 3 through Ollama to run AI inference locally.

Using information retrieved from Git history, the application generates spooky stories about forgotten files and produces the Reaper's Verdict, combining technical observations with a Halloween-inspired narrative.

I also added a ghost voice feature to make the experience more interactive.

3. Building the developer experience

I designed the interface around a spooky terminal and graveyard theme, with repository scanning, file selection, code exploration, and AI-generated results forming a connected experience.

The goal was not just to create a Halloween-themed interface, but to build a working application that connects real Git history with locally running open-weight AI.

Architecture

Haunted Repo follows a client-server architecture with local AI integration.

The React frontend communicates with the Node.js and Express backend through API requests.

The backend uses Git CLI commands to retrieve deleted files, previous source code, and commit history from the local repository.

For AI-powered features, the backend sends relevant file information to Gemma 3 through Ollama, which generates ghost stories and the Reaper's Verdict locally. The results are then returned to the frontend.

This architecture keeps repository analysis and AI inference on the developer's machine without relying on a hosted AI API.

Why Does Open Innovation Matter?

One of the main reasons I chose Gemma 3 with Ollama was the ability to run AI locally.

Haunted Repo explores source code and Git history, so keeping repository data on the developer's machine was an important consideration.

Using an open-weight model offered several advantages:

Privacy: Repository content can be processed locally without sending it to a third-party AI API.
Control: I can experiment with prompts, model behaviour, and different models.
No per-request API costs: Local inference doesn't require paying for each AI request.
Offline capability: Once the required model and dependencies are installed, AI inference can run without an internet connection.
Flexibility: Ollama makes it possible to experiment with other supported models without rebuilding the entire application.

Running Gemma 3 locally also came with trade-offs. AI response times depend on the available hardware, and local models have memory and processing requirements.

For Haunted Repo, I felt those trade-offs were worthwhile because the project is designed around exploring local repositories.

What I appreciated most about this challenge was the opportunity to build something where open-weight AI wasn't just an added feature — it was central to how the application works.

My Agent Session

I didn't record a DevRelay agent session, but I used ChatGPT as a development assistant throughout the project.

It helped me explore implementation approaches, understand Git commands, troubleshoot errors, and refine parts of the frontend and backend.

I worked through the features with AI assistance, testing the application, making adjustments, and adding my own ideas along the way.

The Spirit of It

For me, the fun part of Haunted Repo was imagining what would happen if forgotten code could tell its own story.

Every deleted file once had a purpose. Maybe it was replaced, refactored, or simply no longer needed. But somewhere in Git history, traces of it still remain.

One of the more fun decisions was whether to add a ghost voice. At first, I wasn't sure it was necessary — after all, the deleted files already had plenty of history to uncover! 💀

But I eventually decided to give those forgotten files a voice, and I think it added a fun touch to the whole experience.

I wanted Haunted Repo to feel like more than a Git history viewer. The Graveyard Terminal, ghost stories, and Reaper's Verdict turn something technical into a slightly spooky experience.

Because in Git, nothing truly stays buried.

Prize Categories

Gemma 3

Haunted Repo uses Gemma 3, running locally through Ollama, to generate spooky stories and the Reaper's Verdict based on deleted files and their Git history.

LazyFlow AI: Turning Messy Messages into Actionable Tasks with Gemma 3

Thanzia Patel — Sun, 25 Oct 2026 08:23:40 +0000

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

What I Built

As a parent, I often receive school announcements containing several reminders, assignments, deadlines, and upcoming activities. Sometimes, a single notification includes multiple things that need attention, and keeping track of everything can become overwhelming.

This made me think about how often we receive similar messages in everyday life, whether it's a school announcement, a long workplace email, meeting notes, or a group message filled with instructions and reminders.

What if I could simply paste one of these messages and let AI identify the tasks instead of going through everything manually?

That's how the idea for LazyFlow AI came about.

LazyFlow AI is a simple, full-stack AI-powered task management application that transforms long, messy, or unstructured messages into clear, actionable tasks using Google's open-weight Gemma 3 4B model running locally through Ollama.

Instead of manually identifying each task, users can paste a message and let the AI extract the relevant action items, along with deadlines and priorities.

With LazyFlow AI, users can:

Extract actionable tasks from emails, school announcements, meeting notes, and everyday messages.
Identify deadlines and priorities from the message context.
Organize tasks under AI-generated group headings.
Edit, complete, or delete tasks.
Select individual tasks or entire groups and save them into named collections.
Track task completion progress.

Although school notifications inspired the idea, I wanted to build something useful for anyone dealing with lengthy messages containing multiple things to do.

The goal isn't to replace existing reminder or task management applications, but to make the step before task management easier: turning scattered information into organized tasks.

Demo

This short demo shows how LazyFlow AI transforms a school announcement containing multiple instructions and deadlines into organized tasks.

It demonstrates AI task extraction, priority and deadline identification, task completion, selective saving, editing tasks, and tracking progress within saved collections.

Code

LazyFlow AI is an open-source full-stack project built with React, Node.js, Express, and Gemma 3 running locally through Ollama.

The GitHub repository includes the source code, setup instructions, environment configuration example, and screenshots of the application.

GitHub Repository: LazyFlow AI

How I Built It

I built LazyFlow AI using the MERN-style full-stack approach I'm familiar with, but instead of using MongoDB, I chose browser localStorage to keep the application simple for this MVP.

Tech Stack

Frontend: React, Vite, Tailwind CSS, React Router, and Lucide React
Backend: Node.js and Express
AI Model: Google's Gemma 3 4B
Local Inference: Ollama
Storage: Browser localStorage

Application Architecture

LazyFlow AI follows a simple full-stack architecture, with Gemma 3 running locally through Ollama.

flowchart TD
    A["User pastes a message"] --> B["React + Vite Frontend"]
    B -->|"HTTP Request"| C["Node.js + Express Backend"]
    C -->|"Prompt + Message"| D["Ollama + Gemma 3 4B"]
    D -->|"Structured JSON"| C
    C -->|"Validated Tasks"| B
    B --> E["Task Dashboard"]
    E --> F["Saved Collections"]
    E -.-> G["Browser localStorage"]
    F -.-> G

The React frontend handles user interactions and task management. The Express backend communicates with Ollama, where Gemma 3 extracts actionable tasks, deadlines, priorities, and group headings.

The generated tasks are validated and returned to the frontend, where users can organize and manage them. Dashboard tasks and saved collections are persisted using browser localStorage.

Integrating Gemma 3 with Ollama

I wanted to explore running an open-weight AI model locally rather than depending on a cloud-based AI API.

I downloaded Gemma 3 4B and ran it on my Mac using Ollama.

When a user pastes a message and clicks Generate Tasks, the React frontend sends the text to the Express backend.

The backend then communicates with Ollama's API, passing the user's message along with instructions for extracting actionable tasks.

I designed the prompt to return structured JSON containing:

A meaningful heading for the message
Task titles
Deadlines, when available
Task priorities
An indication of whether a task needs clarification

The backend validates the response before returning the extracted tasks to the frontend.

If a message doesn't contain any actionable items, the application displays a notification instead of creating unnecessary tasks.

Building the Task Management Features

Once tasks are generated, users can edit, delete, or mark them as completed.

I also added task grouping so that messages are kept separate. Users can select individual tasks or an entire group and save them into named collections.

Each collection has its own task list and completion progress.

For this MVP, I used localStorage to persist tasks and collections across browser refreshes without introducing a database or authentication system.

Challenges and What I Learned

One challenge was getting the AI model to return predictable, structured output. I refined the prompt to help Gemma distinguish actionable instructions from general information and avoid inventing deadlines or priorities.

Another challenge involved duplicate-message detection.

Initially, I stored a history of every successfully processed message to prevent duplicate tasks. However, I realized this prevented users from processing the same message again, even after deleting or saving its tasks.

I improved this by checking whether tasks from the same message still exist on the Dashboard. This prevents unnecessary duplicates while allowing users to regenerate tasks after clearing them.

I also worked on handling task selection, saving only selected tasks, and keeping progress tracking separate between the Dashboard and saved collections.

Building LazyFlow AI helped me better understand local LLM integration, prompt design for structured output, validating AI responses, and managing state across different parts of a React application.

Why Does Open Innovation Matter?

One of the reasons I chose Gemma 3 for LazyFlow AI was to explore how open-weight AI models can be used in everyday applications without relying on a hosted AI service.

Using Gemma 3 4B with Ollama allowed me to download the model and run inference locally on my Mac. I could experiment with prompts, test different types of messages, and refine how the model extracts tasks without making requests to a paid cloud AI API.

Local inference also offers an important privacy advantage. Messages such as school announcements, personal reminders, or workplace emails can be processed on the user's own machine without needing to send their contents to an external AI provider.

Another benefit is flexibility. Because the model runs through Ollama, I can experiment with different supported models and adjust the extraction instructions as the application evolves.

Of course, running AI locally also has trade-offs. Users need suitable hardware, must install Ollama and download the model, and inference performance depends on their device.

For me, open innovation made it possible to explore AI integration more independently, understand how local inference works, and build a practical application around an openly available model.

LazyFlow AI is a small example of how open-weight AI can make everyday tasks easier while giving developers more control over how their applications use AI.

The Lazy Payoff

The biggest benefit of LazyFlow AI is reducing the manual effort involved in identifying tasks from lengthy messages.

For example, a school announcement might contain information about homework, excursion payments, consent forms, and upcoming activities. Normally, I would need to read through the message, identify each action item, check the deadlines, and manually organize everything.

With LazyFlow AI, I can paste the entire message and get a structured list of tasks, along with their deadlines and priorities, which I can then review, edit, and organize.

The same approach works for workplace emails, meeting notes, and other everyday messages.

I haven't measured the exact time saved yet, but the application helps reduce the effort spent going through lengthy messages, figuring out what needs to be done, and identifying when each task needs to be completed.

For me, the idea behind LazyFlow AI is simple: make it easier to understand and organize tasks from everyday messages, so we can spend less time figuring out what needs to be done and when.

Prize Categories

Best Use of Gemma

LazyFlow AI uses Google's Gemma 3 4B open-weight model, running locally through Ollama, as the core of its AI task extraction functionality.

Gemma analyzes unstructured messages and generates structured task data, including task titles, deadlines, priorities, and meaningful group headings.

The application demonstrates how Gemma can be integrated into a practical full-stack workflow to simplify everyday task management.