Daily Study Guide

Daily Study Guide

A Claude Code plugin that quietly logs your sessions and, on demand, turns a day's work into a study guide: what you did, why, the tech you used, the decisions you made, and what you learned — plus a "highlights worth remembering" section that doubles as work-log / résumé material. Optionally, it researches the day's topics on the web and appends current docs, recent news, and go-deeper links.

Built by Beer Digital LLC.

---

How it works

Two moving parts, by design:

1. Capture (automatic, in-session). Two hooks feed a tiny script that records one row per session — date, session id, working directory, transcript path — into ~/.claude/study-guide/sessions.jsonl:
   • SessionEnd writes the canonical row when a session ends.
   • Stop (fires when Claude finishes a turn) writes the same row once per session as a crash-safe fallback, so a session is still logged even if it's killed before SessionEnd can fire. Repeat turns are cheap no-ops thanks to a per-session guard file.
2. Generate (on demand). A script collects the day's sessions, compacts each transcript (keeps your prompts, Claude's text, and tool intent; drops bulky tool-output payloads so a full day fits the model), summarizes each with a fast model, then synthesizes one Markdown study guide with a stronger model. For very long single sessions it keeps the head and tail and omits the middle, so the day's ending isn't lost. With --research, a final pass uses WebSearch/WebFetch to append a "Further reading & what's new" section. You can steer the guide with --focus / --objectives / --tech, narrow it to a single project with --project, and fold a span of days into one guide with --since / --until (see Usage).

The valuable part of a study guide is the why, which lives in your prompts and Claude's explanations — so the generator works from the transcripts (which contain all of that), not from shallow tool logs.

The generator exports an internal flag so its own claude -p calls are not logged as sessions — otherwise every run would record itself and compound over time.

Backfill. The capture hook only sees sessions that run after the plugin is installed. To build a guide for a day with sessions the hook never recorded — including days before you installed it — use --backfill, which also scans ~/.claude/projects for that day's transcripts and merges them in (de-duplicated). Backfill auto-enables when the index has nothing recorded for the requested date.

Publish (optional). With --push, after the guide is written it copies the guide and the compacted transcripts into a local clone of a private git repo (STUDYGUIDE_GIT_DIR) and commits/pushes. The compacted transcripts (tool-output payloads already stripped) give you durable, re-processable source beyond Claude Code's ~30-day transcript retention, and centralize work across machines. Use the dir allow/deny filters (below) to control exactly which sessions are eligible — so, e.g., only personal projects are ever published.

1. Wiki (optional). Where the daily guide is a time-ordered log, the wiki is a topic-ordered, living reference. With --wiki (or the /daily-study-guide:studyguide-wiki command), it maintains one Obsidian note per project — Overview, Architecture, Decisions, Tech, Gotchas, Timeline — updating each page as new sessions come in, plus a generated Home.md Map of Content. It builds from the per-session summaries the generator stores under STUDYGUIDE_SUMMARY_DIR, folding in everything newer than each page's sessions_through (so re-runs are idempotent and backfilled history is picked up). The wiki folder is an Obsidian vault — point Obsidian at it for the graph view and [[wikilinks]]. With --push, the wiki commits to your repo under wiki/.

---

Requirements

• Claude Code (the claude CLI must be on your PATH).
• jq — brew install jq (macOS) or apt-get install jq (Debian/Ubuntu).
• The --research pass additionally needs network access and the WebSearch/WebFetch tools available to your CLI.

---

Install

Option A — proper install via the Beer Digital marketplace (recommended)

claude plugin marketplace add ./beer-digital-marketplace
claude plugin install daily-study-guide@beer-digital

Option B — instant local use, no marketplace

claude --plugin-dir ./beer-digital-marketplace/plugins/daily-study-guide

After either, confirm it loaded:

claude plugin list
# inside a session:  /hooks   (should show SessionEnd + Stop)   and   /studyguide

Capture starts from the next session onward.

