
Hindsight Memory Skill
FreeEnhance your workflow with persistent memory storage.
Free · Opens the source repo
What Hindsight Memory Skill does
The Hindsight Memory Skill provides developers and designers with a robust solution for storing and recalling valuable insights from their work. By using the hindsight-embed CLI, users can retain learnings, preferences, and outcomes from their tasks, allowing for a more informed approach to future projects. This skill is particularly beneficial for teams or individuals who frequently revisit similar tasks or projects, as it helps maintain continuity and context in their work.
When utilizing Hindsight, users can store detailed observations, including coding style preferences, successful procedures, and even bugs encountered during development. The skill processes this information through an internal pipeline that extracts structured facts, identifies key entities, and builds relationships between them. This ensures that the information retained is not just a raw string but is organized in a way that can be easily recalled and utilized later.
To get started, users must first configure the Hindsight daemon, which involves setting up an LLM provider and API key. Once configured, commands such as memory retain, memory recall, and memory reflect can be used to manage the stored information effectively. The skill encourages users to store memories immediately after significant learnings and to recall relevant memories before embarking on new tasks, ensuring that past experiences inform current decisions.
Overall, the Hindsight Memory Skill is designed for developers and designers looking to enhance their productivity by leveraging past experiences and insights. By systematically storing and recalling memories, users can streamline their workflows and reduce the likelihood of repeating mistakes or overlooking important details.
When to use it
Use this skill when you want to retain learnings and preferences from your work to improve future task execution.
When not to use it
This skill may not be suitable for one-off tasks where context is not likely to be reused or for users who prefer not to manage memory manually.
What you can build with it
Storing User Preferences
Capture coding style preferences and tool choices to ensure consistency across projects.
Documenting Procedure Outcomes
Record successful commands and configurations that resolved issues to streamline future tasks.
Reflecting on Past Experiences
Use stored memories to inform decisions on new tasks, enhancing productivity and reducing errors.
How to install Hindsight Memory Skill
View source1. Install with the skills CLI
npx skills add vectorize-io/hindsight/hindsight-local --agent claude-code2. Or install it manually
Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.
Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs
Inside SKILL.md
Written by vectorize-ioHindsight Memory Skill (Local)
You have persistent memory via the hindsight-embed CLI. Proactively store learnings and recall context to provide better assistance.
Setup Check (First-Time Only)
Before using memory commands, verify Hindsight is configured:
uvx hindsight-embed daemon status
If this fails or shows "not configured", run the interactive setup:
uvx hindsight-embed configure
This will prompt for an LLM provider and API key. After setup, the commands below will work.
How Hindsight Works
When you call retain, Hindsight does not store the string as-is. The server runs an internal pipeline that:
- Extracts structured facts from the content using an LLM
- Identifies entities (people, tools, concepts) and links related facts
- Builds temporal and causal relationships between facts
- Generates embeddings for semantic search
This means you should pass rich, full-context content — the server is better at extracting what matters than a pre-summarized string. Your job is to decide when to store, not what to extract.
Commands
Store a memory
Use memory retain to store what you learn. Pass the full context — raw observations, session notes, conversation excerpts, or detailed descriptions:
uvx hindsight-embed memory retain default "User is working on a TypeScript project. They enabled strict mode and prefer explicit type annotations over inference."
uvx hindsight-embed memory retain default "Ran the test suite with NODE_ENV=test. Tests pass. Without NODE_ENV=test, the suite fails with a missing config error." --context procedures
uvx hindsight-embed memory retain default "Build failed on Node 18 with error 'ERR_UNSUPPORTED_ESM_URL_SCHEME'. Switched to Node 20 and build succeeded." --context learnings
You can also pass a raw conversation transcript with timestamps:
uvx hindsight-embed memory retain default "[2026-03-16T10:12:03] User: The auth tests keep failing on CI but pass locally. Any idea?
[2026-03-16T10:12:45] Assistant: Let me check the CI logs. Looks like the tests are running without the TEST_DATABASE_URL env var set — they fall back to the production DB URL and hit a connection timeout.
[2026-03-16T10:13:20] User: Ah right, I never added that to the CI secrets. Adding it now.
[2026-03-16T10:15:02] User: That fixed it. All green now." --context learnings
Recall memories
Use memory recall BEFORE starting tasks to get relevant context:
uvx hindsight-embed memory recall default "user preferences for this project"
uvx hindsight-embed memory recall default "what issues have we encountered before"
Reflect on memories
Use memory reflect to synthesize context:
uvx hindsight-embed memory reflect default "How should I approach this task based on past experience?"
IMPORTANT: When to Store Memories
Always store after you learn something valuable:
User Preferences
- Coding style (indentation, naming conventions, language preferences)
- Tool preferences (editors, linters, formatters)
- Communication preferences
- Project conventions
Procedure Outcomes
- Steps that successfully completed a task
- Commands that worked (or failed) and why
- Workarounds discovered
- Configuration that resolved issues
Learnings from Tasks
- Bugs encountered and their solutions
- Performance optimizations that worked
- Architecture decisions and rationale
- Dependencies or version requirements
IMPORTANT: When to Recall Memories
Always recall before:
- Starting any non-trivial task
- Making decisions about implementation
- Suggesting tools, libraries, or approaches
- Writing code in a new area of the project
Best Practices
- Store immediately: When you discover something, store it right away
- Pass rich context: Include full observations, not pre-summarized strings — the server extracts facts automatically
- Include outcomes: Store what happened AND why, including failures and workarounds
- Recall first: Always check for relevant context before starting work
- Use
--contextfor metadata: The--contextflag labels the type of memory (e.g.,procedures,learnings,preferences), not a replacement for full content
Frequently asked questions about Hindsight Memory Skill
Similar skills
Napkin
Collaborate visually with Copilot using an interactive whiteboard.
Mode Creator
Custom note-taking modes for claude-mem.
Google Meet Assistant
Join, transcribe, and interact in Google Meet calls.
Memory Keeper
Organize lessons learned into reusable knowledge.
Meeting Minutes
Generate concise, actionable meeting minutes effortlessly.
Brag Sheet
Transform your work into impactful statements for reviews.
