memory-management

Overview of memory-management skill

What the memory-management skill actually does

The memory-management skill gives Claude a repeatable way to persist project context across sessions instead of re-discovering the same facts every time. In this repository, it is designed mainly for SEO and GEO workflows, using a three-tier memory model: a hot cache in CLAUDE.md, structured project memory under memory/, and archival storage for older details.

Who should install memory-management

This memory-management skill is best for people running ongoing, multi-session work where context decays quickly: keyword tracking, competitor monitoring, audits, campaign status, glossary terms, and recurring reporting. It is especially useful for teams doing memory-management for Context Engineering, where the real problem is not generating one answer, but keeping the right facts available over time.

The real job-to-be-done

Users usually want one of four outcomes:

• save important project decisions for later
• ask “what do we know so far?” without re-uploading everything
• keep active priorities visible while archiving bulky details
• update memory consistently after recurring events like rank checks or audits

The skill is valuable because it turns vague “remember this” requests into a concrete file structure and update routine.

What makes this different from a normal prompt

A generic prompt can ask Claude to remember things, but this skill adds operating rules:

• a specific HOT/WARM/COLD structure
• templates for CLAUDE.md and memory/glossary.md
• promotion/demotion rules for what stays visible
• event-based update triggers after audits, reports, and ranking checks

That makes the output more maintainable than ad hoc notes dumped into one file.

Best-fit and misfit cases

Best fit:

• active SEO projects with recurring updates
• long-running campaign work
• repositories where CLAUDE.md is already part of the workflow
• users who want a documented memory system, not just chat history

Misfit:

• one-off tasks
• tiny projects with almost no repeated context
• users expecting automatic database-like persistence without maintaining files
• non-file-based workflows where nobody will review or update the memory artifacts

How to Use memory-management skill

Install context and compatibility

The repository declares compatibility with Claude Code ≥1.0, skills.sh marketplace, ClawHub marketplace, and the Vercel Labs skills ecosystem. No system packages are required. Optional MCP network access only matters if you want connected SEO tooling; the core memory-management install and workflow are file-based.

If your environment supports marketplace-style skill installation, the common pattern is:

npx skills add aaron-he-zhu/seo-geo-claude-skills --skill memory-management

If your setup uses a different skill loader, point it at cross-cutting/memory-management in the repo.

Read these files first before using memory-management

For fast adoption, do not read the whole repository in order. Start here:

1. cross-cutting/memory-management/SKILL.md
2. cross-cutting/memory-management/references/hot-cache-template.md
3. cross-cutting/memory-management/references/update-triggers-integration.md
4. cross-cutting/memory-management/references/promotion-demotion-rules.md
5. cross-cutting/memory-management/references/examples.md
6. cross-cutting/memory-management/references/glossary-template.md

This path gets you the operating model, the file shape, the update triggers, and concrete examples with minimal guesswork.

What input the skill needs from you

The memory-management usage quality depends heavily on the starting context you provide. At minimum, give:

• project name
• project type and scope
• active target keywords or priorities
• main competitors
• current campaigns or audits in progress
• where you want memory stored in the repo
• what should stay “hot” versus archived

Without that, Claude can create the structure, but it will be generic and less useful.

Initialize the memory structure

A practical first run is to ask Claude to initialize:

• CLAUDE.md as the hot cache
• memory/glossary.md
• subfolders for audits, research, monitoring, and archives as needed

Good first prompt:

Initialize the memory-management skill for this SEO project. Create CLAUDE.md as a hot cache, create memory/glossary.md, and propose a minimal memory/ folder structure for rankings, competitors, audits, and reports. Use only sections we will realistically maintain.

That last sentence matters. The templates are strong, but overbuilding the memory tree creates maintenance debt fast.

Turn a rough goal into a strong invocation prompt

Weak prompt:

Remember this project.

Strong prompt:

Use the memory-management skill for this project. Save the following into a hot/warm/cold structure:

• Project: Acme SEO
• Hero keywords: technical seo audit, free backlink checker, content optimization guide
• Priority this month: recover rankings after migration
• Top competitors: example1.com, example2.com
• Recent event: technical audit completed on 2025-01-10
• Keep active priorities in CLAUDE.md
• Archive full audit details under memory/audits/technical/
  Then show me what was stored where.

Why this works:

• it names the skill intent explicitly
• it separates active facts from detailed artifacts
• it asks for placement, not just summarization
• it makes the output auditable

Suggested workflow for ongoing projects

A high-signal memory-management guide for daily use looks like this:

1. Initialize CLAUDE.md and core memory/ folders.
2. Populate hero keywords, competitors, priorities, and key metrics.
3. After each major event, update both hot cache and dated artifact files.
4. Periodically demote stale items from CLAUDE.md.
5. Ask Claude to summarize from hot cache first, then pull deeper records only when needed.

This keeps fast context fast, while preserving detail elsewhere.

When the skill should trigger

The repository includes trigger language like:

• “remember project context”
• “save SEO data”
• “track campaign progress”
• “what did we decide last time”
• “what do we know so far”
• “remember this for next time”

In practice, trigger memory-management when the conversation produces reusable project state, not just disposable reasoning.

