AI
I Built a Second Brain for My GitHub (and I'm Keeping the Code Private)
Five failed attempts, one missing check, and the vault that finally works: an Obsidian brain map of 200 repositories, written from the code by an AI agent every night and reviewed by me. Here is how it works, and why the code is not public.
Rishabh Dubey
5 min read

I built a second brain for my GitHub
I have more than two hundred repositories. Side projects, hackathons, take-home assignments, experiments that lasted an evening. For a long time I could not answer simple questions about my own work: which projects are actually finished? Where did I already solve this problem? Which README is still telling the truth?
So I built a vault: an Obsidian knowledge base where every repository gets a folder of notes written from its source code. It is the project I am proudest of, and it is a project whose code I am not sharing. I will explain both.
Five attempts that all made the same mistake
This is not my first try. Between April and August 2026 I built five versions of this idea. The first was a handful of notes written by hand. Then came a script that filled four templates per repository, a big API with dozens of endpoints, an agent pipeline with a typed graph, and finally a set of scheduled jobs running on GitHub Actions.
Each version was better engineered than the one before. And each one shipped the same defect, which I only saw when I went back and read what they had produced:
Every attempt was built to produce output. None was built to read its own output.
One version published a benchmark from a script that was empty. One returned random numbers as embeddings. The last one ran green on a schedule for eight days while publishing nothing at all. Every redesign fixed what the previous attempt was visibly bad at, and none of them asked the only question that mattered: did what came out actually contain anything true?
The fix: make every claim checkable
The current vault is built around that one missing check. Every note follows a few strict rules:
- Every factual claim carries a
path:linethat was opened and checked. If a claim cannot be anchored to the code, it is deleted, not softened. - Snippets are copied verbatim, with their file and line range.
- A README is a claim to test, never a source. Several of mine failed that test.
- No placeholders, no pasted tool output, no filler. A missing section is honest; padding is not.
- Secrets are never written down. No secret value ever appears in a note.
And then a machine checks the rules. A Python verifier opens every path:line reference and fails the run if any of them does not resolve, if a link points nowhere, if a placeholder or an unredacted secret slipped through, or if a repository's notes do not link out to anything else. A note set that fails goes back to be rewritten.
How it grows every night
I do not write the notes by hand any more. A scheduled Claude Code agent runs every night against a written runbook. It takes the next repositories from a ranked queue, clones them, reads the code, writes or deepens their notes and runs the verifier.
- I review, the bot authors. Each run pushes a branch, and a GitHub Actions workflow opens the pull request as a bot. I read it and merge it, the same way I would review a colleague's work.
- Runs can be resumed. In-flight state lives on the run branch, so a run that gets cut off is picked up by the next one.
- A watchdog. A morning workflow opens an issue if the night's run is missing or stuck.
- Everything is measured. Every failure, skip and workaround is logged as an issue, and the stats on the vault's front page are generated from those logs.
As of October 2026 it covers 201 repositories with 402 repository notes, 22 notes on concepts that recur across projects and 27 on the technologies I use. The project pages on this site were picked using its grades.
What it taught me about my own code
- I build in bursts. Many of my projects were written in one or two long sittings. Sometimes that produced my most careful code; sometimes it produced commit messages that just say
fix. - READMEs drift. A README describes the project I meant to build. The code describes the one I built. They are often not the same project.
- A green build is not proof. A test suite that quietly registers zero tests, or a model score measured on the wrong unit, both look like success. Ask what the number actually measured.
- My best ideas were already written. Several problems I was about to solve again had a good solution sitting in an older repository.
Why I am not sharing the code
This is a deliberate choice, made for my own good. The vault reads every repository I have, including private projects and client work. Its notes quote that code line by line. Publishing the vault would publish all of it, so the vault and its tooling stay private.
What I can share is the idea, and I think the idea is the valuable part: if you build anything that generates knowledge, build the thing that reads it back and checks it first. Everything else is just output.