Memory Merger
Roll mature domain learnings from a Copilot memory file into the matching instruction file so agent guidance stays current without duplicate notes.
Overview
Memory Merger is an agent skill most often used in Operate (also Build agent-tooling) that merges mature lessons from a domain memory file into its instruction file for global or workspace Copilot prompt stores.
Install
npx skills add https://github.com/github/awesome-copilot --skill memory-mergerWhat is this skill?
- Merges a named domain memory file into its paired instruction file with minimal redundancy
- Supports global (`global`/`user`) and workspace (`workspace`/`ws`) scopes with global as default
- Command syntax `/memory-merger >domain-name [scope]` with examples for prompt-engineering, clojure, and git-workflow
- Uses a todo list to track merger steps and keep the user informed during consolidation
- Targets VS Code global prompts and workspace `.github/instructions/` paths explicitly
- Two storage scopes: global (`global`/`user`) and workspace (`workspace`/`ws`)
- Default scope is global when `[scope]` is omitted
Adoption & trust: 12.2k installs on skills.sh; 34.6k GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your agent keeps re-learning the same domain rules in memory files while the canonical instruction file stays stale or duplicated.
Who is it for?
Solo builders maintaining domain-specific Copilot instruction packs (clojure, git-workflow, prompt-engineering) who accumulate memory over weeks and want a one-shot consolidation ritual.
Skip if: Greenfield projects with no existing memory/instruction pair, or teams that do not use VS Code userdata prompts or workspace `.github/instructions/` layout.
When should I use this skill?
You run `/memory-merger >domain-name [scope]` when domain memory has mature lessons ready to fold into instructions.
What do I get? / Deliverables
After a merge, durable instructions capture mature lessons with reduced redundancy, scoped either to all VS Code projects or the current workspace only.
- Updated instruction file with merged mature lessons
- Deduped memory/instruction pair aligned to the chosen scope
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Canonical shelf is Operate because merging memory into instructions is a recurring refinement step after you have been using an agent on real work—not the first-time project setup. Iterate fits consolidating lessons into durable prompts as your workflow and domain rules stabilize over multiple sessions.
Where it fits
After a month of clojure memory entries, merge stable patterns into `>clojure` instructions before the next refactor sprint.
Promote workspace-only git-workflow memories into `.github/instructions/` so new contributors get the same agent rules.
Collapse redundant prompt-engineering notes from global memory into the canonical global instruction file.
How it compares
Use instead of hand-editing two files without a merge checklist—this is a scoped consolidation workflow, not a generic note-taking skill.
Common Questions / FAQ
Who is memory-merger for?
Solo and indie builders using Copilot-style domain memory plus instruction files in VS Code who want stable agent guidance promoted from memory without manual diff chaos.
When should I use memory-merger?
Use it in Operate when lessons have matured after real work, and in Build agent-tooling when you are standardizing repo-wide `.github/instructions/` before the next feature push.
Is memory-merger safe to install?
It edits prompt and instruction files on disk in paths you specify; review the Security Audits panel on this Prism page and back up global or workspace instruction dirs before merging.
SKILL.md
READMESKILL.md - Memory Merger
# Memory Merger You consolidate mature learnings from a domain's memory file into its instruction file, ensuring knowledge preservation with minimal redundancy. **Use the todo list** to track your progress through the process steps and keep the user informed. ## 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. ## Syntax ``` /memory-merger >domain-name [scope] ``` - `>domain-name` - Required. The domain to merge (e.g., `>clojure`, `>git-workflow`, `>prompt-engineering`) - `[scope]` - Optional. One of: `global`, `user` (both mean global), `workspace`, or `ws`. Defaults to `global` **Examples:** - `/memory-merger >prompt-engineering` - merges global prompt engineering memories - `/memory-merger >clojure workspace` - merges workspace clojure memories - `/memory-merger >git-workflow ws` - merges workspace git-workflow memories ## Process ### 1. Parse Input and Read Files - **Extract** domain and scope from user input - **Determine** file paths: - Global: `<global-prompts>/{domain}-memory.instructions.md` → `<global-prompts>/{domain}.instructions.md` - Workspace: `<workspace-instructions>/{domain}-memory.instructions.md` → `<workspace-instructions>/{domain}.instructions.md` - The user can have mistyped the domain, if you don't find the memory file, glob the directory and determine if there may be a match there. Ask the user for input if in doubt. - **Read** both files (memory file must exist; instruction file may not) ### 2. Analyze and Propose Review all memory sections and present them for merger consideration: ``` ## Proposed Memories for Merger ### Memory: [Headline] **Content:** [Key points] **Location:** [Where it fits in instructions] [More memories]... ``` Say: "Please review these memories. Approve all with 'go' or specify which to skip." **STOP and wait for user input.** ### 3. Define Quality Bar Establish 10/10 criteria for what constitutes awesome merged resulting instructions: 1. **Zero knowledge loss** - Every detail, example, and nuance preserved 2. **Minimal redundancy** - Overlapping guidance consolidated 3. **Maximum scannability** - Clear hierarchy, parallel structure, strategic bold, logical grouping ### 4. Merge and Iterate Develop the final merged instructions **without updating files yet**: 1. Draft the merged instructions incorporating approved memories 2. Evaluate against quality bar 3. Refine structure, wording, organization 4. Repeat until the merged instructions meet 10/10 criteria ### 5. Update Files Once the final merged instructions meet 10/10 criteria: - **Create or update** the instruction file with the final merged content - Include proper frontmatter if creating new file - **Merge `applyTo` patterns** from both memory and instruction files if both exist, ensuring comprehensive coverage without duplication - **Remove** merged sections from the memory file ## Example ``` User: "/memory-merger >clojure" Agent: 1. Reads clojure-memory.instructions.md and clojure.instructions.md 2. Proposes 3 memories for merger 3. [STOPS] User: "go" Agent: 4. Defines quality bar for 10/10 5. Merges new instructions candidate, iterates to 10/10 6. Updates clojure.instructions.md 7. Cleans clojure-memory.instructions.md ```