notebooklm-study-kit

Turn NotebookLM into a private tutor and master a technical domain at an expert level — a reusable method, question playbooks, and tooling for spinning up a new study topic in minutes.

Languages: English · 日本語

notebooklm-study-kit is a multi-topic monorepo for learning technical domains with NotebookLM using an active-recall question playbook. You assemble a small, curated set of authoritative sources (the corpus), then ask a sequenced set of expert-grade questions instead of "summarize this". The method is topic-independent, so adding a new domain is a templated, repeatable step.

The approach is inspired by a post from @ihtesham2005 ("use NotebookLM as a private tutor and compress a semester of study into 48 hours"). The full write-up of the method lives in METHOD.md.

What you get

• A learning method (METHOD.md) — how to curate sources and which questions to ask, with the evidence behind every moving part (METHOD.md §1.1: each mechanism cites the meta-analysis or randomized trial it rests on — and the kit makes no "10× faster" claims, because no such evidence exists).
• 11 reusable playbook files (playbook-template/) — Configure-Chat setup, mental models, tensions, trajectory, interview questions, a weak-spot diagnosis, a calibrated self-test loop, successive relearning, and a teach-back finale, plus a 99-corpus-audit exception step (for hand-built corpora).
• Five learner paths — 00-how-to-use's "choose your path" table adapts the same corpus from complete beginner through senior-aiming-for-expert (source selection, difficulty, focus steps).
• Topic tooling (tools/) — scaffold a topic, snapshot sources to Markdown (one page or a whole manifest), fetch talk transcripts, validate a corpus (CJK-aware, URL liveness), schedule your reviews (review_due.py reads your review-log.md), and regenerate a topic's playbook for a new learner level (regenerate_playbook.py).
• An add-topic skill (.claude/skills/add-topic/) — drives the whole setup from Claude Code: archetype & goal → scaffold → collect corpus → customize playbook → validate → index.
• A regenerate-playbook skill (.claude/skills/regenerate-playbook/) — rebuilds only the playbook for an existing topic when you level up (beginner → intermediate → senior), leaving the collected corpus untouched.
• A worked example (topics/android/) — an "Android 2026" topic, shipped without its corpus (see below).
• Two ways to run it (METHOD.md §8) — the default cadence (2 sessions/week × 30–60 min, ≥8 weeks) or the 48-hour sprint with sleep-split relearning when the deadline is real.

⚠️ The corpus is NOT included — and you should not commit it

A topic's corpus/*.md files are faithful Markdown snapshots of upstream documentation (for the Android example, the official Android docs). Those are copyrighted by their authors, so redistributing them would be a copyright problem. Therefore:

• This repository ships with empty corpora. Every topics/*/corpus/ directory contains only a .gitkeep. You build your own corpus locally and upload it to NotebookLM directly — it never needs to be committed.
• .gitignore enforces this. topics/*/corpus/* is ignored (except .gitkeep), so a corpus you build locally is never committed by accident.
• If you build a corpus, keep that clone private and do not redistribute it.

Repository layout

notebooklm-study-kit/
├── METHOD.md              # [shared] the learning method (topic-independent)
├── playbook-template/     # [shared] 11 generic playbook files (00–09 + 99-corpus-audit, with {TOPIC}/{ROLE} placeholders)
├── tools/                 # [shared] scaffold / fetch_snapshot / rebuild_corpus / fetch_transcript / validate_corpus / review_due / regenerate_playbook
├── .claude/skills/add-topic/            # [shared] Claude Code skill that orchestrates a new topic
├── .claude/skills/regenerate-playbook/  # [shared] rebuild the playbook for a new learner level (corpus untouched)
└── topics/
    ├── README.md          # topic index
    └── android/           # worked example — Android 2026
        ├── README.md      # topic overview + NotebookLM upload steps
        ├── playbook/      # Android-specialized prompts (derived from the template)
        ├── corpus/        # ← empty here (.gitkeep only); you rebuild it locally
        ├── sources/       # url-manifest.md / io-2026-talks.md (the source list to rebuild from)
        ├── review-log.md  # your study state (confidence / grades / due dates)
        └── coverage-map.md

Quickstart

1. Pick a topic. Use the bundled android example, or add your own (next section).
2. Build that topic's corpus locally — see Adding a topic. For the android example, topics/android/sources/url-manifest.md lists every source to rebuild from.
3. In NotebookLM (pick a tier whose per-notebook source limit fits your corpus — see METHOD.md §2), create a notebook and upload the generated corpus/*.md as file sources and the URLs from sources/ as URL sources (tools/rebuild_corpus.py <topic> --upload-list prints the checklist).
4. Set NotebookLM's output language to match the playbook language you run — the English playbook (*.md) expects English output, the Japanese playbook (*.ja.md) expects Japanese output.
5. Paste playbook/01-chat-config.md into Configure Chat (citation discipline, scope-lock, no answer-dumps — applies to every chat and Studio artifact) and write your retention-goal date into review-log.md.
6. Run the prompts in topics/<topic>/playbook/ in the recommended order (00-how-to-use.md explains it, with per-tier session plans). Progress is the closed-book senior-rate trend in review-log.md (tools/review_due.py tells you what's due today) — not the post-session feel.

Adding a topic

With the add-topic skill (recommended): from Claude Code, say "add a topic". The skill scaffolds the tree, collects a curated corpus, customizes the playbook, validates, and updates the indices, following METHOD.md. It treats topics/android/ as an example to imitate, not a dependency.

Manually: the same steps are documented in topics/README.md:

python3 -m pip install -r requirements.txt
python3 tools/scaffold_topic.py --slug <slug> --topic "<Topic>" \
    --role "<expert persona>" --context-key <topic>_context --lang <en|ja>
# ...collect corpus with tools/fetch_snapshot.py, then:
python3 tools/validate_corpus.py topics/<slug>

The Android example

topics/android/ is a fully specialized worked example — playbook, coverage map, and source list — with its corpus left out (see the copyright note above). Its README.md, coverage-map.md, and sources/ show what a built-out topic looks like and list every source, so you can rebuild the corpus with one of the methods above and then upload it to NotebookLM.

A note on language

The shared layer ships in both English and Japanese. English files are *.md, Japanese files are *.ja.md — for example METHOD.md / METHOD.ja.md and playbook-template/02-mental-models.md / …02-mental-models.ja.md. Prose docs carry a language switcher at the top; template prompts and source manifests come as *.md / *.ja.md pairs without a switcher, since they are pasted whole into NotebookLM. A topic you generate with add-topic, by contrast, is single-language (your language) under plain *.md names — an English speaker doesn't want *.ja.md files and vice versa. The corpus sources themselves stay in their original language. See METHOD.md §7.

Contributing & security

See CONTRIBUTING.md and SECURITY.md. By participating you agree to the Code of Conduct.

License

MIT. The learning method is credited to @ihtesham2005; this repository's original contributions (playbooks, tools, structure) are MIT-licensed.