using-forgetful-memory

A task-management overlay designed to simplify your day-to-day workflow organization and boost productivity through thoughtful task planning and execution tracking. It leverages your own Mac's built-in featuresbfh and integrates seamlessly with your daily routine to ensure you never lose sight of your goals.

3|Updated Dec 20, 2025
One-click install
npx skills add https://github.com/ScottRBK/forgetful-plugin --skill using-forgetful-memory
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: using-forgetful-memory
Source: https://github.com/ScottRBK/forgetful-plugin/tree/main/skills/using-forgetful-memory
Command: npx skills add https://github.com/ScottRBK/forgetful-plugin --skill using-forgetful-memory

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Forgetful semantic memory guidance to decide when to query vs create, how to structure content using atomic memory principles, and how to apply importance scoring for prioritization.

Core Features & Use Cases

  • Query-before-create workflow: Always check for existing memories before creating duplicates to avoid clutter.
  • Atomic memory principles: Each memory captures a single concept with a concise title and content, enabling clean linking and retrieval.
  • Content constraints & quality: Guidance on Title (≤200 chars), Content (≤2000 chars), Context (≤500 chars), Keywords (≤10), and Tags (≤10) to improve clustering and search.
  • Project discovery: Find and attach memories to the correct project by discovering the current repo, filtering by repo, and using the project_id.
  • Announcing operations: When creating significant memories, announce results to improve visibility and traceability.

Quick Start

  1. Get current repo with git remote get-url origin and derive the owner/repo identifier. 2) Discover or create a project with list_projects and use the returned project_id. 3) Before creating a memory, run a query to check for duplicates: execute_forgetful_tool("query_memory", {"query": "<topic of potential new memory>", "query_context": "Checking for existing memories before creating", "k": 5})
  2. If a similar memory exists, update or link it; if not, create a new memory with a suitable title, content, context, keywords, and tags.

Frequently Asked Questions about using-forgetful-memory

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

FAQPage Schema
How do I decide when to query memory versus creating a new memory entry?

Always query memory first to check for existing entries before creating new ones. Use query_memory with your topic to avoid duplicates and clutter, then create only if no similar memory exists. This query-before-create workflow keeps your semantic memory organized and retrievable.

What are atomic notes and how do I structure memory entries correctly?

Atomic notes capture a single concept with concise, linked content. Structure each memory with a title (≤200 chars), content (≤2000 chars), context (≤500 chars), keywords (≤10), and tags (≤10). This atomic approach enables clean linking, better clustering, and faster semantic retrieval across your project work.

How do I organize memories across multiple projects using the Forgetful tool?

Get your current repo with git remote get-url origin, discover or create a project using list_projects, then attach memories to the correct project_id. This ensures memories stay discoverable and linked to the right architectural patterns and technical workflows.

What's the best way to score and prioritize memory importance?

Apply importance scoring when creating memories to prioritize high-value entries across technical patterns and workflows. Score based on relevance to past decisions, architectural patterns, and how often you'll reference the content. Higher scores surface critical memories during semantic queries.

When should I update an existing memory instead of creating a duplicate?

If your query finds a similar memory, update or link to it rather than creating new. This prevents semantic memory clutter and maintains a single source of truth for recurring concepts, architectural decisions, and project patterns.

Why does memory content have character limits and what happens if I exceed them?

Content constraints (title ≤200 chars, content ≤2000 chars, context ≤500 chars) improve clustering, search accuracy, and semantic retrieval speed. Exceeding limits degrades memory quality and makes content harder to retrieve and link across related patterns.