Latest / AI Fire Daily / #588 Neil: AI Memory Still Forgets the Project Context You Need Most

Transcript

#588 Neil: AI Memory Still Forgets the Project Context You Need Most · AI Fire Daily

• 0:00
  You just spent three solid hours doing deep work
• 0:03
  with an AI. You mapped out massive decisions
• 0:06
  for your ongoing work. But three days later,
• 0:09
  you are endlessly scrolling through your old
• 0:12
  chat logs. You need to find one tiny missing
• 0:16
  detail. And you are doing this because the AI
• 0:19
  just completely forgot a crucial deadline. It
• 0:22
  is the absolute worst feeling. It really is.
• 0:25
  Well, welcome to the Deep Dive. We're incredibly
• 0:27
  thrilled to have you listening today. We have
• 0:28
  a lot to cover. We do. We have a very clear roadmap
• 0:31
  for this session. Today's mission is to break
• 0:35
  down the three levels of AI memory. Exactly.
• 0:38
  We want you to keep your important context secure.
• 0:41
  You should really never have to dig through old
• 0:42
  chats again. Right. Nobody has time for that.
• 0:45
  No, they don't. So we will explore the basic
• 0:48
  built -in memory features first, then we will
• 0:51
  explore building a completely custom file -based
• 0:53
  system. We absolutely have to understand the
• 0:56
  default state of AI memory, though. Right. I
• 0:58
  mean, we need to do that before we can actually
• 1:00
  fix it. That brings us right to the starting
• 1:02
  line. Let us examine what we call level one memory.
• 1:06
  Yeah, the baseline. Exactly. This is the global
• 1:08
  AI memory layer. So what exactly is happening
• 1:11
  under the hood here? So global AI memory is the
• 1:14
  basic baseline layer you get right now. You find
• 1:17
  this operating in chat GPT, Claude, or Gemini.
• 1:21
  It basically works by silently attaching your
• 1:23
  preferences to every new conversation. Like an
• 1:26
  invisible system prompt. Exactly. It is an invisible
• 1:29
  system prompt running in the background. Okay,
• 1:32
  so it essentially remembers the broad strokes
• 1:34
  of your professional life. Right. It keeps track
• 1:37
  of your specific job or your daily role. It notes
• 1:40
  the tone you usually use in your writing. Exactly.
• 1:43
  It tracks the writing preferences you mentioned
• 1:45
  most frequently. Okay. Let us say you prefer
• 1:48
  to write short, natural emails. The AI logs that
• 1:52
  specific preference in its global database. So
• 1:55
  when you start a brand new chat session on Tuesday,
• 1:58
  the AI applies that writing style without asking
• 2:00
  you again. Wow. So it bypasses that initial friction
• 2:03
  of setting up the persona. Yeah. It saves a ton
• 2:06
  of time. Yeah. You can actually verify this mechanism
• 2:08
  for yourself right now. Oh yeah. In chat GPT,
• 2:12
  navigate through your settings to find this layer.
• 2:15
  Go to personalization, then memory, and finally
• 2:18
  click manage. OK. That dashboard shows you exactly
• 2:22
  what the AI has saved globally. This is where
• 2:24
  the cracks start to show, right? Oh, absolutely.
• 2:26
  Global AI memory can easily miss important granular
• 2:31
  project details. You might have a brand new deadline
• 2:34
  for a launch. Or you might have a crucial decision
• 2:38
  from a strategy meeting. The AI simply cannot
• 2:41
  always remember every single moving part. No,
• 2:44
  it cannot. And we can actually run a quick test
• 2:46
  of this global memory. How does that work? You
• 2:49
  can try this out with a very simple prompt. You
• 2:51
  tell the AI to explicitly update its internal
• 2:54
  memory. OK. You say your upcoming presentation
• 2:57
  is on October 6. and you state you prefer short,
• 3:00
  direct slide headlines. Got it. Then you go and
• 3:02
  start a completely new blank chat. Exactly. You
• 3:05
  ask the AI what it remembers about your upcoming
• 3:07
  presentation. You also ask what it remembers
• 3:09
  about your writing preferences. Right. If the
• 3:11
  AI saved that information correctly, you will
• 3:14
  see it immediately. The presentation date should
• 3:16
  appear right there in the final answer. Yeah.
• 3:19
  You should also clearly see your specific writing
• 3:22
  preference applied. That sounds great on the
• 3:24
  surface, but we really need to look at the massive
