Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

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...

19,250 görüntüleme • 4 gün önce •via X (Twitter)

10 Yorum

Bober_smart profil fotoğrafı
Bober_smart4 gün önce

I recommend this setting to everyone

plusxbt profil fotoğrafı
plusxbt4 gün önce

🫡

The SI Maximalist profil fotoğrafı
The SI Maximalist4 gün önce

The memory folder needs a proper introduction.

Prior profil fotoğrafı
Prior4 gün önce

the 200 line cap is the part to watch. once MEMORY.md grows past it, every line after 200 stops loading and claude just quietly forgets those. worth pruning it every few weeks

Leo profil fotoğrafı
Leo4 gün önce

A memory folder that fills itself is useful until stale notes start steering the model. Do you prune it by hand, or let it accumulate?

Nguyễn Chí Trọng Nghĩa profil fotoğrafı
Nguyễn Chí Trọng Nghĩa4 gün önce

Vào /memory xem thử mới biết Claude Code nhớ dai từ tháng 2, kiểu bạn thân thuộc lòng chuyện cũ 🙂

John Rood profil fotoğrafı
John Rood4 gün önce

yes, and the reason is that the folder stores conclusions, not evidence. a line saying "use X" carries no date and no reason, so nothing in it can go stale on its own. that gap is the whole problem i built memoryrouter around: the decision, the why and the date travel together or you just inherit yesterday's guess.

小樱聊车知识多 profil fotoğrafı
小樱聊车知识多4 gün önce

made the button bigger, cut the radius, entire layout just works better

爱车人的日常频道 profil fotoğrafı
爱车人的日常频道3 gün önce

Next pour was so forget when the ground must already be bitter my okay found no grinding

Atenov int. profil fotoğrafı
Atenov int.4 gün önce

How many people actually read what Claude stored about their workflows before sharing a project folder with someone else?

Benzer Videolar

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 görüntüleme • 12 gün önce

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 görüntüleme • 3 ay önce

I can't f*cking believe people still use Claude Code like a chat bot. the ones getting real work out of it gave it a folder, tools and a map of everything it knows. that map is graphify. you point it at a folder and it builds a knowledge graph of everything inside. code, docs, PDFs, images, even video. then your agent searches the graph instead of opening files one by one. 134k stars on GitHub. backed by Y Combinator. and most people still haven't tried it. what makes it different: -> the code part runs fully on your machine. nothing gets uploaded -> no vector database, no embeddings. it's a real graph your agent walks through -> every connection is labeled: read straight from the source, or figured out by graphify. you always know which -> you get 3 files: a clickable map you open in your browser, a report with the key ideas and surprising links, and the full graph your agent queries anytime on a public memory benchmark it found the right answer in its top 10 results about half the time. mem0 managed under 5%. and building the graph cost 0 model credits. here's the full setup around it: > create a folder called AGENT, open Claude Code inside it, and add a CLAUDE.md with one line: "save every decision, person and project to memory/" > run uv tool install graphifyy, then graphify install, then type /graphify . and the whole folder becomes a map Claude can search in seconds > run npm install -g @googleworkspace/cli, then gws auth setup and gws auth login. Claude can now read your Gmail, Calendar and Drive > run claude mcp add playwright npx @playwright/mcp@latest. it gets its own browser for sites, forms and data > run npm i -g jev-guard, then jev-guard key "...", then jev-guard install claude. Jev checks every action before it runs. rm -rf gets blocked, emails with hidden instructions get flagged, about 4 cents per 1,000 checks > type /schedule and say "every morning at 7:30, send me what came in, what you drafted and what needs my yes" one folder. 15 minutes. and Claude finally knows where everything is. all the repos: -> -> -> -> bookmark this and try graphify first. it's the piece everyone skips.

kiosa

29,075 görüntüleme • 8 gün önce

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 görüntüleme • 4 ay önce

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 görüntüleme • 4 ay önce

THIS GUY BUILT AN AUTONOMOUS AI AGENT OUT OF CLAUDE CODE + OBSIDIAN and this is way more interesting than another “use AI to take notes” demo the trick is simple: Obsidian is not the writing app here. it becomes the agent’s memory, task board, and context folder. Claude Code is not just answering prompts. it reads the vault, edits files, follows instructions, and keeps moving through the work like a junior operator with a filesystem. the reusable setup looks like this: 1. create an Obsidian vault for one project 2. keep goals, rules, tasks, decisions, and references as markdown files 3. point Claude Code at the folder 4. give it a clear operating loop: read context → choose next task → execute → write back what changed 5. use the notes as persistent memory instead of re-explaining the project every chat that’s the part people miss. the “agent” is not magic. it’s the boring combination of: - local files - explicit rules - task state - write access - a model that can run through the repo/vault Obsidian makes the memory human-readable. Claude Code makes the memory executable. that combo is why the video worked: it turns a notes app into an operating surface for actual work. best use cases: - content systems - research vaults - coding projects - client ops docs - personal knowledge bases that need actions, not just storage the caveat: if your vault is messy, your agent becomes messy too. folders, naming, “done” criteria, and forbidden actions matter more than the prompt. but once the structure is clean, this is one of the easiest ways to build an agent that remembers what happened yesterday without paying for a full custom app.

kocer

30,403 görüntüleme • 4 ay önce