Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

Boris Cherny gave Claude Code a memory that has no database, no indexing, no setup, and 80% of Anthropic runs on it a CLAUDE.md "gets automatically read into context at the start of every session" 12:48 - CLAUDE.md loads into memory every session 13:15 - Keep memory short or...

N01ennn's profile picture

NO1ennn

5,679 subscribers

13,015 Aufrufe • vor 3 Monaten •via X (Twitter)

Wissenschaft & TechnologieBildung
LIVE

Anya Rossi• Live Now

Private livecam show

16 Kommentare

Profilbild von Alex
Alexvor 3 Monaten

boris droopped alpha

Profilbild von Bass
Bassvor 3 Monaten

CLAUDE.md is great until two people, or two agents, need to update the same file at once. Then it's just a race to whoever writes last. Works fine solo, gets messier the moment more than one hand is touching it.

Profilbild von Matt
Mattvor 3 Monaten

mine drifted into rules for situations that stopped existing months ago, and a plain file never tells you a line went stale. i only catch it when i read the whole thing top to bottom. written with ai

Profilbild von AI Alpha By Mario
AI Alpha By Mariovor 3 Monaten

The simplicity is the point—short, curated context often beats adding another memory stack

Profilbild von Pedro
Pedrovor 3 Monaten

i wish i could participate in that event with Boris

Profilbild von AlexConway.eth ⌬⃤⟁
AlexConway.eth ⌬⃤⟁vor 3 Monaten

sir this talk is almost 3 months old

Profilbild von Nahid
Nahidvor 3 Monaten

this is so smart no fancy db needed

Profilbild von joka
jokavor 3 Monaten

Editable markdown is a great memory interface, but the hard part is deciding what deserves to become durable. If every temporary correction gets written back, CLAUDE.md can turn into a pile of stale local rules. Curation and expiry matter as much as storage.

Profilbild von sindikitil
sindikitilvor 3 Monaten

CLAUDE.md as session memory is such a clean pattern. No DB, no infra — just markdown that loads automatically.

Profilbild von Seeker
Seekervor 3 Monaten

Simple systems are often the most powerful

Profilbild von Secta
Sectavor 3 Monaten

markdown files let memory scale across team without setup

Profilbild von Insomnia
Insomniavor 3 Monaten

it's help for big context

Profilbild von Mine's a large gin
Mine's a large ginvor 3 Monaten

hopefully Harold Finch has access

Profilbild von ALEXYZ
ALEXYZvor 3 Monaten

CLAUDE.md as persistent memory is brilliantly simple.

Profilbild von Chloe
Chloevor 3 Monaten

so we’re just turning the readme into a long-term memory now, i love how gloriously cursed this is.

Profilbild von Ridark
Ridarkvor 3 Monaten

This lecture is superb in everything, I started to respect him more

Ähnliche Videos

It is becoming f*cking dangerous: when Anthropic shipped CLAUDE.md, they didn't even realize they were opening a Pandora's box 1. Make an empty folder on your computer, call it SECOND BRAIN 2. Open Claude Code inside it 3. Add subfolders: MEMORY/, notes/, people/, projects/ 4. Drop a CLAUDE.md in the root with one rule: save every key fact to MEMORY, one topic per file 5. Add @-links in CLAUDE.md so key files load into context every session 6. Run claude mcp add to connect Playwright MCP, now Claude controls a real browser 7. Build a skill in .claude/skills/ so one command runs the entire routine Folder setup: about 5 minutes Your Claude becomes a second brain: it keeps every key fact between sessions, loads your main files by itself and drives a real browser Full guide in the article below
0:43

It is becoming f*cking dangerous: when Anthropic shipped CLAUDE.md, they didn't even realize they were opening a Pandora's box 1. Make an empty folder on your computer, call it SECOND BRAIN 2. Open Claude Code inside it 3. Add subfolders: MEMORY/, notes/, people/, projects/ 4. Drop a CLAUDE.md in the root with one rule: save every key fact to MEMORY, one topic per file 5. Add @-links in CLAUDE.md so key files load into context every session 6. Run claude mcp add to connect Playwright MCP, now Claude controls a real browser 7. Build a skill in .claude/skills/ so one command runs the entire routine Folder setup: about 5 minutes Your Claude becomes a second brain: it keeps every key fact between sessions, loads your main files by itself and drives a real browser Full guide in the article below

plusxbt

69,401 Aufrufe • vor 17 Tagen

It is becoming f*cking dangerous: Claude Code has kept its own memory folder since February and you've probably never opened it 1. Open any project in Claude Code and type /memory 2. Check the auto memory toggle, it is on by default in local sessions 3. Pick the option to open the auto memory folder 4. Read MEMORY.md first, it is the index, one line per memory 5. Look at the files: one memory each, typed user, feedback, project or reference 6. Tell Claude "remember: always use pnpm, not npm" and watch it save a new memory 7. Edit or delete any wrong memory, it is plain markdown Only the first 200 lines or 25KB of MEMORY.md load each session, Claude opens the topic files when needed Ask Claude to remember what matters once, it stays until you or Claude edit or delete it Full guide in the article below
0:39

It is becoming f*cking dangerous: Claude Code has kept its own memory folder since February and you've probably never opened it 1. Open any project in Claude Code and type /memory 2. Check the auto memory toggle, it is on by default in local sessions 3. Pick the option to open the auto memory folder 4. Read MEMORY.md first, it is the index, one line per memory 5. Look at the files: one memory each, typed user, feedback, project or reference 6. Tell Claude "remember: always use pnpm, not npm" and watch it save a new memory 7. Edit or delete any wrong memory, it is plain markdown Only the first 200 lines or 25KB of MEMORY.md load each session, Claude opens the topic files when needed Ask Claude to remember what matters once, it stays until you or Claude edit or delete it Full guide in the article below

plusxbt

19,632 Aufrufe • vor 12 Tagen

Clude is now available as a custom connector on Anthropic Claude. Giving it persistent memory across every conversation. It remembers your projects, your preferences, and the decisions you make, so you never start from zero again. Use Clude across Chat / Co-Work and Claude Code. Add it in 30 seconds, no API key: 1. In Claude: Customize, Add custom connector URL: Enter your email. That's it. Recap for people unfamiliar: Clude deviates from the traditional vector database that many others bolt onto Claude. We are a cognitive memory system modeled on how human memory works. Think traditional memory systems: Calculator > It computes. Fullstop. Excel > Dynamic, formula run, able to share and manipulate Clude scored 86% on LongMemEval, one of the toughest long-term memory benchmarks. This means less hallucinations to traditional platforms. It scores memories by relevance, recency, and importance, links them into a knowledge graph, and consolidates them over time. Tell Claude something, open a new chat, and watch it remember.
0:39