Use update triggers, not random note dumping

One of the strongest parts of the skill is the event-driven update logic in references/update-triggers-integration.md. The pattern is:

• after ranking checks, update keyword tables and save dated rank history
• after competitor analysis, update the hot cache and save full reports
• after audits, extract top action items into CLAUDE.md and save the complete audit separately
• after monthly reports, refresh metrics and archive stale work

This is the difference between durable memory and a note pile.

How to decide what belongs in CLAUDE.md

Use CLAUDE.md only for items you need frequently:

• top keywords
• top competitors
• active optimization priorities
• recent key metrics
• current campaign status

Do not put every observation there. The repo’s promotion/demotion rules are useful because they force a decision: what needs immediate retrieval, and what can live in memory/ until requested?

Practical prompt patterns that improve output quality

Use prompts that force structure and thresholds:

• “Promote only keywords mentioned 3+ times recently.”
• “Demote anything stable and inactive for 60+ days.”
• “Extract only the top 5 action items from this audit into hot cache.”
• “Save the full report, but keep the summary under 150 words in CLAUDE.md.”

These mirror the repository’s rules and produce cleaner memory than open-ended “store this” commands.

Common adoption mistake: treating it like automatic memory

The biggest blocker to successful memory-management usage is expecting implicit persistence. This skill is a workflow, not magical recall. You still need to:

• initialize files
• ask for updates after meaningful events
• review whether hot cache is overloaded
• keep naming and folder conventions consistent

If nobody maintains the memory layer, retrieval quality will decay.

memory-management skill FAQ

Is memory-management only for SEO projects?

No, but this implementation is clearly optimized for SEO/GEO work. The examples, templates, and update triggers revolve around keywords, competitors, audits, and reports. You can adapt it to other long-running knowledge workflows, but the best out-of-the-box fit is SEO operations.

Is this better than just using chat history?

Yes, when work spans many sessions or collaborators. Chat history is hard to query, easy to lose, and poorly structured for project state. The memory-management skill externalizes important context into files Claude can revisit and update systematically.

Is memory-management beginner friendly?

Reasonably, yes. The templates lower the setup burden, especially hot-cache-template.md and glossary-template.md. The main beginner challenge is deciding what deserves hot cache versus archive. If you start small, the system is approachable.

When should I not use memory-management?

Skip it if:

• your work is one-off
• the project has little repeated context
• you do not want repository files modified
• you are unlikely to maintain a memory folder over time

In those cases, a normal prompt or a single summary file may be enough.

Does memory-management require external tools?

No. Core operation is file-based. External SEO tools or MCP access are optional and mainly help collect fresh data for updates like rankings or audits.

How is this different from writing one big project summary?

A single summary file becomes stale and bloated. memory-management for Context Engineering works better because it separates:

• active context in CLAUDE.md
• structured reference material in memory/
• archived historical details elsewhere

That separation improves both retrieval speed and maintenance.

How to Improve memory-management skill

Start with a smaller hot cache than you think

The most common failure mode is an overloaded CLAUDE.md. If everything is “important,” nothing is easy to retrieve. Keep the hot cache focused on active decisions, active targets, and current status. Push detail into dated files under memory/.

Provide stronger source inputs

Better memory-management results come from higher-quality source material. Instead of:

Save our audit findings.

Use:

Save this technical audit. Put the full report in memory/audits/technical/2025-01-10-core-web-vitals.md. Extract the top 3 issues, expected impact, and owner into CLAUDE.md. Add any new recurring terms to memory/glossary.md.

This tells Claude what to save, where to save it, and what belongs in the hot layer.

Use consistent naming and dated artifacts

Retrieval improves when your files follow stable patterns such as:

• memory/audits/technical/YYYY-MM-DD-name.md
• memory/research/competitors/YYYY-MM-DD-analysis.md
• memory/monitoring/rank-history/YYYY-MM-DD-ranks.csv

This matters because later prompts can refer to patterns instead of hunting for ad hoc filenames.

Apply promotion and demotion rules explicitly

Do not rely on intuition alone. The repository’s rules are practical:

• promote frequently referenced or fast-changing items
• demote stable, inactive, or completed items
• review hot cache on a schedule

If you ask Claude to enforce those rules, the memory system stays usable longer.

Ask for placement summaries after every update

After each save, ask:

Show exactly what you updated in CLAUDE.md, what you stored in memory/, and what you decided not to keep hot.

This catches bad classification early and improves trust in the memory-management guide you are building around the skill.

Iterate after the first output

The first pass is usually too broad or too shallow. Improve it with follow-ups like:

• “Reduce hot cache to only this quarter’s priorities.”
• “Move completed campaign details out of CLAUDE.md.”
• “Add missing competitor shorthand to memory/glossary.md.”
• “Create a monthly archive routine from the existing files.”

Good memory systems are tuned over a few cycles, not created perfectly in one run.

Combine retrieval requests with update requests

For ongoing work, pair questions with maintenance:

What do we know so far about hero keywords, and update the hot cache if any targets are stale?

This pattern keeps memory useful while you use it, instead of letting it drift between separate cleanup sessions.