explainmyrepo

open source · free · no login

You built something genuinely good. Give it a front door that proves it.

Point explainmyrepo at any GitHub repo. It reads the real source and builds a designed explainer page, a repo you own and a downloadable AI knowledge pack — so a stranger goes from “never seen this” to “oh, I get it. I want this.”

A real explainer page that explainmyrepo generated for the PhotonLayer repo: a bold headline 'The lens already did the thinking', a prism splitting white light into a rainbow, and an independent-explainer provenance line.
one flat repo in → bespoke explainers that build themselves · no two alike

PUBLIC repo? Build it right here — no keys, no install

See a real one

PRIVATE repo you own? Run it inside VS Code / Claude Code

Your editor already has everything this needs: the keys in your .env, the GitHub login that can see your private repo, and your Claude Code subscription to do the thinking. Add one OpenAI key and paste:

npx explainmyrepo <github-url>
  • a page you forward
  • a repo you own
  • an AI knowledge pack

Before → after

The same repo. Two very different first impressions.

Left: the GitHub README of ruvnet/agenticow, as a stranger first meets it. Right: the explainer explainmyrepo built from the same source. Drag the handle to compare.

The explainer page explainmyrepo generated for the agenticow repo: a dark teal hero reading 'Branch a million-vector memory in 0.5 ms and 162 bytes' beside a glowing generative branching-network diagram. The top of the ruvnet/agenticow GitHub README: a long centred title, an intro line, a row of badges and links, and the start of a dark banner image.
Same repo, same facts. Open the full explainer · See the README on GitHub

Why this exists

Why great GitHub repos lose readers, and why AI assistants guess

Great tools ship with READMEs written by people who already get it — so a curious developer hits a wall of jargon and quietly closes the tab.

It isn’t that the tool is bad. The introduction is. Engineers ship things assuming people already know why they’d care — and they usually don’t. That costs you twice in the age of AI:

A human lands on your repo, doesn’t get it in thirty seconds, and leaves — the work was great, the welcome wasn’t.

An AI (Claude Code, Cursor) gets asked about your repo and guesses, because it has no grounded understanding of the actual source.

What you get

One command. Three things you keep.

Each one is grounded in your repo’s real source — no invented features, no confident guessing.

A live explainer page

The link you actually forward. A bespoke, art-directed walkthrough at its own URL — a real architecture diagram and a real data-flow diagram, drawn from your code itself.

the page you share

A GitHub repo you own

You’re invited as a collaborator on the explainer’s own repository, so you can edit it any time. It’s yours — separate from your app’s repo, never tangled with it.

yours to edit

A downloadable AI pack

A drop-in .zip: a real RVF vector knowledge base, a search CLI and an MCP server — so Claude Code or Cursor answer about your project from the real source, not a guess.

for their AI

And the builder itself does more when you clone it: npx explainmyrepo capabilities lists verified local companions — today, a shareable trailer and a social loop rendered from your page’s own assets for ~$0.

The process

Not a template filler. A thinking author.

This is the part you couldn’t be bothered to do by hand — and the part that makes the result look like a serious team built it. One brain runs your repo through an ordered sequence, and loops on the quality gate until it’s genuinely good.

The explainer build pipeline Seven stations run left to right: read, understand, conceive, author, visualize, then grade — which loops back to refine — and finally ship. A pulse of light travels along the connecting track. refine ⟲ until it clears the bar 01read 02understand 03conceive 04author 05visualize 06grade ⟲ 07ship
read, understand, conceive, author, visualize, grade (loop), ship.
  1. Read — clone the repo and confirm it’s reachable.
  2. Understand — build a real RVF vector knowledge base from the actual code, plus a symbol index, dependency graph and entrypoints. Everything downstream is grounded here.
  3. Conceive — before writing a word, invent this repo’s art direction: a visual metaphor that fits, a palette, a type personality, a hero. That’s why every explainer looks different.
  4. Author — write along a comprehension arc, the questions a newcomer actually asks, in order. Every claim traces to a passage in the KB.
  5. Visualize — generate emotional imagery and crisp vector diagrams. A real architecture diagram and data-flow diagram are mandatory, drawn from the repo’s own structure.
  6. Grade ⟲ — render the page, score it on real pixels, and refine in a loop until it clears the bar.
  7. Ship — deploy the already-great page, create the repo, invite you in, and email you the scorecard, both screenshots and every link.

The quality gate

It refuses to ship something ugly.

A generic generator emits something and stops. explainmyrepo does not ship until an independent critic and a set of owner-signed questions both pass — on mobile and desktop.

The quality gate flow The live page is rendered at mobile and desktop sizes, an independent vision critic scores craft and substance, six operator questions must all answer yes, and only then does it ship. A back-arrow shows the refine loop. render · 390 + 1440px independent vision critic Gate A · substancedo they get it? Gate B · craftdid someone who cares make this? ≥ 90 6 operator questions ship it ✦ refine the named weakness

On both devices, the operator must answer YES to all six — looking at the real screenshots:

  1. Would this make me believe I understand this?
  2. Would this make it approachable?
  3. Would this explain it for somebody who doesn’t understand it?
  4. Would it give me confidence I understand the architecture?
  5. Does it make me smile — “oh, that’s cool”?
  6. Could someone who knows nothing about this domain read the first four sections and explain it back?
90mean · min axis 85

Anchored to real, hand-built exemplars — not impossible perfection. One weak axis (a raw diagram, a pretty-but-empty image) scores ~50 and fails the whole build. If a repo genuinely can’t clear the bar, it says so honestly instead of shipping slop.

Get seen

A great repo nobody can find is wasted.

