How do I install the Compact With Memory skill?

Run npx skillmds@latest add q2wxec/compact-with-memory in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

Is Compact With Memory safe to use?

This skill has not completed SkillMD's automated safety review yet. Capability flags: executes scripts, reads secrets. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Compact With Memory?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Compact With Memory free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Compact With Memory?

q2wxec (@q2wxec) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Compact With Memory by q2wxec — Agent Skill

Name: Compact With Memory
Rating: 4.2 (5 reviews)
Author: q2wxec

Compact With Memory

Enhanced /compact that doesn't just summarize — it extracts and persists key decisions, eliminated approaches, new patterns, and current blockers into MEMORY.md before compressing the conversation. Use this skill whenever the user says /compact, "compress context", "compact the conversation", or when the context window is getting full and you want to preserve institutional knowledge from this session. It ensures that after compression, future sessions can reconstruct the reasoning behind current state, not just the state itself.

q2wxec Updated Sep 22, 2026

File contents

compact-with-memory

An enhanced /compact that treats compression as a memory opportunity: before summarizing the conversation, extract what's worth keeping permanently and write it to MEMORY.md.

Why this matters

Claude Code's autoCompact.ts triggers when token usage exceeds effectiveContextWindow - 13,000 tokens. Standard compaction generates a summary and discards the conversation — fast, but lossy. This skill adds a pre-compression pass that distills the session's institutional knowledge into durable memory files, so future sessions don't have to rediscover what this session learned.

Process

Step 1 — Audit the conversation for memory-worthy content

Read back through the current conversation and identify:

Decisions made — architectural choices, approach selections, tradeoffs accepted ("we went with X over Y because Z")
Eliminated approaches — things tried and ruled out, with reasons ("tried approach A, failed because B — don't retry")
Newly discovered patterns — code conventions, project quirks, API behaviors that aren't in any file
Current blockers — open issues, unresolved questions that will matter next session
Factual corrections — anything that contradicted prior assumptions or MEMORY.md entries

Skip:

Implementation details already visible in the code
Step-by-step narrative of what was done (git log has this)
Transient state that won't matter next session

Step 2 — Write to MEMORY.md

Check if MEMORY.md exists. If not, create it as a lightweight index (one line per entry, under 150 chars each).

For each item identified in Step 1, decide:

Index-only: short, universal facts go directly as a pointer line in MEMORY.md
Topic file: anything with more than 2-3 sentences of detail gets its own file in the memory directory, with a pointer line in MEMORY.md

Memory file format:

---
name: <descriptive name>
description: <one-line summary — what would make this file worth loading?>
type: feedback | project | user | reference
---

<content — for feedback/project types, lead with the rule/fact, then **Why:** and **How to apply:** lines>

MEMORY.md pointer format (one line, under 150 chars):

- [Title](filename.md) — one-line hook describing when this is relevant

Step 3 — Run the actual compact

After writing the memory updates, run the standard /compact command to compress the conversation. The summary generated by compact should reference what was persisted to memory ("Key decisions written to MEMORY.md — see [file] for X").

Step 4 — Confirm

Tell the user:

How many memory items were written/updated
Which files were touched
That compaction completed

What to write vs. skip

Write to memory:

"We're using optimistic locking here because the DB doesn't support SELECT FOR UPDATE in this version"
"The auth service always returns 200 even on failure — check data.success not status code"
"User prefers small focused PRs over large refactor PRs — confirmed multiple times"

Don't write to memory:

"Implemented user authentication with JWT" — the code IS the record
"Fixed bug in login flow" — git commit message has this
"Read 5 files and summarized them" — noise

Tone

Be selective. One high-quality memory entry beats five generic ones. If you're unsure whether something is worth persisting, ask: "Would a fresh session benefit from knowing this immediately, before reading any code?"

---name: compact-with-memorydescription: Enhanced /compact that doesn't just summarize — it extracts and persists key decisions, eliminated approaches, new patterns, and current blockers into MEMORY.md before compressing the conversation. Use this skill whenever the user says /compact, "compress context", "compact the conversation", or when the context window is getting full and you want to preserve institutional knowledge from this session. It ensures that after compression, future sessions can reconstruct the reasoning behind current state, not just the state itself.---# compact-with-memoryAn enhanced `/compact` that treats compression as a memory opportunity: before summarizing the conversation, extract what's worth keeping permanently and write it to `MEMORY.md`.## Why this mattersClaude Code's `autoCompact.ts` triggers when token usage exceeds `effectiveContextWindow - 13,000` tokens. Standard compaction generates a summary and discards the conversation — fast, but lossy. This skill adds a pre-compression pass that distills the session's institutional knowledge into durable memory files, so future sessions don't have to rediscover what this session learned.## Process### Step 1 — Audit the conversation for memory-worthy contentRead back through the current conversation and identify:- **Decisions made** — architectural choices, approach selections, tradeoffs accepted ("we went with X over Y because Z")- **Eliminated approaches** — things tried and ruled out, with reasons ("tried approach A, failed because B — don't retry")- **Newly discovered patterns** — code conventions, project quirks, API behaviors that aren't in any file- **Current blockers** — open issues, unresolved questions that will matter next session- **Factual corrections** — anything that contradicted prior assumptions or MEMORY.md entriesSkip:- Implementation details already visible in the code- Step-by-step narrative of what was done (git log has this)- Transient state that won't matter next session### Step 2 — Write to MEMORY.mdCheck if `MEMORY.md` exists. If not, create it as a lightweight index (one line per entry, under 150 chars each).For each item identified in Step 1, decide:- **Index-only**: short, universal facts go directly as a pointer line in MEMORY.md- **Topic file**: anything with more than 2-3 sentences of detail gets its own file in the memory directory, with a pointer line in MEMORY.mdMemory file format:```markdown---name: <descriptive name>description: <one-line summary — what would make this file worth loading?>type: feedback | project | user | reference---<content — for feedback/project types, lead with the rule/fact, then **Why:** and **How to apply:** lines>```MEMORY.md pointer format (one line, under 150 chars):```- [Title](filename.md) — one-line hook describing when this is relevant```### Step 3 — Run the actual compactAfter writing the memory updates, run the standard `/compact` command to compress the conversation. The summary generated by compact should reference what was persisted to memory ("Key decisions written to MEMORY.md — see [file] for X").### Step 4 — ConfirmTell the user:- How many memory items were written/updated- Which files were touched- That compaction completed## What to write vs. skip**Write to memory:**- "We're using optimistic locking here because the DB doesn't support SELECT FOR UPDATE in this version"- "The auth service always returns 200 even on failure — check `data.success` not status code"- "User prefers small focused PRs over large refactor PRs — confirmed multiple times"**Don't write to memory:**- "Implemented user authentication with JWT" — the code IS the record- "Fixed bug in login flow" — git commit message has this- "Read 5 files and summarized them" — noise## ToneBe selective. One high-quality memory entry beats five generic ones. If you're unsure whether something is worth persisting, ask: "Would a fresh session benefit from knowing this immediately, before reading any code?"

Frequently asked questions