First run / onboarding

Logging starts after install — the hooks only see sessions that run from then on. So your very first same-day /studyguide may find an empty index; when it does, it auto-scans ~/.claude/projects for that day's transcripts so you still get a guide. To build a guide for earlier days (including before you installed the plugin), add --backfill, which pulls those transcripts in too. After a session or two of normal use the index fills in and the auto-scan stops being needed.

Updating

claude plugin update daily-study-guide              # update the plugin
claude plugin marketplace update beer-digital       # refresh the marketplace first if needed

---

Usage

Inside Claude Code, when you're done for the day:

/studyguide                       # today, fast (no web research)
/studyguide 2026-05-29            # a specific date
/studyguide --backfill            # today, incl. sessions the hook didn't record
/studyguide 2026-05-20 --backfill # an older day, reconstructed from disk
/studyguide-deep                  # today + web-researched further reading
/studyguide-deep 2026-05-29       # a specific date, with research
/studyguide --wiki                # today's guide, then update the project wiki
/studyguide-wiki                  # update the wiki only (no daily guide)
/studyguide-wiki --push           # update the wiki and push it to your repo
/studyguide --focus "auth flow"   # steer the guide toward a learning angle
/studyguide --project marketplace # only sessions whose cwd basename contains "marketplace"
/studyguide --tech "bash,jq"      # emphasize these technologies (still covers the rest)
/studyguide --since 2026-05-26 --until 2026-05-30  # one guide spanning a range of days
/studyguide --dry-run             # preview the plan (sessions, models, budget, output) — no API call, no writes
/studyguide --push --allow-secrets # push even if the secret scan flags something
/studyguide-doctor                # read-only check of your install & config

--backfill and --research can be combined and appear in any order; both pass through the slash command.

Steer & scope the guide

These are all optional — with none set the guide behaves exactly as before. Each has an env-var fallback (below), and the flag overrides the env var. Value-taking flags accept both --flag value and --flag=value.

Flag	What it does
--focus "TEXT"	Free-text learning angle/objective to steer the guide (and, in --research, the further-reading section).
--objectives "TEXT"	Explicit learning objectives the guide should address.
--project NAME	Only include sessions whose project (cwd basename) contains NAME, case-insensitive.
--tech "x,y,z"	Comma-separated technologies to emphasize; the guide still covers everything else.
--since YYYY-MM-DD / --until YYYY-MM-DD	Fold a span of days into one guide. A range writes study-guide-<since>_to_<until>.md.
--dry-run	Print the plan (sessions, models, token budget, which passes would run, output path, push target) and exit — no Claude API call, no file writes, no push. Use it to preview cost/scope.
--allow-secrets	Override the push-time secret scan (see below) and push anyway.

Why & what-didn't-work (always on)

The guide and the per-session summaries now capture rationale and negative learnings, not just what was done:

• Each per-session summary adds ### Why this approach (reasoning, alternatives considered, why chosen) and ### What didn't work (dead ends, failed attempts, bugs, and why).
• The daily guide adds ## Why we chose these approaches and ## What didn't work sections.
• The per-project wiki page adds a ## What didn't work / dead ends section and records why an approach was chosen over the alternatives.

These are omitted automatically when there's genuinely nothing to say.

Guides index

After each run the generator (re)writes INDEX.md in your guides directory — a newest-first list of every guide with its TL;DR — so your accumulated guides are browsable at a glance. It's rebuilt from the study-guide-*.md files on disk every run (no extra API call).

Preview a run with --dry-run

--dry-run (or STUDYGUIDE_DRY_RUN=1) prints what would happen — the sessions it found, the summary/synthesis models, the token budget, which passes would run (research / push / wiki), the output path, and the push target — then exits without calling the Claude API, writing any files, or pushing. Use it to preview cost and scope before a real run. Each real run also prints a one-line notice that it calls the Claude API; --research / /studyguide-deep additionally warn that a live web pass may incur cost and take 1-2 minutes.

