New to Claude Skills? Learn how to install them →

vectorize-io on GitHub

Hindsight Memory Skill

Free

Enhance your workflow with persistent memory storage.

Get this skill

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 source

1. Install with the skills CLI

npx skills add vectorize-io/hindsight/hindsight-local --agent claude-code

2. 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-io

Hindsight 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:

  1. Extracts structured facts from the content using an LLM
  2. Identifies entities (people, tools, concepts) and links related facts
  3. Builds temporal and causal relationships between facts
  4. 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

  1. Store immediately: When you discover something, store it right away
  2. Pass rich context: Include full observations, not pre-summarized strings — the server extracts facts automatically
  3. Include outcomes: Store what happened AND why, including failures and workarounds
  4. Recall first: Always check for relevant context before starting work
  5. Use --context for metadata: The --context flag 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