Skills github awesome-copilot Memory instructions

memory-merger

Use it when:: A domain's file of remembered lessons has grown and you want the mature ones folded into that domain's standing instructions.
It does:: Reads <domain>-memory.instructions.md and <domain>.instructions.md, proposes which memories go where, waits for your go, then drafts and refines the merge.
You get:: A new or updated instruction file, with both files' applyTo patterns combined, and a memory file with the merged lessons removed.
Call it as:: /memory-merger >domain, optionally with a scope: global (VS Code's user prompts folder, the default) or workspace (.github/instructions/).
Needs:: The repo's remember skill installed too: it writes the <domain>-memory.instructions.md files this one merges.

Skill 2 of 2 in the Memory instructions bundle, after remember.

Only works inside its bundle: Needs a <domain>-memory.instructions.md file, which remember writes, and merges its lessons into <domain>.instructions.md. Install Memory instructions instead.

Merges the <domain>-memory.instructions.md files that the repo's remember skill writes, so install remember with it. Built for VS Code: the files live in VS Code's user prompts folder or .github/instructions/.

TL;DR

Memory files hold lessons learned, one per heading, next to the instruction files an agent loads for a domain such as clojure or git-workflow; applyTo patterns in their front matter say which files they apply to. This skill consolidates the two. It works out the paths from the domain and scope, globbing the folder for a near match if you mistyped the domain, and reads both files; the instruction file may not exist yet. It lists each memory with its key points and where it would go, then stops until you approve all with "go" or name the ones to skip. It drafts the merged instructions without touching any file, judging them against three goals: no detail or example lost, overlapping guidance consolidated, and a clear, scannable structure, and refines until they meet all three. Only then does it write the instruction file, adding front matter if the file is new, and remove the merged sections from the memory file. It tracks its progress in the agent's todo list.

Summarizes the skill at 797337f.

npx skills add https://github.com/github/awesome-copilot --skill memory-merger

skills.sh page Source on GitHub All skills from github/awesome-copilot

Total Downloads: 12,900 on skills.sh, Nov 9, 2026
Repo stars: 40,943 github/awesome-copilot
First seen: Feb 25, 2026 on skills.sh

Weekly Downloads

+8% over the 8 weeks to Nov 9

Weekly values

Week to	Installs
Sep 21	12
Sep 28	22
Oct 5	13
Oct 12	5
Oct 19	19
Oct 26	9
Nov 2	11
Nov 9	13

Category	category:agents category:software-engineering Build agents, orchestrate workers and give agents memory. Everything for building software: planning, coding, debugging, design, frameworks, cloud, agents and skills.
Type	type:workflow A multi-step process the agent follows: interview, debug, run a TDD loop, review.
Effect	effect:local Its own steps create or change files, git state or local tools.
Needs	needs:none Instructions only. Works in any agent that supports skills.
Publisher	by:official A verified publisher on skills.sh, or the company or maintainer behind the product the skill operates.
Topics	memory self-improvement
Stack	stack:github-copilot

SKILL.md

From github/awesome-copilot at 797337f. Checked daily, last changed Nov 6, 2026.

Frontmatter

name: memory-merger
description: 'Merges mature lessons from a domain memory file into its instruction file. Syntax: `/memory-merger >domain [scope]` where scope is `global` (default), `user`, `workspace`, or `ws`.'

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:

Zero knowledge loss - Every detail, example, and nuance preserved
Minimal redundancy - Overlapping guidance consolidated
Maximum scannability - Clear hierarchy, parallel structure, strategic bold, logical grouping

4. Merge and Iterate

Develop the final merged instructions without updating files yet:

Draft the merged instructions incorporating approved memories
Evaluate against quality bar
Refine structure, wording, organization
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