Clude is now available as a custom connector on Anthropic Claude. Giving it persistent memory across every conversation. It remembers your projects, your preferences, and the decisions you make, so you never start from zero again. Use Clude across Chat / Co-Work and Claude Code. Add it in 30 seconds, no API key: 1. In Claude: Customize, Add custom connector URL: Enter your email. That's it. Recap for people unfamiliar: Clude deviates from the traditional vector database that many others bolt onto Claude. We are a cognitive memory system modeled on how human memory works. Think traditional memory systems: Calculator > It computes. Fullstop. Excel > Dynamic, formula run, able to share and manipulate Clude scored 86% on LongMemEval, one of the toughest long-term memory benchmarks. This means less hallucinations to traditional platforms. It scores memories by relevance, recency, and importance, links them into a knowledge graph, and consolidates them over time. Tell Claude something, open a new chat, and watch it remember.

seb

20,756 Aufrufe • vor 4 Monaten

ANTHROPIC JUST KILLED A DOZEN AI MEMORY STARTUPS WITH ONE BUILT IN TOOL people raised millions to give AI long term memory. Anthropic just shipped it straight into the API. free, no framework, no vector database. it is a folder of files Claude reads and writes. that is it. the trick: it is client side. Claude never touches your data directly. it only requests a file operation, and your app runs it against storage you control. before every task Claude checks its /memories directory, pulls back what it learned last time, and keeps going. when it learns something new, it writes it down. six plain operations do all of it: > view, create, str_replace, insert, delete, rename why it actually wins: > just in time retrieval, it reads on demand instead of loading everything up front > it survives a context reset, so a long job resumes instead of starting over > every path is locked to /memories, so it cannot wander your filesystem > works on every Claude 4 model, no beta flag, generally available Anthropic even pairs it with context editing and compaction, so the live window stays tiny while the important stuff lives on disk. the whole thing in one line: Claude keeps the notes, you keep the storage. bookmark this before you pay for a memory layer you no longer need.
0:26

ANTHROPIC JUST KILLED A DOZEN AI MEMORY STARTUPS WITH ONE BUILT IN TOOL people raised millions to give AI long term memory. Anthropic just shipped it straight into the API. free, no framework, no vector database. it is a folder of files Claude reads and writes. that is it. the trick: it is client side. Claude never touches your data directly. it only requests a file operation, and your app runs it against storage you control. before every task Claude checks its /memories directory, pulls back what it learned last time, and keeps going. when it learns something new, it writes it down. six plain operations do all of it: > view, create, str_replace, insert, delete, rename why it actually wins: > just in time retrieval, it reads on demand instead of loading everything up front > it survives a context reset, so a long job resumes instead of starting over > every path is locked to /memories, so it cannot wander your filesystem > works on every Claude 4 model, no beta flag, generally available Anthropic even pairs it with context editing and compaction, so the live window stays tiny while the important stuff lives on disk. the whole thing in one line: Claude keeps the notes, you keep the storage. bookmark this before you pay for a memory layer you no longer need.

NO1ennn

43,756 Aufrufe • vor 2 Monaten

ANTHROPIC KILLED THE VECTOR DATABASE AND REPLACED IT WITH A FOLDER no embeddings. no black-box retrieval. no special memory tools. the agent just reads and writes a folder the insight: your agent already knows how to use a filesystem. so Anthropic made long-term memory a directory of small markdown files, mounted straight into the agent's sandbox at /mnt/memory the agent manages it with the tools it already has, bash, read, write, edit, grep, and Anthropic auto-injects a note into the system prompt so the agent always knows the memory is there and where to look the result: > every change is an immutable version: full audit trail, point-in-time recovery, redaction > read-only or read-write per store, so many agents can safely share one memory > workspace-scoped and persistent, memory that survives every session end most teams bolt on a vector DB and pray retrieval works. Anthropic went the opposite way: compiled knowledge as plain, human-readable files you can open, diff, and edit yourself and there's a second layer. Anthropic's "Dreaming" runs offline, reviews past sessions and the store, and rewrites it into a cleaner, higher-signal version. the agent literally consolidates memory in its sleep. bookmark this. the most production-grade agent memory right now is just a well-organized folder, and Anthropic proved it.
0:50

ANTHROPIC KILLED THE VECTOR DATABASE AND REPLACED IT WITH A FOLDER no embeddings. no black-box retrieval. no special memory tools. the agent just reads and writes a folder the insight: your agent already knows how to use a filesystem. so Anthropic made long-term memory a directory of small markdown files, mounted straight into the agent's sandbox at /mnt/memory the agent manages it with the tools it already has, bash, read, write, edit, grep, and Anthropic auto-injects a note into the system prompt so the agent always knows the memory is there and where to look the result: > every change is an immutable version: full audit trail, point-in-time recovery, redaction > read-only or read-write per store, so many agents can safely share one memory > workspace-scoped and persistent, memory that survives every session end most teams bolt on a vector DB and pray retrieval works. Anthropic went the opposite way: compiled knowledge as plain, human-readable files you can open, diff, and edit yourself and there's a second layer. Anthropic's "Dreaming" runs offline, reviews past sessions and the store, and rewrites it into a cleaner, higher-signal version. the agent literally consolidates memory in its sleep. bookmark this. the most production-grade agent memory right now is just a well-organized folder, and Anthropic proved it.

NO1ennn

13,359 Aufrufe • vor 3 Monaten

Most people use Claude Code like a chatbot. That is the mistake. The real power is not in better prompts. It is in controlling the session. /init gives the project memory. /memory keeps the rules alive. /clear removes old context. /compact saves the important parts. /context shows where the tokens go. /rewind fixes bad turns. /plan stops blind edits. /model matches the brain to the task. Claude Code gets 10x better when you stop letting the conversation run itself. Memory. Context. Boundaries. Rollback. Planning. That is the system. Stop asking Claude Code to “just do it”. Teach it what to remember, what to forget, and when to stop. Bookmark this before your next session turns into 40 messages of context debt.
0:33

Most people use Claude Code like a chatbot. That is the mistake. The real power is not in better prompts. It is in controlling the session. /init gives the project memory. /memory keeps the rules alive. /clear removes old context. /compact saves the important parts. /context shows where the tokens go. /rewind fixes bad turns. /plan stops blind edits. /model matches the brain to the task. Claude Code gets 10x better when you stop letting the conversation run itself. Memory. Context. Boundaries. Rollback. Planning. That is the system. Stop asking Claude Code to “just do it”. Teach it what to remember, what to forget, and when to stop. Bookmark this before your next session turns into 40 messages of context debt.

Fluixo

19,226 Aufrufe • vor 4 Monaten

