This is a submission for the GitHub Finish-Up-A-Thon Challenge
Museum of Dead Dreams: Turning Abandoned GitHub Repos into AI Revival Plans and Copilot Kits
What if abandoned repositories were not just dead code, but unfinished stories waiting for the right resurrection plan?
That idea became Museum of Dead Dreams: an AI-powered product that transforms forgotten GitHub repositories into interactive museum exhibits, grounded technical autopsies, revival strategies, branded PDFs, and GitHub Copilot-ready execution kits.
This project started as a visually interesting concept. I finished it as a real product.
What I Built
Museum of Dead Dreams is a virtual museum for abandoned software projects.
A user enters a GitHub username, and the app:
- scans public repositories
- filters out forks
- ranks projects by abandonment
- collects real repo evidence like languages, commits, README excerpts, root files, and manifest snippets
- generates an AI-powered personalized museum
- turns each abandoned project into an exhibit
- lets the user ask a Copilot Curator
- creates a Revival Plan
- exports that plan as Markdown or a branded PDF
- saves selected projects into Resurrection Bay
- generates a GitHub Copilot Resurrection Kit that can be dropped into a real repository
This is not just a portfolio viewer or a gimmick UI. It is a complete workflow for recovering value from unfinished code.
Why I built it
Every developer has a graveyard.
Old side projects. Half-finished tools. Hackathon builds. Startup experiments that almost became something.
GitHub preserves the files, but it usually does not preserve the context:
- Why did the project die?
- What still makes it valuable?
- What should be rebuilt first?
- How can a coding agent like GitHub Copilot actually help revive it?
Museum of Dead Dreams is my answer to that problem.
Demo
Live Links
- Live Experience: https://osiam2phyuryk.kimi.page
- GitHub Repository: https://github.com/jpablortiz96/Museum-of-Dead-Dreams
- Video Walkthrough: https://youtu.be/qmLwdTxxjIA
Product Flow
The experience works like this:
- Enter a GitHub username
- Scan public repositories
- Rank the most abandoned projects
- Generate a personalized AI museum
- Explore exhibits, causes of death, and technical artifacts
- Ask the Copilot Curator project-specific questions
- Open a six-part Revival Plan
- Export it as Markdown or branded PDF
- Commit revived projects into Resurrection Bay
- Download a Copilot Resurrection Kit and continue the rebuild in the original repo
Real Product Screenshots
These are real screenshots captured from the running application.
Welcome Screen
Loading Graveyard
Museum Hall
Exhibit Room
Copilot Curator
Revival Plan
Resurrection Bay
The Comeback Story
This is the part that matters most for the Finish-Up-A-Thon.
Museum of Dead Dreams did not start as the polished product you see now.
It started as a more static concept: a cool atmospheric museum with a few hardcoded rooms. It looked interesting, but it was not yet a complete, usable system.
Before
- a static concept museum
- four hardcoded rooms
- no live GitHub user analysis
- no grounded repo evidence
- no real AI revival workflow
- no persistent archive
- no Copilot execution handoff
- no exportable decision artifact
After
- personalized museum generation for any GitHub username
- GitHub API repo ingestion
- abandonment ranking and repo evidence enrichment
- AI-generated exhibit narrative grounded in real repo context
- Copilot Curator for per-project Q&A
- Revival Plans with diagnosis, architecture, stack, features, GTM, and score
- Markdown export
- Branded PDF export
- Resurrection Bay as a persistent archive of revived ideas
- GitHub Copilot Resurrection Kits ready to drop into a real repo
- shareable museum URLs
Before vs After Visual
The challenge was not just adding more features.
The real challenge was turning a concept into a complete product with:
- a clear workflow
- a stronger information architecture
- live repo analysis
- fallback-safe AI behavior
- exportable outputs
- and a real “next step” after inspiration
That “next step” became one of my favorite parts of the project: the Copilot Resurrection Kit.
The Most Important Product Idea
I did not want this to become “just another cool AI interface.”
So I asked myself:
What happens after the museum tells you a project is worth reviving?
The answer was: the app should help you act on it.
That is why Museum of Dead Dreams generates a GitHub Copilot Resurrection Kit with files like:
.github/copilot-instructions.mdAGENTS.md.github/instructions/resurrection.instructions.md.github/skills/<project>-resurrection/SKILL.mddocs/revival-plan.mddocs/resurrection-backlog.md
Here is the visual for that system:
This makes the project more than a diagnosis engine.
It becomes an execution bridge between abandoned code and the next real commit.
Technical Highlights
Museum of Dead Dreams is built with:
- React 19
- TypeScript
- Vite
- Tailwind CSS
- shadcn/ui
- Node.js
- OpenAI SDK
- Zod for structured output validation
- GitHub API
- html2canvas + jsPDF for branded PDF export
- JSZip for Copilot kit downloads
-
localStoragefor persistence and per-museum Resurrection Bay archives
High-Level Architecture
A few technical choices I’m especially proud of:
1. Grounded repo analysis
The app does not just ask an LLM to imagine a project story. It collects real context from the repo first:
- languages
- commit count
- last commit
- README excerpt
- root files
- manifest snippets
2. AI with fallbacks
The app stays functional even when AI is unavailable:
- museum exhibit fallback generation
- revival plan fallback generation
- curator fallback answers
- caching and timeouts
3. Persistent Resurrection Bay
Revived projects are not temporary UI state. They become part of a scoped archive for that museum.
4. Exportable outcomes
The output is not trapped in the interface. Users can export plans and download repo-ready guidance artifacts.
Business / Product Value
One of the most interesting things about abandoned code is that it often represents hidden capital.
Not every dead repo deserves to come back. But many deserve a second look.
Museum of Dead Dreams helps compress the time required to:
- discover forgotten projects worth revisiting
- understand what they are
- diagnose why they died
- define what should happen next
- and package that thinking into something actionable
Here’s the framing I used:
This is useful for:
- solo developers with years of side projects
- hackathon builders reviewing unfinished experiments
- startup founders revisiting prototype graveyards
- engineering managers evaluating internal abandoned tools
- open-source maintainers trying to prioritize what to revive
My Experience with GitHub Copilot
GitHub Copilot was a meaningful part of finishing this project.
I do not mean that in the shallow “AI wrote everything” sense.
I mean that Copilot helped me behave like a more effective finisher.
It supported the process by helping me:
- inspect and reason about code structure faster
- tighten workflows across multiple components
- refine technical documentation
- shape product-facing explanations
- prepare repository instructions
- polish submission materials
- and move the project from “interesting prototype” to “launch-ready experience”
That last part matters.
The whole spirit of this challenge is not just to build something new, but to finally finish something that was left unfinished.
That is exactly what happened here.
Copilot was especially useful in the finish-up stage:
- repo polish
- docs
- architecture communication
- developer onboarding
- GitHub-ready packaging
- and turning the repo into something others can understand quickly
So my experience with GitHub Copilot was not just about speed.
It was about momentum.
It helped reduce friction in the exact phase where many side projects usually die: the final stretch.
Why This Project Fits the Challenge
This challenge asks for a clear comeback story.
Museum of Dead Dreams is, in a way, a meta submission.
It is a project about abandoned software.
And it was itself revived and finished for a challenge about reviving unfinished work.
That made the completion arc very natural and very honest.
I did not just “add a few features.”
I turned a concept into:
- a functional full-stack product
- a real AI workflow
- a polished public repository
- a demoable experience
- and a stronger statement about how we should think about unfinished code
Final Thought
Most unfinished projects are not failures.
They are frozen momentum.
Museum of Dead Dreams is built around the belief that with the right context, diagnosis, and execution handoff, abandoned repositories can become future products.
If GitHub is where software lives, then maybe it should also be where dead ideas get a second chance.
Links
- Repository: https://github.com/jpablortiz96/Museum-of-Dead-Dreams
- Video Demo: https://youtu.be/qmLwdTxxjIA
Built by Juan Pablo Enríquez Ortiz / Eduky.
Top comments (0)