DEV Community: Sanjeevi Kumar V

RepoSéance: Summoning the Ghost of Forgotten Code with Open-Source AI

Sanjeevi Kumar V — Tue, 27 Oct 2026 10:46:40 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

👻 RepoSéance: Summoning the Ghost of Forgotten Code with Open-Source AI

Somewhere on GitHub, there are projects that once had ambitious roadmaps, enthusiastic contributors, and big ideas.

Then the commits stopped.

The README remained. The dependencies aged. The issues went unanswered. And the original context slowly disappeared.

What if we could summon those projects' digital ghosts and ask them what happened?

Meet RepoSéance, a local-first AI-powered software archaeology tool that reconstructs the story of forgotten repositories and helps developers bring them back to life.

What I Built

RepoSéance interprets the Week 4 theme, Ghost in the Machine, as a story about digital memory.

Software repositories preserve code, but understanding a project often requires more than reading its latest files. Important context can be scattered across commit messages, configuration changes, documentation, TODOs, and test failures.

RepoSéance brings those clues together using open-weight AI.

Point it at a local Git repository, and it investigates the project's history, searches for unfinished work, and generates a structured report called a Ghost Profile.

The Ghost Profile has five parts:

👻 1. The Last Words

A chronological account of significant changes near the end of the project's development. What was being built? Which areas changed most? What does the available history suggest about the project's final active phase?

🕯️ 2. Unfinished Business

A prioritized list of potential unfinished tasks, including TODO and FIXME markers, incomplete documentation, and tests that currently fail when safely executed.

🪦 3. The Graveyard

A report of potential maintenance concerns, such as declared dependencies with old version constraints, deprecated API usage detected by available checks, and suspiciously stale project configuration.

These are investigation leads, not automatic declarations that something is broken.

📜 4. The Séance Transcript

An atmospheric narrative that explains the repository's history in plain English, with references to the evidence behind its claims.

The AI can make the experience spooky, but it cannot invent commits, contributors, events, or developer intentions.

⚡ 5. The Resurrection Plan

A practical recovery roadmap: what to inspect first, which checks to run, what documentation to update, and which small improvement could make the project useful again.

The aim is to turn digital archaeology into actionable maintenance work.

Because abandoned software doesn't always need to remain abandoned. Sometimes it just needs someone willing to understand it.

Demo

Live demo: [Will be added soon]

The ideal demonstration uses a small, public or personally owned Git repository with a meaningful commit history.

The workflow:

Select a local repository.
Let RepoSéance inspect its Git history, file structure, and selected project files.
Watch the Ghost Profile appear, with evidence-linked findings.
Explore unfinished work and the suggested resurrection plan.
Export the report as Markdown to share with a potential maintainer.

Code

Contributions that would be especially valuable include support for more languages, better repository analysis, additional local models, and improved evidence verification.

How I Built It

RepoSéance is designed around a simple architecture: deterministic software analysis gathers the evidence, and an open-weight language model turns that evidence into an understandable investigation.

1. Repository forensics

Python handles repository inspection using Git history, file-tree traversal, configuration parsing, and targeted searches for TODOs, FIXMEs, documentation, and test files.

Git metadata provides timestamps, commit messages, changed-file information, and other available historical clues.

The application limits which files are analyzed, excludes common generated directories, and avoids treating arbitrary repository content as trusted instructions.

2. Open-weight AI inference

A compact instruction-tuned model, such as Qwen2.5-3B-Instruct or another compatible open-weight model, generates summaries and structured findings from the collected evidence.

A local inference runtime such as llama.cpp can make this practical without requiring a hosted LLM API.

The model is responsible for interpretation and explanation—not for inventing repository facts.

3. Evidence-grounded reports

Every important finding should reference a verifiable source, such as a commit hash, file path, line number, or command result.

The report separates:

Observed facts
AI-generated interpretations
Unverified hypotheses
Recommended actions

If the repository lacks sufficient evidence to explain why development stopped, RepoSéance should say so instead of inventing a dramatic backstory.

4. Interactive interface

A lightweight Streamlit interface presents the Ghost Profile as an interactive investigation board.

Users can inspect findings, expand their supporting evidence, filter maintenance concerns, and export the report as Markdown.

5. Safety by design

The first version performs read-only repository analysis. It does not automatically execute repository scripts, install dependencies, modify source files, or push commits.

Any optional test execution should require explicit user approval and appropriate isolation.

This keeps the experience useful without giving an AI model unrestricted control over potentially untrusted code.

Why Does Open Innovation Matter?

Forgotten software should not need a subscription to be understood.

A closed AI API could summarize a repository, but it would introduce a remote dependency into a workflow that may involve proprietary code, unpublished projects, security-sensitive components, or private development history.

Open-weight AI gives RepoSéance another path.

Privacy: Repository content can remain on the developer's machine rather than being uploaded to a third-party model provider.

Offline analysis: Once the model and required dependencies are installed, the core analysis can run without a live AI API, subject to the local runtime's requirements.

Model freedom: Developers can swap models, compare their explanations, tune prompts, and adapt the system for different programming languages and repository sizes.

Cost control: Local inference avoids per-token API charges, although it still consumes hardware resources and requires initial setup.

Long-term independence: The project is not tied to the continued availability, pricing, or policies of one hosted AI service.

There is also a deeper connection to open-source preservation.

An abandoned repository may still contain useful ideas, educational examples, or functionality that someone needs. Open tools make it easier for new maintainers to investigate that code and decide whether it deserves another life.

The model is replaceable. The evidence is inspectable. The analysis can be repeated.

That is the kind of digital archaeology I want to build.