THIS GUY TURNED ONE OBSIDIAN VAULT INTO A SHARED BRAIN FOR 5 CLAUDE AGENTS BUILT TO HANDLE 80% OF A SOLO DEVELOPER’S WORK. 00:03 he zooms out and hundreds of connected notes appear on screen. it is the perfect visual for Claude working from one shared project memory instead of starting from zero every session. most developers give Claude 1 file and 1 prompt. this setup gives it the architecture, coding rules, tests, client briefs, and previous decisions before it writes anything. obsidian becomes the memory layer, storing everything in markdown files Claude can read alongside the codebase. every agent works from the same context instead of repeating the same questions. then 5 specialists split the job. one researches, one plans, one codes, one reviews, and one deploys while the developer only controls the important decisions. one vault, 5 agents, 2 model tiers, and a $50 to $150 monthly stack can turn Claude from a chatbot into a small development team.
0:30

THIS GUY TURNED ONE OBSIDIAN VAULT INTO A SHARED BRAIN FOR 5 CLAUDE AGENTS BUILT TO HANDLE 80% OF A SOLO DEVELOPER’S WORK. 00:03 he zooms out and hundreds of connected notes appear on screen. it is the perfect visual for Claude working from one shared project memory instead of starting from zero every session. most developers give Claude 1 file and 1 prompt. this setup gives it the architecture, coding rules, tests, client briefs, and previous decisions before it writes anything. obsidian becomes the memory layer, storing everything in markdown files Claude can read alongside the codebase. every agent works from the same context instead of repeating the same questions. then 5 specialists split the job. one researches, one plans, one codes, one reviews, and one deploys while the developer only controls the important decisions. one vault, 5 agents, 2 model tiers, and a $50 to $150 monthly stack can turn Claude from a chatbot into a small development team.

Gipp 🦅

10,799 Aufrufe • vor 4 Monaten

Built a 3-layer Memory Stack that wires Claude Code directly into Obsidian with skills so it never forgets your project DNA, your notes, your standards, or your goals. Fixes most of Claude Code's memory issues.
1:38

Built a 3-layer Memory Stack that wires Claude Code directly into Obsidian with skills so it never forgets your project DNA, your notes, your standards, or your goals. Fixes most of Claude Code's memory issues.

WorldofAI

115,934 Aufrufe • vor 7 Monaten

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tips for Claude Code. The idea: stop dumping 500 lines into CLAUDE.md and let Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1 manage a self-pruning memory tree. Zero context bloat, path-scoped rules that load only when touched, and persistent learnings that never drift into hallucination. You just inspect and steer your memory like this: /memory here's how it splits: → Opus 5.5 locks enduring architecture rules and approves permanent memory commits → Sonnet 5.5 writes modular .claude/rules/*.md with frontmatter path globs so rules only load for matching files → Haiku 5.5 indexes MEMORY.md at 340 tok/s and sweeps transient scratchpads into topic files → Fable 5.1 acts as the memory adversary, catching contradictions between ~/.claude/CLAUDE.md and ./CLAUDE.md Fable 5.1 only steps in at three moments: → before a rule writes: does this directive contradict existing project memory or inject false constraints? → when auto-memory hits the 200-line cap: prune stale debugging notes and purge hallucinated assumptions → before session commit: audit memory diffs so transient scratchpad noise never pollutes future turns Opus 5.5 locks. Sonnet 5.5 scopes. Haiku 5.5 indexes. Fable 5.1 curates JEV engineering is the same move one layer down: the forks that need no thinker (path glob matching, auto-memory threshold check, cache hit resolution) resolve in code in 16ms, and frontier models only wake up when memory rules actually conflict the full tree > Opus 5.5 on high runs the main session and enforces zero-regression memory standards > Sonnet 5.5 drafts path-scoped rules in .claude/rules/ with frontmatter globs > Haiku 5.5 indexes MEMORY.md at 340 tok/s and offloads deep context to topic files > Fable 5.1 on call audits rule drift and eliminates contradictory directives > ~/.claude/projects/ /memory/ shares hardened learnings across all Git worktrees > JEV routes path glob matches and cache lookups in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code memory architecture around this tree: 1. Audit ~/.claude/CLAUDE.md and ./CLAUDE.md to eliminate contradictory instructions and strip out stale rules 2. Split monolithic project guidelines into modular .claude/rules/*.md files with YAML frontmatter path globs 3. Delegate MEMORY.md index maintenance and 200-line threshold pruning to Haiku 5.5 at 340 tok/s 4. Set Fable 5.1 as the adversary to audit any new memory entry before it commits to disk 5. Reserve Opus 5.5 for high-level architecture decisions and permanent memory sign-off 6. Route deterministic path matching and cache checks through JEV Show me every change as a diff first. No edits until I say go" ↳ save it, you'll use this every single day
0:25

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tips for Claude Code. The idea: stop dumping 500 lines into CLAUDE.md and let Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1 manage a self-pruning memory tree. Zero context bloat, path-scoped rules that load only when touched, and persistent learnings that never drift into hallucination. You just inspect and steer your memory like this: /memory here's how it splits: → Opus 5.5 locks enduring architecture rules and approves permanent memory commits → Sonnet 5.5 writes modular .claude/rules/*.md with frontmatter path globs so rules only load for matching files → Haiku 5.5 indexes MEMORY.md at 340 tok/s and sweeps transient scratchpads into topic files → Fable 5.1 acts as the memory adversary, catching contradictions between ~/.claude/CLAUDE.md and ./CLAUDE.md Fable 5.1 only steps in at three moments: → before a rule writes: does this directive contradict existing project memory or inject false constraints? → when auto-memory hits the 200-line cap: prune stale debugging notes and purge hallucinated assumptions → before session commit: audit memory diffs so transient scratchpad noise never pollutes future turns Opus 5.5 locks. Sonnet 5.5 scopes. Haiku 5.5 indexes. Fable 5.1 curates JEV engineering is the same move one layer down: the forks that need no thinker (path glob matching, auto-memory threshold check, cache hit resolution) resolve in code in 16ms, and frontier models only wake up when memory rules actually conflict the full tree > Opus 5.5 on high runs the main session and enforces zero-regression memory standards > Sonnet 5.5 drafts path-scoped rules in .claude/rules/ with frontmatter globs > Haiku 5.5 indexes MEMORY.md at 340 tok/s and offloads deep context to topic files > Fable 5.1 on call audits rule drift and eliminates contradictory directives > ~/.claude/projects/ /memory/ shares hardened learnings across all Git worktrees > JEV routes path glob matches and cache lookups in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code memory architecture around this tree: 1. Audit ~/.claude/CLAUDE.md and ./CLAUDE.md to eliminate contradictory instructions and strip out stale rules 2. Split monolithic project guidelines into modular .claude/rules/*.md files with YAML frontmatter path globs 3. Delegate MEMORY.md index maintenance and 200-line threshold pruning to Haiku 5.5 at 340 tok/s 4. Set Fable 5.1 as the adversary to audit any new memory entry before it commits to disk 5. Reserve Opus 5.5 for high-level architecture decisions and permanent memory sign-off 6. Route deterministic path matching and cache checks through JEV Show me every change as a diff first. No edits until I say go" ↳ save it, you'll use this every single day