• 3:27
  limitation here. We do. Global memory is like
• 3:30
  having a very eager personal assistant. This
• 3:33
  assistant perfectly remembers how you take your
• 3:36
  morning coffee, but they have absolutely no idea
• 3:40
  what actual project you're working on. That is
• 3:42
  an incredibly accurate way to look at it. Right.
• 3:46
  Global memory stretches across many different
• 3:48
  unrelated conversations at once. The AI has to
• 3:52
  balance information useful in vastly different
• 3:54
  situations. Which creates a very messy digital
• 3:58
  filing cabinet. I mean, you probably do not want
• 4:00
  to work presentation deadlines suddenly showing
• 4:02
  up, especially while you are just trying to plan
• 4:05
  a relaxing weekend trip. Right. And we call that
• 4:07
  phenomenon context collapse. Context collapse.
• 4:10
  Because of that massive risk, global AI memory
• 4:13
  is intentionally limited. It simply is not a
• 4:16
  reliable place for full project histories. Let
• 4:19
  us say you made a key design decision yesterday.
• 4:22
  You might clearly remember why you chose that
• 4:25
  specific layout, but the AI can still completely
• 4:29
  forget it in a new chat. Why does the system
• 4:32
  fail to retrieve that specific detail? It fails
• 4:36
  because the context window gets incredibly diluted
• 4:39
  over time. You are basically expecting it to
• 4:43
  pull a needle from a massive haystack. You can
• 4:47
  try to connect your Google Drive to fix this
• 4:49
  gap. Right. Or you can ask the AI to use a meeting
• 4:52
  transcript as context. Exactly. That works reasonably
• 4:55
  well when the information exists in a saved document.
• 4:58
  But what if that important decision only lives
• 5:00
  in an old chat? Yeah, that happens all the time.
• 5:03
  What if it emerged from a very quick phone call?
• 5:05
  Or maybe an in -person conversation that you
• 5:07
  simply never documented anywhere. Right. The
• 5:09
  AI will absolutely miss that critical information
• 5:11
  entirely. It cannot reference what it cannot
• 5:14
  clearly see in its active memory. So if Global
• 5:16
  memory is just a broad baseline. How do we fence
• 5:19
  off specific work to keep it clean? We use project
• 5:22
  -specific memory to wall off your related data.
• 5:25
  That makes total sense, because global memory
• 5:28
  mixes absolutely everything together by default.
• 5:31
  We desperately need a way to build a wall around
• 5:34
  specific tasks. This leads us directly into level
• 5:39
  two of AI memory. Level two is what we call project
• 5:42
  AI memory. If that global baseline feels way
• 5:46
  too broad, you use this. Use project AI memory
• 5:49
  to keep one single project highly focused. OK,
• 5:53
  so inside a specific project workspace, you keep
• 5:56
  everything nicely grouped together. Yeah, exactly
• 5:58
  like stacking Lego blocks of data. Nice. You
• 6:01
  keep all your related chats enclosed in one single
• 6:03
  place. You keep your relevant files and instructions
• 6:06
  right there beside them. This specific architecture
• 6:09
  gives the AI much more useful targeted context.
• 6:12
  Right. When you come back tomorrow, the AI knows
• 6:14
  exactly where to look. With Project AI memory,
• 6:17
  you actively separate your different types of
• 6:20
  work. So you can keep the research for one presentation
• 6:22
  totally isolated? Yeah. Or you can use a project
• 6:25
  for a single complex marketing campaign. Exactly.
• 6:28
  You could dedicate one workspace to a specific
• 6:30
  client engagement. OK. And the AI uses those
• 6:33
  previous conversations inside the project as
• 6:36
  strict context. It references them perfectly
• 6:38
  when you start a new chat inside. By actively
• 6:41
  choosing this project -only memory setting, you
• 6:44
  create a boundary. The AI only references chats
• 6:48
  from inside that specific walled garden. It completely
• 6:51
  ignores saved memories or conversations from
• 6:53
  the outside world. That gives you a significantly
• 6:56
  cleaner, much more reliable boundary. Right.
• 6:59
  You use this when you want one project to stay
• 7:01
  completely separate. It prevents your weekend
• 7:04
  travel plans from bleeding into your work deadlines.
• 7:07
  We should walk through a quick test for this
• 7:09
  project memory, too. We should, yeah. To test
• 7:11
  this properly, you have to change your approach
• 7:13
  slightly. You do not tell the AI to explicitly
