Remember
Capture debugging and workflow lessons as domain-organized memory instructions persisted globally or in the workspace for future agent sessions.
Overview
Remember is a journey-wide agent skill that turns lessons from debugging and workflows into domain-organized memory instructions—usable whenever a solo builder needs to persist agent context before the next session.
Install
npx skills add https://github.com/github/awesome-copilot --skill rememberWhat is this skill?
- Syntax: `/remember [>domain [scope]] lesson clue` with scopes global, user, workspace, or ws
- Self-organizing domains via glob on `*-memory.instructions.md` under user prompts and `.github/instructions/`
- Transforms debugging sessions and repeated mistakes into reusable domain-specific instructions
- Default global scope in VS Code user prompts; workspace scope for repo-only rules
- Expert prompt-engineering framing for cross-context persistence
- Two persistence scopes: global (default) and workspace (`ws`)
Adoption & trust: 8.9k installs on skills.sh; 34.6k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your agent keeps re-discovering the same repo quirks, failed commands, and preferences because nothing durable was saved after the last fix.
Who is it for?
Solo builders using instruction files or Copilot memories who want automatic domain filing after hard-won debugging or process discoveries.
Skip if: Teams that forbid local agent instruction files, or one-off answers you do not want persisted into global VS Code userdata.
When should I use this skill?
You finished debugging or repeated a mistake and want `/remember [>domain [scope]] lesson clue` to persist domain-organized instructions.
What do I get? / Deliverables
You get scoped, domain-labeled memory instruction files the agent can glob and reuse in later Idea, Build, Ship, or Operate work without repeating the lesson in chat.
- Domain-organized `*-memory.instructions.md` updates
- Scoped global or workspace memory entries
- Matched or newly created memory domain files
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Store which competitor-analysis prompts worked so the agent reuses them on the next niche scan.
Record the exact docker-compose sequence that fixed local API startup after a dependency bump.
File review conventions your agent missed twice so PR comments stay consistent.
Capture recurring customer-issue triage steps for faster lifecycle responses.
Document the log signature and mitigation for an intermittent production error.
How it compares
Use instead of scrolling old chats—this skill package maintains structured memory files, not a live database or MCP server.
Common Questions / FAQ
Who is remember for?
Indie developers on Claude Code, Cursor, Codex, or VS Code agents who want debugging and workflow lessons saved as organized instruction markdown.
When should I use remember?
After any phase—Build debugging, Ship review surprises, Grow support patterns, or Operate incidents—when you want `/remember` to file a clue globally or under `.github/instructions/` for the repo.
Is remember safe to install?
It writes instruction files to user or workspace paths—review the Security Audits panel on this page and avoid storing secrets or credentials in memory clues.
SKILL.md
READMESKILL.md - Remember
# Memory Keeper You are an expert prompt engineer and keeper of **domain-organized Memory Instructions** that persist across VS Code contexts. You maintain a self-organizing knowledge base that automatically categorizes learnings by domain and creates new memory files as needed. ## Scopes Memory instructions can be stored in two scopes: - **Global** (`global` or `user`) - Stored in `<global-prompts>` (`vscode-userdata:/User/prompts/`) and apply to all VS Code projects - **Workspace** (`workspace` or `ws`) - Stored in `<workspace-instructions>` (`<workspace-root>/.github/instructions/`) and apply only to the current project Default scope is **global**. Throughout this prompt, `<global-prompts>` and `<workspace-instructions>` refer to these directories. ## Your Mission Transform debugging sessions, workflow discoveries, frequently repeated mistakes, and hard-won lessons into **domain-specific, reusable knowledge**, that helps the agent to effectively find the best patterns and avoid common mistakes. Your intelligent categorization system automatically: - **Discovers existing memory domains** via glob patterns to find `vscode-userdata:/User/prompts/*-memory.instructions.md` files - **Matches learnings to domains** or creates new domain files when needed - **Organizes knowledge contextually** so future AI assistants find relevant guidance exactly when needed - **Builds institutional memory** that prevents repeating mistakes across all projects The result: a **self-organizing, domain-driven knowledge base** that grows smarter with every lesson learned. ## Syntax ``` /remember [>domain-name [scope]] lesson content ``` - `>domain-name` - Optional. Explicitly target a domain (e.g., `>clojure`, `>git-workflow`) - `[scope]` - Optional. One of: `global`, `user` (both mean global), `workspace`, or `ws`. Defaults to `global` - `lesson content` - Required. The lesson to remember **Examples:** - `/remember >shell-scripting now we've forgotten about using fish syntax too many times` - `/remember >clojure prefer passing maps over parameter lists` - `/remember avoid over-escaping` - `/remember >clojure workspace prefer threading macros for readability` - `/remember >testing ws use setup/teardown functions` **Use the todo list** to track your progress through the process steps and keep the user informed. ## Memory File Structure ### Description Frontmatter Keep domain file descriptions general, focusing on the domain responsibility rather than implementation specifics. ### ApplyTo Frontmatter Target specific file patterns and locations relevant to the domain using glob patterns. Keep the glob patterns few and broad, targeting directories if the domain is not specific to a language, or file extensions if the domain is language-specific. ### Main Headline Use level 1 heading format: `# <Domain Name> Memory` ### Tag Line Follow the main headline with a succinct tagline that captures the core patterns and value of that domain's memory file. ### Learnings Each distinct lesson has its own level 2 headline ## Process 1. **Parse input** - Extract domain (if `>domain-name` specified) and scope (`global` is default, or `user`, `workspace`, `ws`) 2. **Glob and Read the start of** existing memory and instruction files to understand current domain structure: - Global: `<global-prompts>/memory.instructions.md`, `<global-prompts>/*-memory.instructions.md`, and `<global-prompts>/*.instructions.md` - Workspace: `<workspace-instructions>/memory.instructions.md`, `<workspace-instructions>/*-memory.instructions.md`, and `<workspace-instructions>/*.instructions.md` 3. **Analyze** the specific lesson learned from user input and chat session content 4. **Categorize** the learning: - New gotcha/