Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

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

19,226 görüntüleme • 1 ay önce •via X (Twitter)

0 Yorum

Yorum bulunmuyor

Orijinal gönderinin yorumları burada görünecek

Benzer Videolar

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 • 1 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 • 2 ay önce

I got curious how compaction works as a PM, so I did some brain surgery on Claude Code: (Anthropic's been doing really interesting work on context editing - they showed Claude Opus playing Settlers of Catan for 75+ minutes in a single thread by constantly editing the context instead of starting fresh. When I saw that Claude Code has a compaction command with optional custom instructions, I wanted to understand what's actually happening.) Abhishek Katiyar and Aman Khan gave me the key tip: Claude Code stores all your conversation history as text files on your computer. Open a new directory and give Claude Code a task. Here's how to watch compaction happening: 1. Go to your user's root directory 2. Press Command+Shift+Period (Mac) to show hidden folders 3. Navigate to ~/.claude/projects/ 4. Find your project folder and use Cursor/VSCode to open it (there's a reason) 5. Install the JSONL Gazelle plugin (open source, thank you Gabor Cselle!) 6. Open the most recent JSONL file - each row is a message in your conversation 7. Run the compact command in Claude Code with custom instructions 8. Watch what happens in the file What I learned: When you compact, Claude Code doesn't just summarize and delete everything. It creates a "compact boundary" in the conversation file, writes a summary of what happened before, but keeps the full original conversation (!!!!) The new thread can still retrieve any details from before compaction if needed. That is so damn cool. Why this matters: What you're getting in Claude Code is similar to what Anthropic ships in their developer SDK - so inspecting your daily tools is how you build real product intuition. The best way to understand AI systems is to open them up and look inside. Everything is text files.

Tal Raviv

57,910 görüntüleme • 7 ay önce

New short course: LLMs as Operating Systems: Agent Memory, created with Letta, and taught by its founders Charles Packer and Sarah Wooders. An LLM's input context window has limited space. Using a longer input context also costs more and results in slower processing. So, managing what's stored in this context window is important. In the innovative paper MemGPT: Towards LLMs as Operating Systems, its authors (which include the instructors) proposed using an LLM agent to manage this context window. Their system uses a large persistent memory that stores everything that could be included in the input context, and an agent decides what is actually included. Take the example of building a chatbot that needs to remember what's been said earlier in a conversation (perhaps over many days of interaction with a user). As the conversation's length grows, the memory management agent will move information from the input context to a persistent searchable database; summarize information to keep relevant facts in the input context; and restore relevant conversation elements from further back in time. This allows a chatbot to keep what's currently most relevant in its input context memory to generate the next response. When I read the original MemGPT paper, I thought it was an innovative technique for handling memory for LLMs. The open-source Letta framework, which we'll use in this course, makes MemGPT easy to implement. It adds memory to your LLM agents and gives them transparent long-term memory. In detail, you’ll learn: - How to build an agent that can edit its own limited input context memory, using tools and multi-step reasoning - What is a memory hierarchy (an idea from computer operating systems, which use a cache to speed up memory access), and how these ideas apply to managing the LLM input context (where the input context window is a "cache" storing the most relevant information; and an agent decides what to move in and out of this to/from a larger persistent storage system) - How to implement multi-agent collaboration by letting different agents share blocks of memory This course will give you a sophisticated understanding of memory management for LLMs, which is important for chatbots having long conversations, and for complex agentic workflows. Please sign up here!

Andrew Ng

200,950 görüntüleme • 1 yıl ö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,177 görüntüleme • 2 ay önce