journaling

Capture structured session notes and lessons learned as markdown entries.

7|3|Updated Mar 17, 2026
One-click install
npx skills add https://github.com/brainbrewlabs/brainbrew-devkit --skill journaling-brainbrewlabs
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: journaling
Source: https://github.com/brainbrewlabs/brainbrew-devkit/tree/main/plugin/config/templates/develop/skills/journaling
Command: npx skills add https://github.com/brainbrewlabs/brainbrew-devkit --skill journaling-brainbrewlabs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Help teams capture concise, structured session notes, retrospectives, and lessons learned so knowledge from debugging sessions, incidents, and feature work is preserved and actionable rather than lost in chat logs.

Core Features & Use Cases

  • Context aggregation: Prompts to review recent git history, diffs, error logs, test outputs, and relevant plan files to assemble context for the entry.
  • Timeline & root cause synthesis: Guides the user to build a clear timeline of events, identify what worked and failed, and surface root causes.
  • Actionable lessons and follow-ups: Produces a compact journal entry with lessons learned and explicit action items, saved under docs/journal or docs/retros for future reference.
  • Use cases: Writing a post-debugging retrospective, documenting an incident and its resolution, capturing decision rationale after a design or implementation discussion.

Quick Start

Create a concise journal entry summarizing the recent debugging session with context, timeline, root cause, lessons learned, and action items, and save it to docs/journal/YYYY-MM-DD-topic.md.

Frequently Asked Questions about journaling

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I write an incident response postmortem using git history and logs?

To write an incident response postmortem, aggregate context from recent git history, diffs, error logs, and test outputs. Synthesize a timeline of events, identify root causes, and save the structured markdown entry to docs/retros with a date-topic filename.

What is the best way to document lessons learned after a debugging session?

Documenting lessons learned after a debugging session involves capturing structured notes that summarize the timeline, what worked and failed, and explicit action items. The entry is saved as a markdown file under docs/journal for future reference.

Can I generate a retrospective automatically from recent git diffs and plan files?

Yes, you can generate a retrospective by prompting the tool to review recent git diffs, error logs, and relevant plan files. It assembles the context to build a timeline, surface root causes, and produce a concise journal entry.

Does capturing session notes require any external dependencies?

No external dependencies are required to capture session notes. The tool operates independently to aggregate context from your local git history and project files, synthesizing the information into structured markdown files.

How do I structure a postmortem for a completed software feature?

To structure a postmortem for a completed feature, extract context from git diffs and plan files to build a timeline of decisions and outcomes. Summarize the rationale and lessons learned into a compact markdown entry under docs/journal.

When should I not use automated journaling for team retrospectives?

Automated journaling may not suit team retrospectives if the critical decisions and context were not captured in git history, diffs, or plan files. It relies on extracting technical context to synthesize timelines and root causes accurately.