mirku

22,211 Aufrufe • vor 5 Tagen

most agent memory is one file that grows forever and gets re-read every single turn. it overflows the context, overwrites old facts, loses the thread. that's why your agent feels sharp on day one and lost by week three. Sibyl Memory replaces the pile with a structure: → leaner context, lower token cost. a bloated agent file and flat memory get re-read in full every message. Sibyl Memory keeps a light hot layer and retrieves the rest on demand, so each turn carries only the tokens that matter. → relations are first-class. people link to projects, projects to deals, deals to the decisions behind them. ask about one partner and the agent surfaces the whole connected web around them. that relational context is what lets it help run a company. → one source of truth per fact, person, and project. no duplicates, no silent overwrites. works with hermes, claude code, and codex. beta open.
0:34

most agent memory is one file that grows forever and gets re-read every single turn. it overflows the context, overwrites old facts, loses the thread. that's why your agent feels sharp on day one and lost by week three. Sibyl Memory replaces the pile with a structure: → leaner context, lower token cost. a bloated agent file and flat memory get re-read in full every message. Sibyl Memory keeps a light hot layer and retrieves the rest on demand, so each turn carries only the tokens that matter. → relations are first-class. people link to projects, projects to deals, deals to the decisions behind them. ask about one partner and the agent surfaces the whole connected web around them. that relational context is what lets it help run a company. → one source of truth per fact, person, and project. no duplicates, no silent overwrites. works with hermes, claude code, and codex. beta open.

SIBYL

89,101 Aufrufe • vor 5 Monaten

A DEVELOPER CONNECTED CLAUDE CODE TO OBSIDIAN SO HIS AI AGENT WOULD STOP FORGETTING THE PROJECT EVERY MORNING. Every coding session used to start the same way. Claude would understand the repo, fix the bug, explain the architecture, and then the moment the session ended, all of that context disappeared. Same codebase. Same decisions. Same architecture. Same mistakes repeated again. So he added a memory layer. Instead of treating Claude Code like a smart terminal, he connected it to a local Obsidian vault through MCP. Now Claude can read the repo, open the vault, create notes, link concepts, and write important decisions back into the system. When it studies the codebase, it does not just answer once and forget. It creates notes for the major services, maps how the architecture works, links auth to the database, connects APIs to storage, and records why certain migrations or design choices exist. Obsidian becomes the project graph. Now when he asks why something was built a certain way, Claude does not guess from the current prompt. It reads the decision notes. When he starts a new branch, Claude checks the active context file. When the work is done, it updates what changed, what is blocked, and what the next agent needs to know before touching the repo. That is the real loop: read context, write code, capture decisions, update memory. Most people are still using AI coding tools like disposable chat windows. Ask, patch, close, forget. This setup turns Claude Code into infrastructure. The repo gets a memory layer that survives every session, and multiple AI agents can work from the same project map without stepping on each other. The unlock is not better prompting. The unlock is giving the agent somewhere to remember what it already learned.
4:19

A DEVELOPER CONNECTED CLAUDE CODE TO OBSIDIAN SO HIS AI AGENT WOULD STOP FORGETTING THE PROJECT EVERY MORNING. Every coding session used to start the same way. Claude would understand the repo, fix the bug, explain the architecture, and then the moment the session ended, all of that context disappeared. Same codebase. Same decisions. Same architecture. Same mistakes repeated again. So he added a memory layer. Instead of treating Claude Code like a smart terminal, he connected it to a local Obsidian vault through MCP. Now Claude can read the repo, open the vault, create notes, link concepts, and write important decisions back into the system. When it studies the codebase, it does not just answer once and forget. It creates notes for the major services, maps how the architecture works, links auth to the database, connects APIs to storage, and records why certain migrations or design choices exist. Obsidian becomes the project graph. Now when he asks why something was built a certain way, Claude does not guess from the current prompt. It reads the decision notes. When he starts a new branch, Claude checks the active context file. When the work is done, it updates what changed, what is blocked, and what the next agent needs to know before touching the repo. That is the real loop: read context, write code, capture decisions, update memory. Most people are still using AI coding tools like disposable chat windows. Ask, patch, close, forget. This setup turns Claude Code into infrastructure. The repo gets a memory layer that survives every session, and multiple AI agents can work from the same project map without stepping on each other. The unlock is not better prompting. The unlock is giving the agent somewhere to remember what it already learned.

DegenCalls

20,124 Aufrufe • vor 4 Monaten

HERMES AGENT LEARNS FROM ITS OWN MISTAKES. UPDATES ITS MEMORY. CREATES ITS OWN SKILLS. NO CLOUD. EVERYTHING STORED LOCALLY. THIS IS HOW THE SELF-IMPROVING LOOP WORKS. most agents start from zero every session. Hermes carries forward what it learned. THREE MEMORY SYSTEMS: 1. PROCEDURAL MEMORY (how to act) stored in ~/.hermes/skills/ as SKILL.md files. when the agent repeats a complex workflow, it saves the procedure as a reusable skill. next time the same task comes up, it follows the skill instead of figuring it out again. you can also create skills explicitly: "create a skill called video-prep that captures how I format my video scripts. spoken english, define jargon inline, no em-dashes, close with a catchphrase." the agent writes the SKILL.md. available as a slash command from that moment. Hermes ships with 90+ skills. the number grows the longer you use it. 2. SEMANTIC MEMORY (durable facts about you) stored in ~/.hermes/memory/memory.md the agent scans conversations for facts worth remembering. preferences, habits, corrections, project details. real example from the video: agent tried to scrape a YouTube channel. URL was wrong. it failed. it updated memory.md with the correct URL pattern so it never makes the same mistake again. you can also save explicitly: "save to memory that my favorite testing framework is pytest" the agent updates memory.md immediately. this file loads into context on every session. the agent knows you better every week. 3. EPISODIC MEMORY (chat history) stored in ~/.hermes/state.db (local SQLite). every conversation. every tool call. every result. searchable with FTS5 full-text search. "search our past sessions. what was the first thing I ever said to you?" the agent queries state.db and finds it. over time, auxiliary models consolidate episodic memory into semantic memory. distilling recurring patterns into durable facts. THE SELF-IMPROVING LOOP: every agent run follows this cycle: → you send a prompt → working memory loads: SOUL.md + memory.md + relevant skills + chat history → agent calls tools (terminal, browser, delegate_task) → agent completes the task, replies to you → AFTER the reply: agent checks "did I learn something worth saving?" → if yes: updates memory.md or creates a new skill → next session starts smarter than the last this happens automatically. you don't ask the agent to learn. it decides what to remember on its own. WHAT MAKES THIS DIFFERENT FROM CLAUDE CODE: Claude Code has memory too. but Hermes stores everything locally. no cloud. your data never leaves your machine. Claude Code doesn't auto-create skills from experience. Hermes turns repeated workflows into reusable procedures. Claude Code memory is instruction-based. Hermes memory is conversational and self-updating. over months of usage, Hermes builds a knowledge base of your preferences, your projects, your mistakes, and the procedures that work for your specific workflow. the agent that remembers your birthday also remembers why your last deploy failed. NO EMBEDDINGS. PLAIN TEXT. Hermes does not use embeddings or RAG for memory. skill and memory search runs on plain text keyword matching. simpler. faster. no vector database to maintain. works entirely offline on your local machine. DELEGATE TO CLAUDE CODE: Hermes can spawn a sub-agent that runs Claude Code in headless mode: "spawn a sub-agent using Claude CLI to build a Python script that fetches the top 5 Hacker News stories to markdown." Hermes delegates. Claude Code writes the code. result returns to Hermes. Hermes runs the script and delivers the output. use Hermes for orchestration. use Claude Code for heavy coding. both tools. not competitors. WHAT HERMES DOES NOT HAVE: no built-in eval or LMOps system. no LangSmith, no LangFuse integration out of the box. trajectory export and logs exist but there is no automated quality tracking. if you need eval, build it yourself or connect external tools. the loop is self-improving. measuring how well it improves is on you. comment LOOP and I'll send you the configs that control how fast Hermes learns and what it remembers. memory limits, skill auto-creation triggers, and the auxiliary model that runs the learning. Replace your entire team with 8 hermes agents👇
20:54

