Deadline Necromancer: I Resurrect Dead Side Projects with a Local Gemma

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

Inspiration

• My ~/projects folder is a graveyard. Fourteen corpses, by last count. A fitness API that died mid-auth, a portfolio tracker that died chasing websockets, a family recipe archive that died three months ago with a half-finished Tamil search feature hiding in a stash.
• The theme is "Slow and Steady" — reward laziness. And I realized the laziest thing a developer can do is not start a new project. Starting from scratch is the most expensive form of work there is. The ultimate lazy move is salvaging the 80% you already built. So I built an AI that performs autopsies on dead projects and writes resurrection plans, slow and steady, one corpse at a time.

What it does

Deadline Necromancer scans a folder of abandoned git repos and, for each one, produces:

• A forensic autopsy: death date, days dead, TODO/FIXME markers, stashes never popped, changes left uncommitted, and the "last words" — the final commit message
• A resurrection plan written by a local AI: cause of death, unfinished business, and a step-by-step plan whose first step is always embarrassingly small
• A Lazy Payoff meter: estimated hours to revive vs. hours to restart from scratch, side by side Demo:

How I built it

• The whole thing runs on your machine. That's not a feature bullet — it's the design constraint.
• The autopsy engine is plain git archaeology — no AI needed, no API calls. git log dates, git stash list, working-tree diffs, and a sweep for TODO/FIXME/HACK markers. Facts first, interpretations later.
• The brain is Gemma 3 (12B) through Ollama, fully local. It receives the autopsy facts and synthesizes: where did this project stop, what's broken, what's the smallest shippable next step. Because LLM output is untrusted by default, every plan goes through validation — malformed JSON rejected, absurd hour estimates clamped. If Ollama is unreachable, a rule-based fallback planner takes over, and the app is honest about it ("Demo mode" label). The demo never dies.
• The UI is a dark graveyard — tombstone cards, drifting fog — with the plan in a modal and the Lazy Payoff as animated bars. Stack: FastAPI backend, vanilla HTML/CSS/JS frontend, pytest (24 tests, all passing).
• The AI is genuinely load-bearing here: remove Gemma and the product dies, because synthesizing "where did I stop and what's the tiniest next step" from a git history is a real language task. No model could be replaced by a timer or a rule — I know, because the fallback planner exists and it's clearly dumber.

Challenges

The honest one: prompt-to-JSON reliability. Gemma is chatty; plans came back with commentary, half-formed JSON, or confidence-inspiring numbers like "revival: 400 hours." The fix was treating model output as hostile: strict schema, clamping, and a graceful fallback instead of a crash. Boring engineering, but it's why the app is bulletproof.
The second: seed data. Demoing an autopsy tool needs believable corpses, so I wrote a script that conjures three repos with backdated commits, each with its own manner of death — one died mid-feature with changes uncommitted, one chased a feature for 11 months, one hid its best work in a stash. Fun fact: the stash corpse (amma-recipes) became the demo's emotional center.

Accomplishments

• Verified live on my own machine: scanned the demo graveyard (3 corpses), re-ran necromancy on fitquest-api and got a fresh, specific plan — "Fix the timezone handling for IST" as step one, 2.5h to revive vs 12h to restart, 9.5 hours saved (my laptop runs gemma2:2b through Ollama; the repo defaults to gemma3:12b)
• The fallback planner is a feature, not a hack: the app is fully demonstrable with zero AI running, and honest about which mode it's in
• 24/24 tests passing, including adversarial LLM-output tests (garbage in, graceful plan out)

What's next

• Point it at my real graveyard and resurrect one project per weekend — the tool dogfoods itself
• Rank corpses by "revival ROI" so the laziest valuable resurrection floats to the top
• A "cremation" option: plans for projects that deserve to be archived properly instead of haunting you

The Lazy Payoff 💤

For a typical corpse: ~1–2 hours to revive with the plan vs. a full week to restart from scratch. Multiply by the 14 corpses in my folder and the math is ridiculous. But the real payoff isn't hours — it's that starting again feels lighter than starting over. The plan's first step is always ten minutes. Ten minutes, anyone can do.

Why open innovation matters

Your abandoned code is your most private code — half-baked ideas, old secrets, experiments you never shipped. A cloud AI reading that is a non-starter; an open-weight model on your laptop is the only version of this tool that should exist. That's the point of the challenge's prompt: open models don't just make AI cheaper, they make certain tools possible.

Prize Categories

Best Use of Gemma — Gemma (via Ollama, fully local) is the project's brain: it reads the git autopsy and writes the resurrection plan. Open-weight and local isn't a deployment choice here, it's what makes the tool possible.

Repo: https://github.com/Revaldo143/deadline-necromancer (MIT, built entirely during the Week 3 window)