• 7:17
  remember things globally. You completely ignore
• 7:20
  that level one command here. Exactly. You simply
• 7:22
  work completely normally in one of your project
• 7:25
  chats. Okay. Then you check what the AI carries
• 7:27
  forward into another chat. But that new chat
• 7:30
  must remain strictly inside the same project
• 7:32
  workspace. Got it. So in that very first chat,
• 7:36
  you paste a simple status update. You say you
• 7:39
  are currently working on a new presentation.
• 7:42
  You state that version one of the presentation
• 7:44
  is officially finished. You remind the system
• 7:47
  the presentation is on October 6. Right. And
• 7:50
  you state that your very next step is doing the
• 7:52
  visual polish. You also add that Tim Cookie and
• 7:55
  John Turnip are confirmed attendees. Then you
• 7:58
  ask the AI to help you improve those slide headlines.
• 8:01
  You want to finish that before you move to the
• 8:03
  visual polish. Exactly. After the AI responds
• 8:06
  to you, you test the internal memory. You start
• 8:09
  a brand new chat inside that same exact project.
• 8:12
  Right. You ask the AI to tell you where you are
• 8:14
  with the presentation. You ask what specific
• 8:17
  task you should be working on next. You also
• 8:19
  ask it to list who the confirmed attendees actually
• 8:22
  are. If the walled garden works, the AI brings
• 8:25
  back the exact status. It does. It brings back
• 8:29
  the visual polish step and those specific attendee
• 8:32
  details. You can clearly see how Project AI memory
• 8:35
  carries context across chats. It does this flawlessly
• 8:38
  as long as you stay inside that workspace. We
• 8:42
  absolutely need to talk about where project AI
• 8:45
  memory fails. We do. Even inside a heavily guarded
• 8:48
  project, you cannot assume absolute perfection.
• 8:52
  You should never assume every small detail comes
• 8:54
  back perfectly every time. I have to admit something
• 8:57
  here. I still wrestle with prompt drift myself.
• 9:00
  Oh, wow. Yeah. The AI just slowly loses the thread
• 9:03
  of the project over time. It starts hallucinating
• 9:07
  details or reverting to older, outdated instructions.
• 9:10
  It happens to absolutely everyone who uses these
• 9:13
  tools extensively. It really is frustrating.
• 9:15
  The AI can still easily miss a minor but crucial
• 9:18
  update. It might reference older context when
• 9:20
  your active project changes over time. Let us
• 9:22
  say reality shifts and you suddenly change a
• 9:25
  deadline. Or maybe you need to add a brand new
• 9:27
  attendee to the meeting. You really must verify
• 9:29
  that detail when accuracy truly matters. Right.
• 9:32
  Once you notice something is wrong, you are forced
• 9:35
  to correct it. You correct the project context
• 9:37
  directly in the active chat interface. You explicitly
• 9:40
  tell the AI you need to update one project detail.
• 9:44
  So you tell it the presentation is actually now
• 9:46
  on October 30. Exactly. You forcefully clarify
• 9:50
  that it is no longer happening on October 6.
• 9:53
  With only a few active projects, you can manage
• 9:55
  these manual checks. You can usually do it without
• 9:57
  too much trouble at all. But as your overall
• 10:00
  professional workload grows... things get much
• 10:04
  harder. They really do. You have to actively
• 10:06
  monitor many more shifting project details. Those
• 10:10
  constant manual corrections inside a chat interface
• 10:13
  become really annoying. Yeah. Critical project
• 10:15
  updates will inevitably start to slip through
• 10:17
  the cracks. I hear that, but let me push back
• 10:19
  for a second. Sure. Why is managing my own system
• 10:22
  better than just letting the AI figure it out?
• 10:25
  What happens when manual corrections in these
• 10:27
  projects just become too overwhelming? You build
• 10:30
  your own file -based system to take total control.
• 10:33
  Sponsor. Let us unpack this transition. Yeah,
• 10:36
  let's do it. When the mental overhead of manually
• 10:38
  correcting AI projects gets too high, we have
• 10:42
  to stop letting the black box manage the memory
• 10:45
  for us. We have to start managing it entirely
• 10:47
  ourselves. This brings us to level three. Level
• 10:50
  three means building your own AI memory system
• 10:52
  from scratch. At this advanced level, you keep
• 10:55
  AI memory inside your own folders. You use plain
• 10:58
  text files instead of letting the AI guess your
• 11:01
  context. This setup works infinitely better when