HERMES AGENT LEARNS FROM ITS OWN MISTAKES. UPDATES ITS MEMORY. CREATES ITS OWN SKILLS. NO CLOUD. EVERYTHING STORED LOCALLY. THIS IS HOW THE SELF-IMPROVING LOOP WORKS. most agents start from zero every session. Hermes carries forward what it learned. THREE MEMORY SYSTEMS: 1. PROCEDURAL MEMORY (how to act) stored in ~/.hermes/skills/ as SKILL.md files. when the agent repeats a complex workflow, it saves the procedure as a reusable skill. next time the same task comes up, it follows the skill instead of figuring it out again. you can also create skills explicitly: "create a skill called video-prep that captures how I format my video scripts. spoken english, define jargon inline, no em-dashes, close with a catchphrase." the agent writes the SKILL.md. available as a slash command from that moment. Hermes ships with 90+ skills. the number grows the longer you use it. 2. SEMANTIC MEMORY (durable facts about you) stored in ~/.hermes/memory/memory.md the agent scans conversations for facts worth remembering. preferences, habits, corrections, project details. real example from the video: agent tried to scrape a YouTube channel. URL was wrong. it failed. it updated memory.md with the correct URL pattern so it never makes the same mistake again. you can also save explicitly: "save to memory that my favorite testing framework is pytest" the agent updates memory.md immediately. this file loads into context on every session. the agent knows you better every week. 3. EPISODIC MEMORY (chat history) stored in ~/.hermes/state.db (local SQLite). every conversation. every tool call. every result. searchable with FTS5 full-text search. "search our past sessions. what was the first thing I ever said to you?" the agent queries state.db and finds it. over time, auxiliary models consolidate episodic memory into semantic memory. distilling recurring patterns into durable facts. THE SELF-IMPROVING LOOP: every agent run follows this cycle: → you send a prompt → working memory loads: SOUL.md + memory.md + relevant skills + chat history → agent calls tools (terminal, browser, delegate_task) → agent completes the task, replies to you → AFTER the reply: agent checks "did I learn something worth saving?" → if yes: updates memory.md or creates a new skill → next session starts smarter than the last this happens automatically. you don't ask the agent to learn. it decides what to remember on its own. WHAT MAKES THIS DIFFERENT FROM CLAUDE CODE: Claude Code has memory too. but Hermes stores everything locally. no cloud. your data never leaves your machine. Claude Code doesn't auto-create skills from experience. Hermes turns repeated workflows into reusable procedures. Claude Code memory is instruction-based. Hermes memory is conversational and self-updating. over months of usage, Hermes builds a knowledge base of your preferences, your projects, your mistakes, and the procedures that work for your specific workflow. the agent that remembers your birthday also remembers why your last deploy failed. NO EMBEDDINGS. PLAIN TEXT. Hermes does not use embeddings or RAG for memory. skill and memory search runs on plain text keyword matching. simpler. faster. no vector database to maintain. works entirely offline on your local machine. DELEGATE TO CLAUDE CODE: Hermes can spawn a sub-agent that runs Claude Code in headless mode: "spawn a sub-agent using Claude CLI to build a Python script that fetches the top 5 Hacker News stories to markdown." Hermes delegates. Claude Code writes the code. result returns to Hermes. Hermes runs the script and delivers the output. use Hermes for orchestration. use Claude Code for heavy coding. both tools. not competitors. WHAT HERMES DOES NOT HAVE: no built-in eval or LMOps system. no LangSmith, no LangFuse integration out of the box. trajectory export and logs exist but there is no automated quality tracking. if you need eval, build it yourself or connect external tools. the loop is self-improving. measuring how well it improves is on you. comment LOOP and I'll send you the configs that control how fast Hermes learns and what it remembers. memory limits, skill auto-creation triggers, and the auxiliary model that runs the learning. Replace your entire team with 8 hermes agents👇

YanXbt

23,088 Aufrufe • vor 4 Monaten

THIS MIGHT BE THE #1 OPEN-SOURCE REPO FOR CLAUDE CODE RIGHT NOW. IT GIVES CLAUDE A MEMORY AND SLASHES YOUR TOKEN COST ON EVERY QUESTION The repo is safishamsi/graphify, a free open-source skill that turns any codebase into a knowledge graph Claude Code can read instantly. Instead of grepping through your files every session, Claude gets a map of how everything connects The problem it fixes: Every time you ask Claude Code about a big repo, it does the same thing, greps through dozens of files like a brute-force Ctrl+F, blows through your context window, and sometimes still misses the answer hiding in a file nobody searched. Claude Code has no memory of how your project is structured. Every session starts from zero What it does: It maps your entire codebase into a knowledge graph, capturing not just which files exist, but which functions depend on which, which modules are central, and which files cluster around the same concern. Claude queries the map instead of scanning files How it works, three passes: 1. Code structure, free and local. Tree-sitter parses your files and pulls out classes, functions, imports and call graphs. No LLM, no tokens, just your actual code mapped deterministically 2. Audio and video, if you have them. Transcribed locally and folded into the graph 3. Docs, papers, images. Here an LLM does semantic analysis, figuring out what each document means and where it fits. Only the meaning gets sent up, never your raw source It saves you money: Normally a question about a big repo makes Claude spawn explore agents that scan file after file, eating your context window and your token budget before you get an answer. With the graph already built, Claude queries the map instead of re-reading the codebase every time. Same answer, a fraction of the tokens. The graph only gets built once, then a hook rebuilds it after each commit for free, so you never pay that scanning cost again. The bigger the repo, the bigger the gap The best parts: it's a skill, so once installed Claude knows when to use it without you memorizing commands. It works on non-code folders too, point it at docs or notes and it can spin up an Obsidian vault How to add it to your Claude: 1. Install Claude Code if you haven't: npm install -g Paul Jankura-ai/claude-code 2. Add the skill: claude skill add safishamsi/graphify 3. Open your project folder and run /graphify . to build the graph 4. Optional, make it automatic: graphify hook install so the graph rebuilds after every commit That's it. Ask Claude about your repo and it reads the map instead of burning tokens on a file hunt Bookmark this
13:23

