I had a folder full of dead repos. So I built a graveyard — and a way to raise them.

#devchallenge #githubchallenge #ai #webdev

GitHub “Finish-Up-A-Thon” Challenge Submission

This is a submission for the GitHub Finish-Up-A-Thon Challenge

Try it now — no login: https://chintanonweb.github.io/lazarus/ · Code: https://github.com/chintanonweb/lazarus

💡 In plain English: Lazarus turns the side-projects you abandoned on GitHub into a little graveyard you can explore and share — then hands you a step-by-step plan (and ready-to-paste AI prompts) to bring one back to life. No login, no setup. Just type a GitHub username.

We all have it. The folder. The one on GitHub where good ideas go to die. todo-app-v3. the-startup. learn-rust-for-real (narrator: they did not learn rust).

I have one too. And the most poetic resident of mine was a file called graveyard.js —
a ~40-line script I hacked together at 2am to list my dead repos. It printed a wall of RIP lines and ended with a comment that aged like milk:

// TODO: epitaphs? a UI? something that isnt ugly? ...finish later

I never finished it. For the Finish-Up-A-Thon, I finally did. I finished the one project whose entire job is to help me finish all the others.

It's called Lazarus.

What I Built

Lazarus is a zero-login web app that raises your dead GitHub repos. Type a username and it:

🪦 Digs up your graveyard — it scores every repo for abandonment (how long since you last touched it, how unfinished it looks, how many issues are left open) and renders the dead ones as engraved, tilting tombstones under a cold moon.

✍️ Writes the epitaphs — every grave gets a cause of death — scope creep, lost interest, "a shinier idea came along," an honest // TODO — and a one-line verse.
"It was going to do everything. It did nothing."

📊 Wraps it up — an Abandoned Projects Wrapped card (think Spotify Wrapped, but for your graveyard) you can download and share: repos buried, % you actually finished, longest cold streak, leading cause of death.

⚡ Raises the dead — pick a grave and Lazarus generates a revival plan: an autopsy of what's missing (README, tests, CI, license), a prioritized checklist, a downloadable copilot-instructions.md tailored to that repo, and copy-paste GitHub Copilot prompts that pick up exactly where you gave up.

No login. No backend. Nothing leaves your browser.

How to use it (3 steps)

Open the site and type any GitHub username — try your own, or click "Walk a sample graveyard" to explore with demo data first (no account needed).
Wander the graveyard. Hover a tombstone to read its epitaph, or open your Wrapped card to see your stats and share the image.
Click a grave you actually care about. You get its revival plan — a checklist plus prompts you paste straight into GitHub Copilot Chat to finish the project, one step at a time.

That's it. Beginners: start with the sample graveyard. Everyone else: brace yourself and type your own username. 🙂

Demo

🔗 Live (try the demo button — no auth needed): https://chintanonweb.github.io/lazarus/

The graveyard:

Raising a grave — the Copilot revival plan:

Your Abandoned Projects Wrapped (downloadable, shareable):

The Comeback Story

Here's the actual before and after — and yes, the git history proves it.

Before — graveyard.js, the 2am hack. One file, console.log, no UI, a // TODO it never came back for:

After — Lazarus: a cinematic graveyard, epitaphs, a shareable Wrapped, and Copilot-powered revival plans.

	Before (`graveyard.js`)	After (Lazarus)
Code	~22 lines, 1 file	~1,700 lines, 24 files
Interface	a wall of `console.log`	animated graveyard + share card
Output	repo names + days	epitaphs, causes of death, revival plans
Tests	0	25 passing (automated checks that catch bugs)
CI	none	GitHub Actions (runs those checks on every change)
Shareable	no	downloadable Wrapped card
Actually finishes anything	no	generates Copilot revival plans

The hardest part wasn't the tombstones. It was the scoring engine — turning "this repo feels dead" into something honest: days since last push, missing README/license/topics, open issues left hanging, and the tell-tale last-commit message (wip, fix later, giving up for tonight).

I kept that logic deterministic — meaning the same repo always gets the same epitaph, never a random one on reload — by writing it as small, self-contained functions I could test in isolation.

I also did the meta thing: I made the repo itself finished. README, MIT license, and a pipeline that automatically runs the tests every time I push. The tool that nags you to add a README has a README.

My Experience with GitHub Copilot

Copilot didn't write Lazarus. It got me unstuck — which, for an abandoned project, is the whole game. Three concrete moments:

1. It reverse-engineered my own dead code. The first thing I did was point Copilot Chat at graveyard.js and ask, "what was I trying to build here and what's half-finished?" It read the // TODO and laid out exactly the four things past-me had given up on. That became the actual roadmap — and, fittingly, the same "re-read the code and tell me where I left off" prompt is now the first prompt Lazarus generates for every revival. The feature is the workflow that built it.

2. I wrote a copilot-instructions.md first, and the quality jumped. That's a small file that tells Copilot the rules of your project. I gave it mine — the two fonts, the color palette, "keep the logic separate from the UI" — and suggestions stopped fighting my architecture and started matching it. So I baked that lesson into the product: Lazarus generates a tailored copilot-instructions.md for whichever repo you're reviving.

3. The honest failure. I asked Copilot to write the epitaph generator and it reached for Math.random() — so every page reload reshuffled every epitaph. Cute, useless. I pushed back: epitaphs have to be stable. We landed on a tiny math trick that turns each repo's ID into a fixed, repeatable "random" pick (it looks random, but never changes). Copilot is fast hands — not a substitute for deciding what "correct" means. The moment I told it the constraint, it nailed the code and the tests.

Net: Copilot turned "ugh, I don't even remember how this works" — the exact feeling that kills side projects — into momentum. So I shipped that feeling as a button.

🔬 Under the hood (for the curious — skip if you just want to play)

The flow:
type a username → fetch their repos from the GitHub REST API → score each repo → render the graveyard → on click, fetch that repo's health signals → build a revival plan

Design choices:

The scoring / epitaph / wrapped / revival logic are pure functions — no UI, no network calls inside them — which makes them trivial to unit-test. 25 Vitest tests cover them.
The "stable random" epitaphs use an FNV-1a hash feeding a mulberry32 PRNG, seeded by the repo ID — deterministic by design.
It's 100% client-side: React + Vite + TypeScript + Tailwind + framer-motion. No backend, no database, no API keys. Unauthenticated requests use GitHub's public API; an optional read-only token unlocks private repos and higher rate limits — and it never leaves your browser.
Shipped on GitHub Pages, with GitHub Actions running the tests + build on every push.