Breaking through the noise on GitHub is almost impossible unless you’re already a name. So every explainer ships the professional touches that make your work look credible — and widen the circle of people (and AIs) who’ll actually find it.

SEO & AI discoverability, baked in

Real meta tags, sitemap.xml, robots.txt and an llms.txt — so search engines and AI crawlers find it and represent it correctly.

Favicons in 7 sizes

16 / 32 / 48 / 192 / 512, an .ico and an apple-touch icon — so the browser tab, the bookmark and the home-screen shortcut all look intentional.

A 1200×630 share card

A designed Open Graph card with your tagline baked in — so a link dropped in Slack, X or iMessage unfurls as a rich, elegant preview instead of a bare URL.

A bare text link versus the rich link-preview card explainmyrepo generates.

One brain, three doors

The judgment lives in one place.

The whole brain is a single Claude Code skill. Three thin doors run the identical engine — pick yours by one question: is the repo public, and whose keys should do the work?

This website — public repos

The zero-setup door. Public repo? Paste the URL above — no keys, no install, nothing to configure. We build it, host it, and email you the link.

explainmyrepo.isovision.ai

npx — private repos & your keys

Best run inside VS Code / Claude Code, in a project whose .env already holds an OpenAI key (art + grading) and a Netlify token (the live URL — optional). Logged into Claude Code? The brain runs on your subscription — no Anthropic key needed. Private repo: gh auth login first. The command checks all of this up front and tells you exactly what's missing.

npx explainmyrepo <github-url>

Claude Code plugin

Install once, then explain any repo with a slash command from inside Claude Code — same brain, your session does the thinking.

/explainmyrepo <github-url>

Real examples

Same engine. Six completely different looks.

Each was generated end to end and held to the same gate — unique by default, reliably great by construction. Open any of them.

Get started

One question decides your door: is the repo public?

Public repo → easiest right here: paste the URL, zero keys, we build it on ours. Private repo you own → run the npx command inside VS Code / Claude Code, where your keys and your GitHub access already live. Same engine, same quality gate, either way.

public repos · zero keys · easiest

Public repo? Paste it. We build it for you.

No keys, no install, no terminal. Drop a public GitHub URL and we run the full AI build on our keys, then hand you the live link.

This runs a full AI build — most builds take 10–25 minutes (the biggest repos can run past half an hour). Keep this page open to watch it happen, or just leave your email and we’ll send the link when it’s ready.

private repos · your keys · open source

Private repo you own? Run it in VS Code.

Recommended: run this inside a VS Code / Claude Code session, in a project whose .env already holds your keys — everything is picked up automatically. Private repo: gh auth login first.

npx explainmyrepo <github-url> --ship-best-effort
How many keys? Inside Claude Code: one.
  • OPENAI_API_KEY — imagery + the quality gate (required)
  • ANTHROPIC_API_KEY — not needed in Claude Code: the brain rides your Claude login. Bare terminal only.
  • NETLIFY_AUTH_TOKEN — the live URL (optional; --no-deploy builds the full page locally)

Set them in your project's .env — the CLI checks everything up front and tells you exactly what's missing and how to fix it.

It’s fully open source — pull it down, read it, run it, star it: github.com/stuinfla/Repo-Explainer

Questions

What people ask before they build.

Straight answers about cost, limits, private repos and what you actually get.

What is explainmyrepo?

explainmyrepo reads a GitHub repository and builds three things: a designed, standalone explainer page, a GitHub repo you own for that page, and a downloadable AI knowledge pack. The page is written for someone who has never seen your project, and every claim traces back to the repo’s real source.

How do I turn a GitHub repo into an explainer page?

If the repo is public, paste owner/name or the GitHub URL and your email into the form at the top of this page, and we build it and email you the live link. If it is private, run npx explainmyrepo <github-url> inside VS Code or Claude Code with your own keys.

Is explainmyrepo free?

Yes. It is open source (MIT) and needs no login. Hosted builds for public repos run on our own keys, so each email can request 5 free builds and capacity is limited each month. After that, run it yourself with your own API keys.

How long does a build take?

Most builds finish in 10 to 25 minutes, and the largest repos can run past half an hour. You can close the tab: if you leave your email, we send the link when it is ready.

Does it work on private repos?

Not through the website, which only builds public repos because it publishes a public page. For a private repo you own, run npx explainmyrepo <github-url> inside VS Code or Claude Code with your own keys and GitHub login.

What is in the AI knowledge pack?

A drop-in .zip containing a real RVF vector knowledge base built from your repo, a search CLI and an MCP server, so tools like Claude Code or Cursor answer questions about your project from its real source instead of guessing.

Will it make things up about my project?

It is built to avoid that. The page is written from a knowledge base of your actual source, and before anything ships an independent vision critic and six operator questions must pass on both mobile and desktop. If a repo cannot clear that bar, it says so instead of shipping a weak page.

Who owns the result?

You do. You are invited as a collaborator on the explainer’s own GitHub repository, so you can edit it any time. It is separate from your app’s repo.

What do I need to run it myself?

Node.js and an OpenAI key (imagery and the quality gate). Inside Claude Code the writing runs on your Claude login, so no Anthropic key is needed. A Netlify token is optional: without it you still get the complete page locally.

Give your repo the front door it deserves.

You did the hard part — you built something real. One command turns it into a page people actually read, an AI pack their assistants understand, and a first impression that finally matches the work.

npx explainmyrepo <github-url>

Your turn

Did this land? Tell me straight.

Thirty seconds. Grade it, tell me what worked or what’s missing, drop an idea or a repo you’d point it at. It comes straight to me — real feedback shapes what this becomes.

How clearly did it land?
Still fuzzyCrystal clear