Push is privacy-scanned

Before --push commits anything (in both /studyguide and /studyguide-wiki), it scans the files it's about to commit for likely credentials — API keys, tokens, private keys, assigned passwords — using a shared scanner. If anything is flagged it refuses to push and tells you which file + category tripped it (secret values are never printed); review the files, then re-run with --allow-secrets (or STUDYGUIDE_PUSH_ALLOW_SECRETS=1) to push anyway. If the scanner is unavailable it fails safe and skips the push unless you opt in the same way.

Check your setup: /studyguide-doctor

/studyguide-doctor runs a read-only check of your install and config — dependencies (claude + jq), paths, guide/summary counts, the models and token budget in effect, push/wiki configuration, and which STUDYGUIDE_* env vars are active. It calls no API and writes nothing; use it to verify a fresh install or debug configuration.

Or straight from a shell:

bash ./scripts/generate-guide.sh                       # today
bash ./scripts/generate-guide.sh 2026-05-29            # a specific day
bash ./scripts/generate-guide.sh --backfill            # today, incl. uncaptured sessions
bash ./scripts/generate-guide.sh --research            # today + research
bash ./scripts/generate-guide.sh --push                # today, then commit/push to your repo
bash ./scripts/generate-guide.sh --wiki                # today, then update the Obsidian wiki
bash ./scripts/build-wiki.sh --push                    # rebuild the wiki only (no daily guide)
bash ./scripts/generate-guide.sh deep backfill push wiki 2026-05-29  # everything, args any order

Guides are written to ~/study-guides/study-guide-YYYY-MM-DD.md.

Run it automatically each evening (cron)

# 6:30pm daily. cron has a minimal PATH, so point CLAUDE_BIN at the real binary.
30 18 * * * CLAUDE_BIN="$HOME/.local/bin/claude" STUDYGUIDE_DIR="$HOME/study-guides" /bin/bash "$HOME/path/to/generate-guide.sh" >> "$HOME/.claude/study-guide/cron.log" 2>&1

Add --research (or STUDYGUIDE_RESEARCH=1) if you want the web-researched section in the nightly run. For a stable path that doesn't move when the plugin updates, copy generate-guide.sh somewhere permanent and point cron at the copy.

---

Configuration

All optional, set as environment variables:

