The Last Commit：為自己的程式碼庫撰寫數碼遺囑的 3D 空間體驗

The Last Commit: Drafting a Digital Will for Open Source

Hacktoberfest 2026 DEV Challenge: Week 4 — Ghost in the Machine

What I Built

The Last Commit is a 3D spatial "study" where you write the digital will for one of your own GitHub repos.

You type a GitHub handle. The app picks one of your recently updated public repos and flies the camera down into a dark room full of cabins. There are 24 of them, and yours is the one with a candle burning. Three papers lie on the desk: an autopsy of the repo, its last commit, and a suggested successor.

An AI "executor" reads the exact same facts, asks you questions in a side panel, and after your third answer, compiles a Digital Will & Testament. It covers who inherits maintainership, what happens to the branches and issues, and what the final message to the community should say. You can download it as Markdown.

How I read the theme

My first idea was the obvious one: a graveyard where you paste in an abandoned repo and its ghost talks back. Then I looked at what other people were building, and a lot of them had the same idea. So I flipped it.

Repos go quiet for everyone eventually. When yours does, nobody knows who is allowed to merge, whether that last branch was finished, or what you wanted said. That felt like the right kind of haunting for this week: something that is still sitting there after you stopped showing up. The will is for the person who opens your repo in two years and has questions.

What it doesn't do

Nothing in the will is carried out automatically. The app has no write access to GitHub, so it never transfers a repo, archives anything, or posts an issue. The will is strictly a document. (I wanted a fast-forward scene where the will "executes" and the room changes, but I ran out of time!)

Demo

Live: the-last-commit-vtg8.onrender.com
Video:

One thing you should know before you click through: The live version has no language model behind it, so the interview questions and the will come from built-in templates. The repo facts on the papers are still real GitHub data, but the will text is canned and your answers are ignored. I'd rather say that here than let you think a template is Gemma writing. To see the real thing, run it locally with Ollama. The README has the steps.

Code

The Last Commit

A 3D study where you write a will for your own open-source repos.

Live demo: https://the-last-commit-vtg8.onrender.com (read About the live demo first)

Built for the Hacktoberfest 2026 "Ghost in the Machine" challenge on DEV, week 4.

The idea

Most ghost projects this week let you talk to dead code. This one goes the other way. You decide what happens to your repos before you stop committing: who inherits them, what gets archived, and what the last message to the community says.

You type a GitHub handle. The app picks one of your recently updated public repos and drops you into a dim 3D study with 24 cabins. Yours lights up. An AI "executor" does an autopsy of the repo, interviews you, and writes the will.

What happens when you play

Enter a GitHub username and press Enter the Study.
The camera flies down to one cabin…

The first commit is from October 29, inside the challenge window. The README covers setup, environment variables, and known limitations, and it will list any commit made after the deadline.

How I Built It

The app is built with Next.js, React, React Three Fiber, and @react-three/drei on top of Three.js, with Framer Motion and Tailwind for the interface. The model is Gemma (gemma4:e4b) running through Ollama on my laptop.

Two API routes do the heavy lifting:

The Fact Gatherer: Calls GitHub's REST API for the repo's metadata, its last commit, and its top five contributors (leaving out the owner and any bots).
The Executor: Has three modes, each with its own system prompt: an autopsy, an interview, and the final will. I call Ollama's chat endpoint in JSON mode with thinking turned off, at a lower temperature for the will than for the interview. The model gets the GitHub facts as a JSON blob, and the prompt explicitly tells it to pick the successor from the contributor list instead of hallucinating one.

Bugs I had to fix in code

The infinite interview: The first loop was a bug. I told the model to ask three questions and then stop, and it never stopped. If your answer was short, it asked a follow-up, and then another one. The fix was to stop asking a small local model to count. The server now counts your answers, and after the third, it returns "ready to compile" without calling the model at all.
3D HTML glitch: I first rendered the papers as HTML elements inside the 3D scene and tried to lift the hovered one up to face the camera. It was glitchy, and the clickable area didn't match what I was looking at. I ended up with flat papers on the desk that glow on hover. A click opens a normal reading card, with plain buttons as a backup.
Camera reset on typing: The walk keys were listening on the whole window, so typing an "a" in the chat moved the camera. I fixed this by ignoring key events from text inputs. I also moved the cabin list generation outside the component, because re-creating the array on every render was causing the camera's fly-to effect to reset on every keystroke.

(I used an AI coding assistant while building this, mostly for debugging the 3D math and camera rig above.)

Why Does Open Innovation Matter?

The interview asks things you would rarely type into a hosted box: why you gave up on a project, which commit you're embarrassed by, who you would or wouldn't trust with it. With Gemma running through Ollama, those answers go to a process on my own machine. The only network calls are to GitHub's public API for the repo facts. For this particular app, that is the whole argument.

It also made the build easier. Every interview run was free, so I could rerun it as many times as I needed while tuning the prompts. And the model is just one environment variable (OLLAMA_MODEL), so trying a different one doesn't touch the code.

There is a cost, and I hit it. Open weights mean somebody has to run them. I don't have a GPU server, so the Render deployment can't call Gemma, and the public demo is the template version. A hosted API would have made the live link work. I would still choose local here, because the answers are the part you would least want to send anywhere, but it means the best version of this project is the one you run yourself.

The Spirit of It

The moment I designed around is the first question. Once you've read the autopsy, the executor opens with something pulled from your own history.

"Your last commit read ''. Was that a surrender, or a pause?"

Most last commits are small and forgettable, and that is what makes the question land. It was the last thing you said to that project, and you didn't know it was the last.

When I tested this on my own repository, seeing the executor pull a mundane chore commit and frame it as a "surrender or a pause" genuinely made me stop and reflect on a project I had abandoned last year. It transformed a simple metadata fetch into a moment of real reflection.

Prize Categories

Best Use of Gemma: Gemma 4 E4B, through Ollama, is the core reasoning engine behind all three executor modes when the app runs locally.
Best Use of Render: The Next.js front end and its API routes are deployed on Render.