THIS MIGHT BE THE #1 OPEN-SOURCE REPO FOR CLAUDE CODE RIGHT NOW. IT GIVES CLAUDE A MEMORY AND SLASHES YOUR TOKEN COST ON EVERY QUESTION The repo is safishamsi/graphify, a free open-source skill that turns any codebase into a knowledge graph Claude Code can read instantly. Instead of grepping through your files every session, Claude gets a map of how everything connects The problem it fixes: Every time you ask Claude Code about a big repo, it does the same thing, greps through dozens of files like a brute-force Ctrl+F, blows through your context window, and sometimes still misses the answer hiding in a file nobody searched. Claude Code has no memory of how your project is structured. Every session starts from zero What it does: It maps your entire codebase into a knowledge graph, capturing not just which files exist, but which functions depend on which, which modules are central, and which files cluster around the same concern. Claude queries the map instead of scanning files How it works, three passes: 1. Code structure, free and local. Tree-sitter parses your files and pulls out classes, functions, imports and call graphs. No LLM, no tokens, just your actual code mapped deterministically 2. Audio and video, if you have them. Transcribed locally and folded into the graph 3. Docs, papers, images. Here an LLM does semantic analysis, figuring out what each document means and where it fits. Only the meaning gets sent up, never your raw source It saves you money: Normally a question about a big repo makes Claude spawn explore agents that scan file after file, eating your context window and your token budget before you get an answer. With the graph already built, Claude queries the map instead of re-reading the codebase every time. Same answer, a fraction of the tokens. The graph only gets built once, then a hook rebuilds it after each commit for free, so you never pay that scanning cost again. The bigger the repo, the bigger the gap The best parts: it's a skill, so once installed Claude knows when to use it without you memorizing commands. It works on non-code folders too, point it at docs or notes and it can spin up an Obsidian vault How to add it to your Claude: 1. Install Claude Code if you haven't: npm install -g Paul Jankura-ai/claude-code 2. Add the skill: claude skill add safishamsi/graphify 3. Open your project folder and run /graphify . to build the graph 4. Optional, make it automatic: graphify hook install so the graph rebuilds after every commit That's it. Ask Claude about your repo and it reads the map instead of burning tokens on a file hunt Bookmark this

Yarchi

56,568 Aufrufe • vor 5 Monaten

Claude Code With UNLIMITED Memory! Solves Claude's Memory Problem! It’s called Claude-Mem, and it lets Claude remember your work across sessions. ⚡ Slash token usage by up to 95% every time you start a session. 🔧 Unlock the ability to make 20× more tool calls before hitting limits. My Video:
0:58

Claude Code With UNLIMITED Memory! Solves Claude's Memory Problem! It’s called Claude-Mem, and it lets Claude remember your work across sessions. ⚡ Slash token usage by up to 95% every time you start a session. 🔧 Unlock the ability to make 20× more tool calls before hitting limits. My Video:

WorldofAI

28,687 Aufrufe • vor 9 Monaten

Martin Keen from IBM just explained the one thing separating "chatbot users" from $300K AI architects > most people use Claude Opus 4.8 as a temporary tool -> the pros build it a permanent memory it's called the CoALA framework. the 4 layers your agent actually needs: > Working Memory - the context window. fast but resets every session. this is the RAM, not the brain > Semantic Memory - your knowledge base. CLAUDE.md, rules, facts the agent never forgets regardless of session > Procedural Memory - skills. workflows and instructions that load only when a specific task begins > Episodic Memory - past lessons. the agent remembers every bug it fixed yesterday so it doesn't repeat it today if your agent doesn't have all four, it's a fancy autocomplete the 2026 job market isn't looking for prompt engineers > it's looking for people who can build AI brains - and the ones doing it now aren't waiting for job postings save this or watch someone else use it to get your next raise 👇
10:04

Martin Keen from IBM just explained the one thing separating "chatbot users" from $300K AI architects > most people use Claude Opus 4.8 as a temporary tool -> the pros build it a permanent memory it's called the CoALA framework. the 4 layers your agent actually needs: > Working Memory - the context window. fast but resets every session. this is the RAM, not the brain > Semantic Memory - your knowledge base. CLAUDE.md, rules, facts the agent never forgets regardless of session > Procedural Memory - skills. workflows and instructions that load only when a specific task begins > Episodic Memory - past lessons. the agent remembers every bug it fixed yesterday so it doesn't repeat it today if your agent doesn't have all four, it's a fancy autocomplete the 2026 job market isn't looking for prompt engineers > it's looking for people who can build AI brains - and the ones doing it now aren't waiting for job postings save this or watch someone else use it to get your next raise 👇

Mr. Buzzoni

10,442 Aufrufe • vor 5 Monaten

Many kept asking how I build my game with AI. Today I open-sourced the whole workspace. A year of building went into it: one repo that keeps project context, knowledge and workflows in one place, so Claude Code, Codex, Blender and Unity all work from the same memory. Every asset in my game goes through it. Full walkthrough and setup:
0:45

Many kept asking how I build my game with AI. Today I open-sourced the whole workspace. A year of building went into it: one repo that keeps project context, knowledge and workflows in one place, so Claude Code, Codex, Blender and Unity all work from the same memory. Every asset in my game goes through it. Full walkthrough and setup:

Stefan 3D AI

19,123 Aufrufe • vor 1 Monat

Engineer runs a Kimi K3 memory layer that costs $11 a month and remembers what a $500,000 vector database keeps losing. No embeddings. Four nodes and one rule about what's allowed to be forgotten. He published the whole schema. His version starts from the opposite idea. Memory is not a pile you search. It's a set of claims that expire unless something keeps paying to keep them. Four nodes. Every memory carries a clock someone has to reset: > WRITER - stores a fact with the reason it mattered, never raw text > DECAY - ages every memory down. Silence is deletion > RENEWER - only re-lifts a memory the model actually used again > GRAVE - holds what died, and why nobody reached for it Three nodes keep memory alive. One keeps the dead ones. Recall isn't storage here. It's rent a fact has to keep earning. That's the entire design. When everything is remembered forever, the useful and the stale retrieve identically. He replayed two months of agent context. 90,000 stored facts. 71,000 never retrieved once. The vector store returned all of them on similarity. Similarity graded closeness. Nobody graded whether the memory was ever right. Everyone else stuffs more into the context window and calls it memory. He built a layer that lets a fact die unless it keeps proving itself. The cost isn't storage. It's finding out how much of what your agent "knows" it has never once used. The article below is the full build - node prompts, the decay curve, the renewal rule. Save it. You'll want it open in the other tab.
0:40