• 11:03
  you have dozens of projects. Oh, absolutely.
• 11:06
  You need to know exactly what context will be
• 11:08
  used next. You need to guarantee this before
• 11:11
  your next deep work session begins. Some power
• 11:14
  users already build these highly advanced memory
• 11:17
  systems today. Oh, really? Yeah, they build them
• 11:19
  with specific markdown files like CLAW EDMD.
• 11:23
  They build external memory layers that keep useful
• 11:26
  context highly organized. That is fascinating.
• 11:29
  But you absolutely do not need to start with
• 11:31
  a massive complex system. No, not at all. You
• 11:33
  can begin with just one very simple plain text
• 11:36
  file. You can call this foundational file memory
• 11:39
  .md. This specific text file works exactly like
• 11:42
  a physical treasure map. I like that analogy.
• 11:45
  It acts as a map of your entire professional
• 11:48
  workspace. Let us say you are using an AI called
• 11:52
  Claude Cowork. OK. Clunk Cowork can read this
• 11:55
  map to deeply understand your workflow. By pointing
• 11:58
  the AI to a specific markdown file, you bypass
• 12:02
  the mess. Exactly. You force its context window
• 12:05
  to look exactly where you want it to. It learns
• 12:07
  exactly which projects you are currently actively
• 12:10
  working on. It learns exactly where the related
• 12:12
  historical context actually lives. And inside
• 12:15
  that memory .md file, you keep just a few critical
• 12:18
  things. Like what? You list out all of your currently
• 12:22
  active ongoing projects. You list the specific
• 12:25
  file folder for each of those active projects.
• 12:28
  You clearly state the current status of every
• 12:30
  single project. You also list the specific files
• 12:33
  Claude Cowork should read next. You list the
• 12:35
  exact files it needs when you return to work.
• 12:37
  When you want to continue a complex project,
• 12:39
  the process is brilliantly simple. Claude Cowork
• 12:42
  can simply read that memory .md file first thing.
• 12:45
  It can quickly find the exact right folder for
• 12:48
  your specific task. It can perfectly load the
• 12:51
  precise context you actually need right now.
• 12:54
  You do not have to endlessly scroll through old
• 12:56
  chats ever again. Never again. You do not have
• 12:59
  to scroll just to remember where you stopped
• 13:00
  yesterday. Each project folder can help significantly
• 13:04
  more detailed memory too. Those dedicated folders
• 13:07
  can hold your specific shifting project deadlines.
• 13:10
  Right. They can hold your important architectural
• 13:13
  decisions and your meeting notes. They hold your
• 13:15
  specific working rules and your currently open
• 13:17
  tasks. Level 3 is ultimately about regaining
• 13:21
  absolute sovereignty over your data. You can
• 13:23
  open these plain text files yourself anytime
• 13:26
  you want. You can verify exactly what Claude
• 13:29
  Cowork will use next session. We can already
• 13:32
  see this brilliant idea operating in real workflows
• 13:35
  today. Powis Huron shared a fascinating second
• 13:38
  brain system for product managers. Oh, I saw
• 13:40
  that. Yeah. He explicitly stores his professional
• 13:43
  knowledge in Markdown files for this exact purpose.
• 13:46
  He actually stores those files inside a Git repo.
• 13:49
  Git repo. A system to track changes in computer
• 13:52
  files. Exactly. He uses a master file called
• 13:55
  keynade .md for system navigation. This file
• 13:59
  helps Claude find the exact right context every
• 14:02
  single time. Bipod Sysinti recently shared a
• 14:05
  very similar highly effective setup too. I think
• 14:08
  I read about that. He uses plain markdown files
• 14:11
  as a dedicated external memory layer. Claude
• 14:14
  can read these lightweight files again and again
• 14:16
  as needed. Right. He does this instead of relying
• 14:19
  on a messy, long chat history. T -sex silence.
• 14:22
  Whoa, beat. Imagine scaling this to a billion
• 14:25
  queries. Yeah. Entire companies running incredibly
• 14:28
  complex workflows just using simple text files
• 14:31
  as a map. It fundamentally changes how we interact
• 14:33
  with these large language models. The true beauty
• 14:35
  of this system lies in the sheer simplicity.
• 14:38
  It really does. You do not have to use the exact
• 14:40
  file names we mentioned here. You do not have
• 14:42
  to strictly use memory .md or keyoludmd. The
• 14:46
  main idea is just moving important long -term
