Codebase to Course: a Claude Code skill that writes the tutorial for your repo

Vibe coders who shipped code they cannot explain

codebase-to-course targets one specific person: someone who builds software by instructing AI coding tools in natural language and never took a computer science course. The README calls them vibe coders, and the pain it names is narrow. You have built something, or found something on GitHub, and it works. You cannot say why. The four goals listed for that person are all about control rather than mastery: steer AI tools better, spot hallucinations and bad patterns, escape bug loops when the agent gets stuck, and hold your own in a conversation with an engineer. The pitch is explicitly not a career change. The stated ambition is coding as a superpower, a lower bar than fluency and an easier thing to deliver. What comes back is a course, not a code change. What the README does not say is how the skill decides which files matter, and that decision is the one that determines whether the result is worth reading.

Three files ship, and none of them is code

The top-level entries are .gitignore, README.md, SKILL.md and references/. That is the whole project. There is no package.json, no lockfile, no build script and no test suite, so there is nothing to install with a package manager and nothing for CI to run. Inside the skill folder the layout is fixed: SKILL.md carries the main skill instructions, references/design-system.md holds CSS tokens, typography, colors and layout, and references/interactive-elements.md holds the quiz, animation and visualization patterns. GitHub reports CSS as the primary language, which fits a repository whose substance is styling rules and prose directions to a model. The practical consequence is that the artifact you care about, the HTML course, is produced at run time by the coding agent and committed nowhere. You cannot diff two runs against each other, and you cannot review a change to the generator as code, because the generator is a set of instructions.

What lands in the single HTML file

The output is one HTML file with no dependencies, no setup and offline use. Scroll-based modules come with progress tracking and keyboard navigation. Code sits on the left with a plain English translation of it on the right, pulled from the real repository. The visualization list is concrete rather than aspirational: data flow animations, a group chat between components, and architecture diagrams. Quizzes are interactive and aimed at application instead of recall, and the sample given is a question about which files change when you want to add favorites. Glossary tooltips appear when you hover a technical term, and the styling is pitched away from what the README calls the typical purple-gradient AI look. Two constraints shape that output more than the feature list does. Snippets are exact copies from the codebase, never modified or simplified. And every screen has to be at least half visual, with text blocks capped at two or three sentences.

Copy the folder into ~/.claude/skills/ and ask for a course

Installation is a file copy, not a package install. Put the skill folder where Claude Code looks for skills, then open the project you want taught and ask for a course in plain language. The copy step is the entire procedure:

cp -r codebase-to-course ~/.claude/skills/

After the copy, open any project in Claude Code and type the request. One documented phrasing is:

Turn this codebase into an interactive course

Five trigger phrases are also listed: "Turn this into a course", "Explain this codebase interactively", "Make a course from this project", "Teach me how this code works" and "Interactive tutorial from this code". What you should see afterwards is a single HTML file. Where that file is written is not documented, so check the project directory after the first run. The folder you copied should look like this:

codebase-to-course/
├── SKILL.md                          # Main skill instructions
└── references/
    ├── design-system.md              # CSS tokens, typography, colors, layout
    └── interactive-elements.md       # Quiz, animation, and visualization patterns

Nothing else is required. There is no configuration file, no dependency to resolve and no version to pin, and the repository has no releases to choose between.

Verbatim snippets set a ceiling on what a module can explain

Original code only is the strictest rule in the skill. Snippets are exact copies from the real codebase, never modified or simplified, and the learner is meant to open the actual file and find the same code. That protects against a standard failure of generated tutorials, where a helper gets quietly elided and the example stops matching the repository. It also carries the repository's own mess into the course. A long handler pasted in full is harder to follow than a trimmed version of it, and the README states no rule about splitting, truncating or annotating, so nothing tells the model to break a big file into readable pieces. The 50 percent visual rule pushes from the other side, since anything that can become a diagram is told not to stay a paragraph. Between them, the output is at its best on a codebase made of short, well-named functions, and a repository of large files or long configuration blocks is the case the README leaves unaddressed.

Half the screen must be visual, and no metaphor repeats

Four rules govern the pedagogy. Build first, understand later inverts the usual order: build something, watch it work, then learn how it works, and the README is direct about why, saying most people quit traditional CS education before they ever build. Show, don't tell requires every screen to be at least 50 percent visual, allows no more than two or three sentences per text block, and states that anything which can be a diagram, an animation or an interactive element should not be a paragraph. Quizzes test doing rather than knowing: the worked example swaps asking what an acronym stands for for a report of stale data after switching pages, then asks where you would look first. No recycled metaphors means each concept gets one that fits it and the same one is never used twice, with a database as a library with a card catalog, auth as a bouncer checking IDs, and API rate limiting as a nightclub with a capacity limit. All four are directions to the model, not constraints anything verifies, and no repository file checks the result.

Plain chat in Claude Code covers the same need without a file

The nearest alternative is not a competing tool. It is the same coding agent without the skill folder, asked to walk through the project, and the skill's own trigger list contains a near duplicate of that request. The difference is the output contract rather than the explanation. A conversational answer is shaped by the question you typed and disappears with the session. A skill run produces one file with scroll modules, progress tracking, keyboard navigation, code beside plain English, quizzes and hover glossary, so it opens again later with no conversation to reconstruct. The cost of that guarantee runs the other way too. The contract is the same for every repository, whether the code is a small utility or a large service, and there is no documented way to ask for a shorter course, a different module order or a specific set of files. The other option is documentation written by the team that owns the code, which stays true as the code moves only when someone edits it.

No licence file, no releases, and no size ceiling

Several things a buyer would ask about are simply absent. There is no LICENSE file in the repository, so the terms for copying this skill folder into your own tooling are unstated, and nothing here is a legal reading of that gap. There are no GitHub releases either, so there is no version to pin and nothing to compare when the skill changes. The last push was on 2026-03-30, which is more than six months back, so assume the folder you copy today is the folder you keep. The README does not document how the skill picks files, how it handles a monorepo, or what a run costs in tokens and time. It sets no module cap and no output size limit, and one self-contained HTML file has to carry every snippet verbatim. Nor does it say how to refresh a course after the code changes, which leaves a full re-run as the only documented way to bring a course up to date.

Editorial conclusion

Adopt it if you ship code through an AI agent and want a teaching artifact you can reopen offline; skip it if you need a maintained reference document, because the repository has no licence file, no releases, and its last push was on 2026-03-30. Before the first run, read SKILL.md and the two files under references/ so you know which constraints the output will be held to.

Frequently asked questions

Official sources

1. Issues
2. README
3. zarazhangrui/codebase-to-course on GitHub