This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine
What I Built
I have a small graveyard of software projects on my laptop.
Ideas I was excited about, projects I spent weeks building, and applications I genuinely wanted to finish. But somewhere along the way, I abandoned them.
And coming back is surprisingly difficult.
Sometimes I open an old project and spend more time trying to remember what I was doing than actually understanding the code. What was this feature supposed to do? Why did I choose this architecture? What was the next step?
Once, I was so reluctant to even inspect an old project that I opened its folder and ran an expo command without thinking. The project was actually built with Vue and Capacitor. Yes, I tried to start the wrong ecosystem entirely. 😅
That experience captures the problem quite well: sometimes, the biggest obstacle to continuing a project is simply recovering the context you have lost.
So I built Ghost Projects, an AI-powered desktop application that investigates forgotten software projects and helps developers rediscover what they were building.
Instead of asking developers to manually explore hundreds of files, it uses an AI agent with investigation tools to examine the codebase, collect evidence, identify technical decisions, and reconstruct the project's possible original purpose.
The investigation produces:
- Project overview: A summary of what the project appears to do.
- Architecture: An overview of its technologies, frameworks, and structure.
- Evidence: Relevant files and code excerpts supporting the investigation.
- Clues: Interesting findings about features, implementation decisions, and unfinished work.
- Recovery plan: A prioritized set of actions to help developers decide where to continue.
The idea behind the name comes from this week's theme, Ghost in the Machine.
An abandoned codebase is not really empty. It still contains traces of the developer's intentions, decisions, and unfinished ideas. Ghost Projects tries to uncover those traces.
Demo
Code
👻 Ghost Projects
Ghost Projects is a desktop developer tool designed to investigate, analyze, and "resurrect" forgotten digital archives. It transforms the daunting task of understanding a legacy codebase into a structured investigation, providing a polished dashboard of findings, evidence, and a concrete recovery plan.
🕯️ Hacktoberfest 2026 — Week 4
Ghost Projects was built as a submission for the Hacktoberfest Open-Source AI Challenge — Week 4, under the theme "Ghost in the Machine."
The challenge invites developers to explore the intersection of open-source AI, forgotten digital history, and creative technology.
Inspired by the idea of bringing abandoned open-source projects back to life, Ghost Projects uses AI to investigate forgotten codebases, uncover their original purpose, reconstruct architectural insights, and suggest practical steps for their recovery.
🔗 Challenge Announcement: Hacktoberfest Open-Source AI Challenge: Ghost in the Machine
🌟 Features
- 🔍 Deep Project Scanning: Automatically detects programming languages, frameworks, and…
The repository contains the application source code and the implementation of its investigation workflow.
How I Built It
I wanted Ghost Projects to behave less like a chatbot receiving a folder of code and more like an investigator with a set of tools.
The application follows a tool-based agent architecture.
At a high level, the investigation works like this:
Project folder → Codebase scanning → Evidence collection → AI investigation → Structured assessment → Desktop interface
The main technologies are:
- Python: Core application logic and services.
- PySide6: Desktop user interface.
- Pydantic: Data models and validation of structured investigation results.
- OpenAI Agents SDK: Agent orchestration and tool integration.
- Gemma 4 (31B): Open-weight model used for the AI investigation.
- Ollama Cloud: Model access through an OpenAI-compatible API.
The investigation tools allow the agent to explore project files, read relevant content, search for specific information, inspect Git history when available, and collect evidence.
One important design decision was separating what the application discovers from what the AI concludes.
The scanner and investigation services collect information from the actual codebase. The AI then uses that information to produce an assessment containing findings, evidence references, architectural details, unknowns, and recovery actions.
Pydantic validates the final structure before it reaches the interface. This matters because an investigation should not simply produce an interesting story; its conclusions should be connected to information that can be inspected.
I also built the interface around this workflow. Rather than displaying everything as a long AI-generated response, the application provides separate areas for the project summary, architecture, clues, evidence, and recovery plan.
The goal is to make the investigation useful and navigable, not just readable.
Challenges and limitations
Building an agent that investigates an unfamiliar codebase was not as straightforward as I initially expected.
Some of the challenges I encountered were:
- Structured Output Compatibility: Gemma did not always return structured data in the format expected by the agent framework. Sometimes it returned Markdown-formatted JSON instead.
- Evidence References: Ensuring that AI-generated findings refer to real evidence collected from the project required additional validation and careful handling.
- Agent Turn Limits: Complex investigations sometimes exceeded the maximum number of allowed agent turns.
- Context Limitations: Large codebases can exceed the model's available context, so the investigation needs to work within scanning and token limits.
- Cloud Infrastructure Dependency: Although the model is open-weight, my current implementation uses Ollama Cloud. This introduces connectivity, latency, and availability constraints.
These limitations are important. Ghost Projects is an investigative assistant, not a tool that guarantees a complete understanding of every codebase or automatically rebuilds abandoned applications.
There is still plenty of room to improve its investigation strategies, model compatibility, and ability to handle very large projects.
Why Does Open Innovation Matter?
For a project like Ghost Projects, the model is an important part of the experience, but it should not become a permanent dependency on a single AI provider.
Open-weight models make experimentation possible. Developers can explore different models, compare their performance, change inference providers, and adapt the system to their available hardware and budget.
This is particularly important for developers who cannot afford expensive API usage.
I used Gemma through Ollama Cloud for this implementation, but the architecture is designed around a model provider rather than hardcoding the investigation logic into one model.
The use of an open-source agent framework also gave me the flexibility to build an agent around specific tools and structured outputs instead of relying on a closed, predefined workflow.
I also think there is something meaningful about applying open-source AI to software preservation.
A forgotten project may contain years of someone's work. Giving developers accessible tools to understand and recover that work is a small but valuable contribution to keeping software ideas alive.
Open innovation makes it easier for others to inspect, modify, extend, and experiment with the same approach.
The Spirit of It
There is something strange about opening a project you abandoned years ago.
You can recognize the code. You remember the idea. Maybe you even remember how excited you were when you started building it.
But the context is gone.
The decisions that once seemed obvious now look mysterious. Features are half-finished, comments are outdated, and sometimes even the folder structure feels unfamiliar.
And somewhere in all those files, there is still a version of you who knew exactly what they were trying to build.
I think that is what makes abandoned software interesting. It is more than unfinished code. It is a record of ideas that never reached their final form.
Ghost Projects cannot recover the time that passed or automatically finish those ideas. But it can help developers find their way back.
Maybe that is enough to give an old project another chance.
Give Your Ghost a Second Life.
Prize Categories
- Best Use of Gemma
Top comments (0)