• 14:48
  context around securely. You move it into transparent
• 14:51
  files. You can actually open yourself. You can
• 14:54
  easily check and meticulously edit these files
• 14:56
  whenever you need. Specific architectural setup
• 15:00
  gives you significantly more control overall.
• 15:03
  You never have to guess what the AI still accurately
• 15:05
  remembers. You never guess which specific deadline
• 15:09
  or project decision is currently active. When
• 15:12
  something important changes in the real world,
• 15:15
  you just open the text file. Exactly. You fix
• 15:17
  the incorrect information right there at the
• 15:19
  fundamental source. If your project gets a brand
• 15:22
  new rule or a different next step, You simply
• 15:25
  save that new update directly in the right folder.
• 15:29
  And Claude Cowore can then read the very latest
• 15:31
  context perfectly. That is so clean. It does
• 15:34
  this reliably the next time you return to the
• 15:36
  project. You still let the AI handle the heavy
• 15:39
  computational lifting for you. The AI handles
• 15:42
  the heavy work of reading all those complex folders.
• 15:44
  Yeah. It synthesizes the useful context and updates
• 15:47
  your actual project progress. But your crucial
• 15:51
  memory stays inside a workspace that you completely
• 15:53
  control. You can actively catch old information
• 15:56
  before it affects your next task. You do not
• 15:59
  have to blindly rely on the AI's hidden retrieval
• 16:02
  system. How do you know exactly when to switch
• 16:04
  from project memory to a full file system? Switch
• 16:09
  when managing multiple complex projects demands
• 16:11
  absolute context accuracy. We have covered a
• 16:14
  massive amount of conceptual ground here today.
• 16:17
  We really have. We should clearly summarize this
• 16:19
  framework for everyone listening right now. Let's
• 16:22
  do a very quick practical decision matrix. OK.
• 16:24
  You do not need the most advanced file -based
• 16:27
  setup. from day one. Right. Your choice depends
• 16:30
  entirely on how complex your current daily work
• 16:34
  is. It depends on how much granular context you
• 16:36
  need to keep around. Global memory is really
• 16:39
  just for your basic everyday preferences. It
• 16:42
  is best when you want the AI to remember your
• 16:44
  broad role. It is strictly for your tone and
• 16:47
  your general writing preferences. And project
• 16:49
  memories for juggling a few distinct ongoing
• 16:51
  tasks. You use it in enclosed spaces for specific
• 16:55
  isolated projects. You want the AI to keep deadlines
• 16:58
  and status updates neatly isolated. Building
• 17:01
  your own AI memory system is for the heavy lifters.
• 17:04
  No, definitely. It is for managing many complex
• 17:07
  long -term projects at the same time. Absolute
• 17:10
  detail control is critically important at this
• 17:13
  high level. You want to read, edit and control
• 17:16
  memory directly in your folders. If your daily
• 17:19
  work is still relatively simple, start with the
• 17:22
  basics. Right. Global memory or built -in project
• 17:25
  memory is usually more than enough. But as your
• 17:27
  total number of active projects grows, old details
• 17:30
  start to matter. Yeah, they do. That is when
• 17:33
  your own AI memory system becomes incredibly
• 17:35
  useful. You can begin experimenting with the
• 17:37
  basic memory features already available right
• 17:40
  now. As your specific projects become more complex,
• 17:43
  transition to a file -based setup. It gives you
• 17:46
  a much clearer, transparent place to keep your
• 17:48
  context. It fiercely protects the information
• 17:51
  that you simply do not want to lose. Think about
• 17:54
  when you return to deep work tomorrow morning
• 17:56
  or even next week. Right. Or maybe you return
• 17:58
  to a complex project many months later. Your
• 18:01
  AI memory system should help you continue from
• 18:03
  the exact right place. Exactly. It should do
• 18:05
  this without you blindly digging through old
• 18:07
  chats again. It is all about maintaining your
• 18:10
  creative momentum and your deep focus. Pete,
• 18:13
  I want you to consider something fascinating
• 18:14
  before we go today. What if the ultimate secret
• 18:17
  to getting the most out of AI memory isn't waiting
• 18:20
  for the technology to get better at remembering,
• 18:22
  but learning to organize our own human workspaces
• 18:25
  more intentionally? Start small with the basic
• 18:28
  built -in features we discussed today. Try them
• 18:31
  out before you build your own complex Markdown
• 18:33
  maps. Thank you for joining us on this deep dive.