Engineer runs a Kimi K3 memory layer that costs $11 a month and remembers what a $500,000 vector database keeps losing. No embeddings. Four nodes and one rule about what's allowed to be forgotten. He published the whole schema. His version starts from the opposite idea. Memory is not a pile you search. It's a set of claims that expire unless something keeps paying to keep them. Four nodes. Every memory carries a clock someone has to reset: > WRITER - stores a fact with the reason it mattered, never raw text > DECAY - ages every memory down. Silence is deletion > RENEWER - only re-lifts a memory the model actually used again > GRAVE - holds what died, and why nobody reached for it Three nodes keep memory alive. One keeps the dead ones. Recall isn't storage here. It's rent a fact has to keep earning. That's the entire design. When everything is remembered forever, the useful and the stale retrieve identically. He replayed two months of agent context. 90,000 stored facts. 71,000 never retrieved once. The vector store returned all of them on similarity. Similarity graded closeness. Nobody graded whether the memory was ever right. Everyone else stuffs more into the context window and calls it memory. He built a layer that lets a fact die unless it keeps proving itself. The cost isn't storage. It's finding out how much of what your agent "knows" it has never once used. The article below is the full build - node prompts, the decay curve, the renewal rule. Save it. You'll want it open in the other tab.

wast3

67,952 Aufrufe • vor 2 Monaten

THIS IS AN ACTUAL F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: run Opus 5.5 and three Sonnet 5.5 subagents, each one keeping its own memory for the job it's best at. Less repeated explaining, because every task lands on an agent that can reuse what it learned about your repo. You just launch Claude Code like this: claude --model opus here's my split: → Opus 5.5 runs the session, plans the work and applies the final fixes → Sonnet 5.5 handles implementation, debugging and diff reviews in separate contexts → memory: project gives each subagent persistent notes that survive between sessions → you stop burning Opus 5.5 context on explaining the same repo conventions again Opus 5.5 only steps in for the big calls at three moments: → before a plan locks → when the same error shows up twice → before calling it done Sonnet 5.5 builds. Memory carries forward. Opus 5.5 reviews. persistent memory takes the same idea one layer down: the findings you keep rediscovering (which module, which test, which fix actually worked) go into each agent's memory, and its next run starts with its saved memory index the full tree > Opus 5.5 runs the main session and coordinates the work > builder implements features on Sonnet 5.5 and remembers repo conventions > debugger fixes failures on Sonnet 5.5 and remembers verified root causes > reviewer checks the diff on Sonnet 5.5 and remembers recurring review patterns > Opus 5.5 reviews the synthesized diff before sign-off > each worker keeps project-scoped memory and checks old notes against current code paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Run the main session on Opus 5.5. Verify both model aliases resolve to 5.5 on my provider. 2. Create three Sonnet 5.5 subagents in .claude/agents: builder (implements features), debugger (fixes failures), reviewer (checks the diff). Flag a restart if this agents directory is new. 3. Set memory: project on all three. Check that auto memory is enabled; ask before changing that setting. 4. Add one rule to CLAUDE.md: delegate implementation, debugging and diff reviews to these subagents to keep the main context small. Sequence dependent work. 5. Tell each agent to consult its memory before working and save only verified, reusable findings afterward. Keep MEMORY.md concise, link detailed notes, and recheck stale assumptions against the code. Show me every change as a diff first. No edits until I say go." ↳ save it, it'll come in handy.
0:37

THIS IS AN ACTUAL F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: run Opus 5.5 and three Sonnet 5.5 subagents, each one keeping its own memory for the job it's best at. Less repeated explaining, because every task lands on an agent that can reuse what it learned about your repo. You just launch Claude Code like this: claude --model opus here's my split: → Opus 5.5 runs the session, plans the work and applies the final fixes → Sonnet 5.5 handles implementation, debugging and diff reviews in separate contexts → memory: project gives each subagent persistent notes that survive between sessions → you stop burning Opus 5.5 context on explaining the same repo conventions again Opus 5.5 only steps in for the big calls at three moments: → before a plan locks → when the same error shows up twice → before calling it done Sonnet 5.5 builds. Memory carries forward. Opus 5.5 reviews. persistent memory takes the same idea one layer down: the findings you keep rediscovering (which module, which test, which fix actually worked) go into each agent's memory, and its next run starts with its saved memory index the full tree > Opus 5.5 runs the main session and coordinates the work > builder implements features on Sonnet 5.5 and remembers repo conventions > debugger fixes failures on Sonnet 5.5 and remembers verified root causes > reviewer checks the diff on Sonnet 5.5 and remembers recurring review patterns > Opus 5.5 reviews the synthesized diff before sign-off > each worker keeps project-scoped memory and checks old notes against current code paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Run the main session on Opus 5.5. Verify both model aliases resolve to 5.5 on my provider. 2. Create three Sonnet 5.5 subagents in .claude/agents: builder (implements features), debugger (fixes failures), reviewer (checks the diff). Flag a restart if this agents directory is new. 3. Set memory: project on all three. Check that auto memory is enabled; ask before changing that setting. 4. Add one rule to CLAUDE.md: delegate implementation, debugging and diff reviews to these subagents to keep the main context small. Sequence dependent work. 5. Tell each agent to consult its memory before working and save only verified, reusable findings afterward. Keep MEMORY.md concise, link detailed notes, and recheck stale assumptions against the code. Show me every change as a diff first. No edits until I say go." ↳ save it, it'll come in handy.

hayato

32,365 Aufrufe • vor 6 Tagen

STOP BURNING YOUR OPUS 5.5 LIMIT FOR NOTHING these 8 repos cut what Claude reads, writes and re-reads. copy the list before your next long session: headroom: shrinks tool output, logs and files before they reach the model, and keeps the originals so Claude can pull them back when it needs them. 75k stars claude-context: semantic search over your whole codebase, so Claude fetches the relevant snippets and doesn’t read whole files to find them. 12k stars lean-ctx: a local layer that compresses file reads and shell output. a file Claude already read costs about 13 tokens the second time. 3.8k stars openwolf: hooks that keep a project index and session notes, so Claude skips files it already read and doesn’t lose its work at compaction. 2.1k stars claude-token-efficient: one CLAUDE.md that keeps answers short. nothing to install, and output is the $20-per-million side of Opus 5.5. 6.1k stars jcodemunch-mcp: indexes the repo once, then Claude asks for one function and gets just that. it claims 95% less code reading. 2.5k stars ccusage: reads your local Claude Code logs and shows tokens and cost by day and by session. 19k stars Claude-Code-Usage-Monitor: live usage bars and a forecast of when you’ll hit your limit. 8.6k stars none of them makes Opus better. each one just stops it from paying for tokens it didn’t need start with the last two: see where your limit actually goes, then pick two tools from the top. the full setup with scripts is in the article
0:24

