vibetime
wipSession management for vibe coding — structured logs, enforced focus, and a path from session notes to published updates.
vibetime is a session management layer for the vibe workspace. It replaces the ad-hoc SESSION.md scratchpad with structured session files, skills for starting and closing sessions, and CLAUDE.md-driven continuity across context clears.
The problem
Claude Code starts each conversation without memory. A rolling scratchpad helps orient the next session, but it gets overwritten, loses history, and doesn't enforce a goal. Without a clear goal, work drifts. Without a log, a context clear means starting from scratch.
How it works
Sessions live in `~/src/vibe/.sessions/` as Markdown files with YAML frontmatter. Each file has a title, timestamps, a status (`open` or `closed`), a Goal section (one paragraph from the approved plan), and an append-only Log. Log entries are timestamped and tagged with the project being touched.
Filenames encode the date and a daily index: `2026-03-12-0-workspace-setup-vibetime.md`. The index increments if you start a second session the same day.
Three skills drive the workflow:
- `/vibetime-new` — checks for open sessions, enters plan mode, creates the session file after approval - `/vibetime-pick` — lists all sessions with status and goal summary, lets you resume any of them - `/vibetime-close` — marks the session closed, summarizes what was done, reminds you to draft website updates
CLAUDE.md at the workspace level reads the active session pointer from `SESSION.md` at startup, greets with the session title and recent log entries, and flags topic drift if a request strays from the session goal.
The path to published updates
Session logs are the raw material for the `updates[]` entries on each project page. At close time, vibetime reminds you to translate significant log entries into prose updates in `byanth.io/src/content/vibe/index.ts`. The workflow closes the loop: plan → build → log → publish.
session updates
vibetime is a session management framework built for the vibe workspace — the setup where all development is done exclusively through Claude Code, with no hand-written code. The core problem it addresses: Claude starts each conversation without memory, and the only continuity mechanism was a hand-rolled SESSION.md scratchpad that got overwritten and lost history. Without a structured goal, sessions drift. Without a log, a context clear means reconstructing from scratch what was being worked on and why. The design centers on structured session files in ~/src/vibe/.sessions/ — Markdown with YAML frontmatter (title, timestamps, status), a Goal section written from the approved plan, and an append-only Log with timestamped entries tagged by project. Filenames encode date and a daily index so multiple sessions per day are supported. Three workspace skills drive the lifecycle: /vibetime-new enters plan mode and creates the session file on approval; /vibetime-pick lists sessions with status and goal summaries for resuming; /vibetime-close marks a session done, summarizes what was accomplished, and prompts to translate log entries into updates[] entries on the website. The workspace CLAUDE.md was updated to read the active session pointer from SESSION.md at startup, greet with the session title and recent log entries, and flag topic drift when a request strays from the session goal. This closes the continuity loop without requiring the user to re-orient Claude manually. First session implemented: the workspace setup session itself, seeded from log entries captured before vibetime existed. The framework, skill files, and GitHub remote were all created in this session.
The first real use of vibetime surfaced two bugs. Claude wasn't executing the session start greeting on load because CLAUDE.md used passive conditional language — "when this file loads, read SESSION.md…" — which Claude treats as background context rather than an immediate action. The fix was to make the instruction explicitly imperative and unconditional: the very first thing Claude does in every conversation is read SESSION.md and greet with session context. This is also stored in auto-memory so the behavior persists across context resets independently of CLAUDE.md. The second bug was that /vibetime-new would block when a session was already active, requiring the user to close the old session first and re-run the command. This came from the status: open/closed field in session frontmatter — the command checked it to detect open sessions. But the status field was redundant: SESSION.md already encodes active-session state by containing a path into .sessions/. Dropping the status field and removing the blocking check means starting a new session just overwrites SESSION.md. The old session file stays on disk as a historical record. /vibetime-close was removed entirely; it only made sense as a companion to the status tracking model. The session log entry rule was tightened from a suggestion to a mandate: every feature change above a minor tweak must produce a log entry as the final step of execution, written at the level of a detailed technical blog post. "Significant changes" was too subjective and easy to skip. The second session also revealed a structural gap: /vibetime-new creates the session file before work begins and relied on execution to remember to append a log entry afterward. That implicit dependency meant the log step could be forgotten with no named trigger. The fix was /vibetime-update: an explicit command the user invokes at the end of execution to record what was built. It reads SESSION.md, appends a timestamped log entry to the Log section, and updates last_updated in frontmatter. The invocation is now a named hook rather than an implicit side effect. /vibetime-new was updated in both command locations to reference /vibetime-update at the end of execution. The missing session file from the previous session was backfilled from the plan's Planned log entry section, since plan and execution matched exactly.