The Spirit of It

For me, the most interesting part of RepoSéance is the idea that software has a form of memory.

Every commit records a decision. Every renamed function hints at an evolving design. Every TODO represents work someone thought mattered enough to leave behind.

But code cannot always tell us the full story.

RepoSéance is an experiment in recovering as much context as the evidence allows, without pretending that an AI can read the minds of developers who are no longer there.

Imagine opening a forgotten project and receiving this message:

"The last recorded change was five years ago. The authentication module was being refactored, three TODO markers remain in the payment workflow, and the test suite currently fails on a dependency compatibility issue. The reason development stopped is unknown. Here are three steps to investigate before you decide whether to revive it."

That's the moment I want to create.

Not a fake ghost claiming to know the past, but a useful digital archivist helping the living decide what to do next.

Some projects are dead. Some are merely waiting for someone to understand them.

👻 RepoSéance — The past left clues. The future needs maintainers.

TabSloth 🦥 - Let Your Tabs Take a Nap

Sanjeevi Kumar V — Wed, 21 Oct 2026 17:19:02 +0000

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

TabSloth 🦥 — Let Your Tabs Take a Nap

What I Built

I built TabSloth, a local-first AI browser companion that helps people escape the endless cycle of opening tabs, forgetting why they opened them, and promising themselves they'll organize everything later.

We've all been there.

You're researching a project. One article leads to another, a tutorial opens three documentation pages, and suddenly your browser looks like a digital junk drawer. Closing everything feels risky because somewhere in that mess is the thing you actually needed.

So you leave everything open.

For days.

TabSloth gives those tabs a better future.

With one click, it can:

Understand the chaos: Analyze open tab titles and page content to identify what each tab is about.
Group by intention: Organize related tabs into projects such as "Learn LangGraph," "Plan a Trip," or "Fix That Bug."
Create memory capsules: Generate a concise summary, preserve the relevant links, and identify the next logical action.
Hibernate the clutter: Let you close tabs once their useful context has been saved.
Resume without the archaeology: Reopen a project later and pick up where you left off.

Instead of asking users to become better at organizing, TabSloth makes organization something they barely have to think about.

The goal isn't to browse more efficiently. It's to spend less energy managing the act of browsing.

Demo

Live demo: [Will be added soon]

The ideal demo starts with a browser full of unrelated tabs, turns them into three or four project cards, hibernates the clutter, and restores one project with its summary and links intact.

Code

The project is designed around a browser extension, a local AI inference layer, and a lightweight interface for managing saved browsing sessions.

How I Built It

TabSloth is built around a simple principle: the AI should do the thinking, but the user's browser should retain control.

1. Browser extension

A browser extension collects tab metadata, including titles and URLs. With explicit user permission, it can also extract relevant page text.

The extension provides controls for analyzing tabs, reviewing suggested groups, saving sessions, and restoring them later.

2. Local open-weight AI

The core intelligence uses an open-weight instruction model, such as Qwen2.5-0.5B-Instruct, through a compatible local inference runtime.

The model receives normalized tab information and produces structured JSON describing:

Suggested project groups
A short description for each group
Important links
A concise session summary
A suggested next action

A lightweight validation layer checks the output before it is displayed or saved.

The model is replaceable, so developers can experiment with other compatible open-weight models without redesigning the application.

3. Local-first storage

Saved sessions and their metadata are stored locally in the browser. The AI workflow is designed to avoid sending browsing history or page content to a remote inference API.

After the model and required assets have been downloaded, the application can be designed to operate offline, subject to browser and runtime support.

4. Human-controlled automation

TabSloth proposes groups and actions, but the user remains in control of closing tabs and restoring sessions. Nothing should silently discard a user's work.

The result is a small, practical AI workflow rather than another assistant that requires constant attention.

Why Does Open Innovation Matter?

Browsing history can reveal far more about someone than they realize: work projects, personal interests, financial research, private correspondence, and unfinished ideas.

Sending all that context to a hosted AI service just to organize browser tabs is an unnecessary trade-off for this use case.

Open-source AI makes a different approach possible.

Privacy by design: Page content can remain on the user's device instead of being sent to a third-party inference API.

Offline capability: Once the required model assets are available locally, the core workflow can continue without a live AI service.

Freedom to experiment: Developers can compare models, adjust prompts, change grouping strategies, and optimize inference for different hardware.

Lower recurring costs: Local inference avoids per-request API charges, although it still consumes device resources and requires an initial model download.

Community-driven improvements: Contributors can improve tab extraction, grouping quality, model compatibility, accessibility, and browser support without depending on a single AI vendor.

A closed API might make the first prototype easier to deploy, but it would introduce a remote dependency for a task that benefits from local processing.

For TabSloth, open innovation isn't just about choosing a different model. It's about deciding that the user's browsing context should remain theirs.

The Lazy Payoff

Imagine finishing a research session with 30 open tabs.

Without TabSloth, you might spend ten minutes revisiting pages, renaming bookmarks, writing notes, and deciding what can safely be closed.

With TabSloth, the intended workflow is:

Click Organize My Chaos.
Review the AI-generated project groups.
Save the sessions and close the tabs you no longer need.
Return later and click Resume.

The target is to turn several minutes of repetitive tab management into a quick review.

I'll measure the actual time saved during testing rather than claim an unverified number. Useful metrics include grouping accuracy, summary usefulness, time required to organize a session, and the percentage of sessions users can successfully resume.

Because sometimes productivity doesn't mean doing more.

Sometimes it means finally closing those 37 tabs and going outside.

TabSloth: Your tabs work overtime. Let them rest. 🦥