Claude Code prioritizes episodic memory over procedural memory, causing repeated relearning of fundamental workflows

Preflight Checklist

• [x] I have searched existing issues and this hasn't been reported yet
• [x] This is a single bug report (please file separate reports for different bugs)
• [x] I am using the latest version of Claude Code

What's Wrong?

Claude Code forgets fundamental workflows (FTP, direct database queries, SSH patterns) that are used 100+ times
across sessions, while remembering one-off conversation details via compacting. Every session requires
re-teaching basic development skills.

What Should Happen?

Claude Code should permanently retain frequently-used procedural patterns (how to FTP, that direct DB queries
are possible, project /instructions/ folder checks) while treating conversation-specific details as temporary
context. Procedural memory should build up across sessions, not reset each time.

Error Messages/Logs

Steps to Reproduce

1. Teach Claude Code to use FTP for file uploads (execute 50+ times)
2. Start new session
3. Claude Code writes test scripts instead of using FTP or querying a database directly
4. Meanwhile, compact preserves 9,000 tokens of project-specific bug fix details

Claude Model

None

Is this a regression?

Yes, this worked in a previous version

Last Working Version

v1.0.120

Claude Code Version

1.0.124 (Claude Code)

Platform

Anthropic API

Operating System

macOS

Terminal/Shell

Terminal.app (macOS)

Additional Information

● Here's a GitHub issue draft you can submit:

---
Title: Claude Code prioritizes episodic memory over procedural memory, causing repeated relearning of
fundamental workflows

Description:

Problem Summary

Claude Code's memory system preserves conversation history (episodic memory) but fails to retain fundamental
development skills (procedural memory) across sessions. This causes the AI to repeatedly relearn basic
workflows it has executed 100+ times, while remembering one-off bug fixes from specific conversations.

Concrete Example

In a typical development session with Claude Code:

What gets remembered (via compacting):

• Specific bug fix from 2 hours ago: "services_json caused issues, use normalized structure"
• Details of parent-child billing logic from one project
• Conversation flow and user frustration quotes

What gets forgotten every session:

• How to use FTP (despite using it 50+ times across sessions)
• That direct database queries are possible (keeps writing test scripts instead)
• SSH credentials and server paths accessed repeatedly
• That project /instructions/ folders should be checked first
• Basic procedural knowledge: "I am a programmer who can query databases"

Impact

This creates a frustrating development loop where:

1. User teaches fundamental workflow (e.g., "use FTP, don't write scripts")
2. Claude Code executes it correctly
3. Next session: Claude Code acts like it's never heard of FTP
4. User has to re-teach the same fundamental skill
5. Meanwhile, Claude Code "remembers" ephemeral project details that may not matter next week

Expected Behavior

Claude Code should:

• Permanently retain frequently-used patterns (FTP commands, direct DB access, SSH workflows)
• Temporarily retain conversation-specific context (bug fixes, this-project details)
• Build up procedural memory of "how this user works" across sessions
• Prioritize skill retention over conversation history preservation

Current Behavior

• Compacting preserves 9,000 tokens of conversation history
• Does not reinforce patterns used 100+ times
• Every session feels like training a new developer from scratch on basic tools

User Quote

"Why are those things you mention... more than vital things like ftp and you are a programmer that can query a
database rather than writing test scripts all over the place?"

Suggested Solution

Memory system should distinguish between:

• Procedural memory (persistent): FTP usage, database access patterns, user's preferred workflows
• Episodic memory (temporary): This conversation's bug fixes, project-specific context
• Weight procedural patterns by frequency of use
• Surface procedural patterns at session start, not conversation history