Variable	Default	Purpose
STUDYGUIDE_DIR	~/study-guides	Where guides are written
STUDYGUIDE_INDEX	~/.claude/study-guide/sessions.jsonl	Session index location
STUDYGUIDE_PROJECTS_DIR	~/.claude/projects	Transcript root scanned by --backfill
STUDYGUIDE_SUMMARY_DIR	~/.claude/study-guide/summaries	Where per-session summaries are stored (the wiki's source)
STUDYGUIDE_WIKI_DIR	$STUDYGUIDE_GIT_DIR/wiki or $STUDYGUIDE_DIR/wiki	Obsidian vault dir the wiki is written to
STUDYGUIDE_GIT_DIR	(unset)	Local clone of your private repo; required for --push
STUDYGUIDE_INCLUDE_DIRS	(unset)	Colon-separated path prefixes; if set, only sessions whose cwd starts with one are included
STUDYGUIDE_EXCLUDE_DIRS	(unset)	Colon-separated path prefixes; sessions whose cwd starts with one are dropped
STUDYGUIDE_MODEL	sonnet	Model used to synthesize the daily guide (and the research)
STUDYGUIDE_SUMMARY_MODEL	haiku	Model used per session (cheap, fast)
STUDYGUIDE_RESEARCH	0	Set to 1 to always run the research pass
STUDYGUIDE_BACKFILL	0	Set to 1 to always scan ~/.claude/projects for the date
STUDYGUIDE_PUSH	0	Set to 1 to always push after generating
STUDYGUIDE_WIKI	0	Set to 1 to always update the wiki after generating
STUDYGUIDE_DRY_RUN	0	Set to 1 to plan only: print the plan and exit without calling the API, writing files, or pushing (same as --dry-run)
STUDYGUIDE_PUSH_ALLOW_SECRETS	0	Set to 1 to push past a secret-scan hit (same as --allow-secrets)
STUDYGUIDE_BARE	0	Set to 1 to add --bare to summary/synthesis calls (faster/cheaper on recent CLIs; off for max compatibility)
STUDYGUIDE_FOCUS	(unset)	Free-text learning angle/objective to steer the guide (same as --focus; flag overrides)
STUDYGUIDE_OBJECTIVES	(unset)	Explicit learning objectives to address (same as --objectives)
STUDYGUIDE_PROJECT	(unset)	Only include sessions whose cwd basename contains this string, case-insensitive (same as --project)
STUDYGUIDE_TECH	(unset)	Comma-separated technologies to emphasize; everything else still covered (same as --tech)
STUDYGUIDE_SINCE	(unset)	Start of a date range to fold into one guide (same as --since)
STUDYGUIDE_UNTIL	(unset)	End of a date range (same as --until)
STUDYGUIDE_MAX_TOKENS	120000	Primary token budget for the transcript portion of each per-session prompt (kept under Haiku's 200K); oversize sessions are chunked + merged
STUDYGUIDE_MAX_BYTES	MAX_TOKENS × 4	Secondary, derived byte ceiling per chunk; computed from STUDYGUIDE_MAX_TOKENS unless you set it explicitly to override
STUDYGUIDE_WIKI_MAX_TOKENS	150000	Token budget for each wiki page-update prompt (trims oldest new entries if exceeded)
CLAUDE_BIN	claude	Path to the Claude Code CLI

Using haiku for per-session summaries and sonnet for synthesis keeps cost low on heavy days while keeping the guide sharp. Set a model variable to empty to use your account default.

---

Publish to a private repo + schedule it (optional)

This gives you a durable, private journal of your work — generated and pushed automatically — using Claude Code's own scheduler, no GitHub Actions or cron.

1. One-time: create a private repo and clone it locally.

gh repo create my-work-journal --private --clone   # or make one in the GitHub UI and `git clone` it
# note the local path, e.g. ~/code/my-work-journal

2. Point the plugin at it (and optionally scope which projects are eligible).

Set these once in your shell profile (~/.zshrc / ~/.bashrc) so both manual runs and the scheduled task see them:

export STUDYGUIDE_GIT_DIR="$HOME/code/my-work-journal"
# Optional safety scoping — only ever publish sessions under these roots:
export STUDYGUIDE_INCLUDE_DIRS="$HOME/dev:$HOME/projects"
# …or, the inverse, never publish sessions under these roots:
# export STUDYGUIDE_EXCLUDE_DIRS="$HOME/work:$HOME/clients"

The filters apply to the whole guide when set, so excluded projects appear in neither the pushed transcripts nor the pushed guide. Test it manually first:

/daily-study-guide:studyguide --push

You should see Pushed guide + compacted transcripts to your repo (...), and the repo gets guides/study-guide-DATE.md and transcripts/DATE/*.jsonl.

3. Schedule it as a local routine (Claude Code Desktop).

Durable native scheduling lives in the Desktop app's Routines page (the CLI's /loop is session-scoped and stops when the session closes; cloud Routines can't see your local transcripts). In Desktop:

• Click Routines → New routine → Local.
• Set the folder to STUDYGUIDE_GIT_DIR (or any trusted folder), a daily time (e.g. 6:30pm), and the prompt: Run /daily-study-guide:studyguide --backfill --push.

Or just say in any Desktop session: "set up a daily routine at 6:30pm that runs /daily-study-guide:studyguide --backfill --push". A local task fires a fresh session on your machine with full plugin access, so it captures, compacts, summarizes, and pushes in one shot. (It runs while the app is open and the machine is awake — that's the trade-off for keeping everything local; capture happens during your sessions anyway, so an evening run lines up well.)

Re-processing later: because the repo stores the compacted transcripts, you can always regenerate or re-summarize history with a better prompt or model — they outlive Claude Code's transcript retention.

---

The Obsidian wiki

The wiki turns your accumulated sessions into a browsable, interlinked knowledge base — one living page per project, updated as you work.

• It's just a folder of Markdown — Obsidian is optional. The pages use Obsidian conventions (YAML frontmatter, [[wiki links]], #tags, and a Home.md Map of Content), but they're plain Markdown and read fine in any editor. If you do use Obsidian, point it at the wiki directory (STUDYGUIDE_WIKI_DIR, by default wiki/ inside your repo) via Open folder as vault and the graph view and backlinks work out of the box. No plugins or API needed.
• Living, not append-only. Each build merges new developments into the right sections of each project page and adds dated entries to that page's Timeline. It only rewrites pages for projects that had new activity.
• Seeding history. The wiki reads the per-session summaries the generator stores. To populate it from days before you started using it, run the generator with --backfill for those dates first (that regenerates and stores their summaries), then run /daily-study-guide:studyguide-wiki.
• Scope. The same STUDYGUIDE_INCLUDE_DIRS / STUDYGUIDE_EXCLUDE_DIRS filters apply to the summaries that get stored, so excluded projects never reach the wiki either.

To schedule both together, point your daily routine at Run /daily-study-guide:studyguide --backfill --push --wiki.

---

Notes & limits

• Privacy / where data goes. Transcripts and the index stay on your machine. Generating a guide sends compressed transcript text to a Claude model through your existing CLI auth — the same data path you already use with Claude Code. The --research pass additionally sends your search queries to the web search tool. Nothing else leaves your machine.
• No fabricated links. The research pass is instructed to use only resources it actually finds via search and to annotate in its own words (no pasted article text). Skim it before trusting any single link, as with any web research.
• Crash safety. The Stop hook records each session after its first completed turn, so a hard crash mid-session still leaves a logged row. Only a crash before the very first turn finishes would miss a session.
• Long sessions (no data loss). Transcripts are compacted (tool-output payloads dropped, long strings clipped) before summarizing. If a compacted session still exceeds the per-session model's context (Haiku 4.5 is a 200K-token model and does not get the 1M window), it's split into token-budgeted chunks, each chunk is summarized, and the parts are merged into one session summary — so a huge session is fully covered instead of being truncated or dropped with a "Prompt is too long" error. Tune the budget with STUDYGUIDE_MAX_TOKENS (default 120000).
• Missing most of a day? If a guide covers only part of the day, the rest was likely in sessions the hook didn't record (e.g. they ended before you installed the plugin). Re-run with --backfill to pull them from ~/.claude/projects.
• Transcript retention. Claude Code prunes session transcripts after ~30 days by default, so generate (and backfill) guides for old days before then. Missing transcripts are skipped gracefully.
• "End of day" is your call. Hooks are per-session, not per-day, so generation is triggered by you (/studyguide) or by cron — there is no day-boundary hook.
• macOS bash. The scripts avoid bash 4+ features, so they run under macOS's system bash 3.2.

---

Troubleshooting

• Nothing captured: ensure jq is installed and the scripts are executable (chmod +x scripts/*.sh); check ~/.claude/study-guide/sessions.jsonl.
• Hooks not firing: /hooks lists active hooks; claude --debug shows plugin loading. Event names are case-sensitive (SessionEnd, Stop).
• /studyguide errors on the model name: your CLI may not accept the sonnet/haiku aliases — set STUDYGUIDE_MODEL / STUDYGUIDE_SUMMARY_MODEL to full model strings, or empty for the default.
• Research pass returns nothing: your CLI build may not expose WebSearch/WebFetch in this context, or the network is blocked. The base guide is still written; only the extra section is skipped.
• claude not found from cron: set CLAUDE_BIN to the absolute path.

---

License

MIT