STOP BURNING YOUR OPUS 5.5 LIMIT FOR NOTHING these 8 repos cut what Claude reads, writes and re-reads. copy the list before your next long session: headroom: shrinks tool output, logs and files before they reach the model, and keeps the originals so Claude can pull them back when it needs them. 75k stars claude-context: semantic search over your whole codebase, so Claude fetches the relevant snippets and doesn’t read whole files to find them. 12k stars lean-ctx: a local layer that compresses file reads and shell output. a file Claude already read costs about 13 tokens the second time. 3.8k stars openwolf: hooks that keep a project index and session notes, so Claude skips files it already read and doesn’t lose its work at compaction. 2.1k stars claude-token-efficient: one CLAUDE.md that keeps answers short. nothing to install, and output is the $20-per-million side of Opus 5.5. 6.1k stars jcodemunch-mcp: indexes the repo once, then Claude asks for one function and gets just that. it claims 95% less code reading. 2.5k stars ccusage: reads your local Claude Code logs and shows tokens and cost by day and by session. 19k stars Claude-Code-Usage-Monitor: live usage bars and a forecast of when you’ll hit your limit. 8.6k stars none of them makes Opus better. each one just stops it from paying for tokens it didn’t need start with the last two: see where your limit actually goes, then pick two tools from the top. the full setup with scripts is in the article

rvaniaaa

12,381 Aufrufe • vor 26 Tagen

THIS IS A PURE F*CKING GOLDMINE Anthropic just documented how Claude Code actually remembers your entire codebase across sessions The idea: stop dumping 500 lines into CLAUDE.md and let the new Haiku 5.5 manage an auto-indexing memory tree while Opus 5.5 audits your rules Zero context bloat, path-scoped rules that load only when touched, and persistent learnings that survive across Git worktrees You just inspect and steer it in Claude Code like this: /memory here's how it splits: → Opus 5.5 audits rule integrity: runs /doctor prompt-audit to catch stale instructions, contradictions, and obsolete configs → Sonnet 5.5 writes path-scoped rules: drafts modular .claude/rules/ with frontmatter globs so rules only load for matching files → Haiku 5.5 maintains auto-memory: indexes MEMORY.md at 340 tok/s and moves deep context into dedicated topic files → you stop burning Opus context on static prompt bloat and keep your session token count razor thin The memory architecture runs through three proven layers: → path-scoped rules: .claude/rules/*.md load strictly when touched files match, saving up to 80% context → auto-memory index: MEMORY.md caps at 200 lines / 25KB, keeping startup instant across all worktrees → on-demand topic files: detailed architectural notes live in ~/.claude/projects/ /memory/ without polluting the turn Opus audits, Haiku indexes, Sonnet scopes JEV engineering is the same move one layer down: the forks that need no thinker (which rule file matches, auto-memory threshold, stale timestamp drop) resolve in code in 15ms, and the frontier models only see the ones that split the full tree > Opus 5.5 audits rule consistency and runs /doctor prompt-audit > Haiku 5.5 prunes and indexes MEMORY.md at 340 tok/s (1M context) > Sonnet 5.5 writes path-scoped rules in .claude/rules/ with frontmatter globs > on-demand topic files capture edge cases without burning startup tokens > ~/.claude/projects/ /memory/ shares learnings across all Git worktrees > Opus 5.5 enforces zero-regression architecture standards > JEV routes path matching in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code memory architecture around this tree: 1. Audit my current CLAUDE.md with /doctor prompt-audit and strip out stale or conflicting rules 2. Move file-specific instructions into .claude/rules/*.md with YAML frontmatter path globs 3. Delegate MEMORY.md indexing and 200-line threshold management to Haiku 5.5 at 340 tok/s 4. Route detailed architectural learnings and edge cases to Sonnet 5.5 as on-demand topic files 5. Reserve Opus 5.5 for high-level rule consistency and cross-worktree memory verification Show me every change as a diff first. No edits until I say go" ↳ save it, it'll come in handy
0:25

THIS IS A PURE F*CKING GOLDMINE Anthropic just documented how Claude Code actually remembers your entire codebase across sessions The idea: stop dumping 500 lines into CLAUDE.md and let the new Haiku 5.5 manage an auto-indexing memory tree while Opus 5.5 audits your rules Zero context bloat, path-scoped rules that load only when touched, and persistent learnings that survive across Git worktrees You just inspect and steer it in Claude Code like this: /memory here's how it splits: → Opus 5.5 audits rule integrity: runs /doctor prompt-audit to catch stale instructions, contradictions, and obsolete configs → Sonnet 5.5 writes path-scoped rules: drafts modular .claude/rules/ with frontmatter globs so rules only load for matching files → Haiku 5.5 maintains auto-memory: indexes MEMORY.md at 340 tok/s and moves deep context into dedicated topic files → you stop burning Opus context on static prompt bloat and keep your session token count razor thin The memory architecture runs through three proven layers: → path-scoped rules: .claude/rules/*.md load strictly when touched files match, saving up to 80% context → auto-memory index: MEMORY.md caps at 200 lines / 25KB, keeping startup instant across all worktrees → on-demand topic files: detailed architectural notes live in ~/.claude/projects/ /memory/ without polluting the turn Opus audits, Haiku indexes, Sonnet scopes JEV engineering is the same move one layer down: the forks that need no thinker (which rule file matches, auto-memory threshold, stale timestamp drop) resolve in code in 15ms, and the frontier models only see the ones that split the full tree > Opus 5.5 audits rule consistency and runs /doctor prompt-audit > Haiku 5.5 prunes and indexes MEMORY.md at 340 tok/s (1M context) > Sonnet 5.5 writes path-scoped rules in .claude/rules/ with frontmatter globs > on-demand topic files capture edge cases without burning startup tokens > ~/.claude/projects/ /memory/ shares learnings across all Git worktrees > Opus 5.5 enforces zero-regression architecture standards > JEV routes path matching in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code memory architecture around this tree: 1. Audit my current CLAUDE.md with /doctor prompt-audit and strip out stale or conflicting rules 2. Move file-specific instructions into .claude/rules/*.md with YAML frontmatter path globs 3. Delegate MEMORY.md indexing and 200-line threshold management to Haiku 5.5 at 340 tok/s 4. Route detailed architectural learnings and edge cases to Sonnet 5.5 as on-demand topic files 5. Reserve Opus 5.5 for high-level rule consistency and cross-worktree memory verification Show me every change as a diff first. No edits until I say go" ↳ save it, it'll come in handy

mirku

30,878 Aufrufe • vor 20 Tagen