The argument in one line.
You can give Claude unlimited working memory by having it write and read three Markdown files (context, todos, insights) that persist across context-window resets, enabling it to process 50+ documents in a single continuous session without losing track or degrading quality.
Read if. Skip if.
READ IF YOU ARE…
- You're processing 20+ documents or files with Claude and hitting context-window limits that force you to stop mid-task or lose earlier analysis.
- A product manager or analyst who needs to extract patterns from large datasets (transcripts, tickets, emails) without manually chunking or summarizing them first.
- You work with Claude Code, OpenAI's Code Interpreter, or similar file-reading tools and want a reusable prompt pattern you can apply immediately without learning to code.
- You're running batches of autonomous AI work and need Claude to maintain coherence and reference its own notes across multiple 20-40 minute sessions.
SKIP IF…
- You primarily work with ChatGPT's native interface or web-based AI without access to file-writing tools like Claude Code or Code Interpreter.
- Your workflow involves processing fewer than 15 documents or your current context window already handles your dataset size without degradation.
The full version, fast.
AI memory limits cause large datasets to fail mid-process because context windows fill up and old information gets pushed out before work completes. The fix is externalizing memory into three Markdown files the agent maintains in a working folder: a context file storing the goal, a to-dos file acting as a checklist of every item to process, and an insights file the agent updates iteratively after each unit of work. When the context window compacts, the agent re-reads context and to-dos to resume exactly where it stopped, then continues until the checklist is complete. Apply this pattern in Claude Code with Opus set to Act mode to process transcripts, emails, tickets, or documents in unattended thirty-to-ninety-minute runs without quality degradation.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 01:38
01 · The Problem
Context window as a leaky bucket: new data pushes old data out. File-drop caps at 10-15 per chat. Concatenating into one big file still fails -- ChatGPT accepts it but only processes ~25%.
01:38 – 02:37
02 · The Solution: External Notes
Three persistent files act as memory. Write then Clear then Read back then Continue. Works with any file-capable tool: Claude Code, Codex, Gemini CLI.
02:37 – 03:52
03 · Four Components + The Cycle
Source data + Context file + Todos file + Insights file. The loop: Process -> Update Notes -> Memory Clears -> Read Notes -> Resume. 20-40 min of continuous work, quality stays consistent.
03:47 – 05:08
04 · Setting Up Claude Code
Download Claude desktop, switch to Code tab, select project folder, change Ask to Act mode, choose Opus 4.5.
05:08 – 10:20
05 · Use Case 01 -- Customer Language
Drop 50 client/prospect transcripts. Extract phrases tied to frustration, stress, fear, confusion. Full prompt shown on screen with 5-part anatomy.
10:20 – 12:18
06 · Use Case 02 -- FAQ Building
Same skeleton, different extraction. Confusion points, uncertainty gaps, how team answered, likely follow-ups. Every question represents friction that can be pre-answered.
12:18 – 13:14
07 · The Common Structure
SETUP (create 3 files) -> WORK LOOP (update iteratively, check todos before compact, re-read after wipe) -> CUSTOMIZE (goal, what to extract, what matters most).
13:14 – 14:58
08 · Same Approach, Endless Uses
Churn risk: mine client calls for complaints. Feature ideas: aggregate requests. Inbox triage: rank leads by conversion likelihood. Works on transcripts, emails, Jira tickets, documents.
14:58 – 15:26
09 · Recap + CTA
Context = goal. Todos = checklist. Insights = accumulator. Write before wipe, read after reset. CTA to next video on building apps with AI.
Lines worth screenshotting.
- Claude's context window is not memory — it is a fixed-size buffer where old data gets pushed out as new data comes in, which is why long document-processing tasks degrade silently.
- Externalizing memory into three files — a context file (goals), a checklist file (progress), and an insights file (outputs) — lets Claude resume after a context reset without losing track.
- When a context window fills, Claude reads its own previously written notes and continues from the checklist step where it left off, enabling 20-40 minutes of continuous autonomous work.
- Concatenating 50 documents into one file is a false solution — most models will claim to have processed all of it while silently reading only 25% due to their actual context limits.
- Any tool that can read and write files on the computer — Claude Code, Codex, Gemini CLI, or similar — can implement the external-memory pattern without any coding knowledge.
- The insights file accumulates outputs continuously as Claude works, so the final deliverable builds incrementally rather than appearing only when the job is done.
- Switching to Opus 4.5 for this pattern is recommended because the higher-quality model handles the note-reading and resumption logic more reliably than lighter models.
- Starting the session in act mode rather than ask mode keeps Claude working continuously rather than pausing to request permission at each step.
- The context file's role is to remind Claude of the original goal when it wakes up fresh — without it, each new context window starts from scratch with no sense of purpose.
- The three-file memory pattern requires no code, no databases, and no infrastructure — just a folder on the desktop and a well-written initial prompt.
- This pattern scales to arbitrarily large datasets because the number of loops is limited only by time, not by token count or file upload limits.
- Claude will not hallucinate that it has processed files it has not yet reached when the checklist explicitly tracks which items are complete and which are pending.
Steal the prompt skeleton.
JoeFlow Batch playbook
Any Claude Code batch job longer than 5 minutes should use the three-file memory pattern.
- Create context.md (goal + scope), todos.md (numbered checklist), insights.md (accumulating output) before starting any large batch.
- Instruct Claude to check off todos iteratively and update insights after every file processed.
- Tell it explicitly: read context + todos after every memory compaction before doing anything else.
- End every prompt with 'work through all files until complete' -- this enables 30-90 min autonomous runs.
- Apply directly to JoeFlow: session transcript mining, client call analysis, inbox lead triage, feature-request aggregation.
- The folder-selection step in Claude Code is the whole unlock -- teach this to any client who asks how to process more than a handful of files.
Terms worth knowing.
- context window
- The maximum amount of text an AI model can hold in memory during a single session — older information gets pushed out as new data comes in, causing the model to lose track of earlier content.
- externalized memory
- A technique where an AI writes its progress, notes, and findings to files on disk so it can read them back after a context-window reset, effectively giving it memory that persists across sessions.
- Claude Code
- Anthropic's command-line AI assistant that can autonomously read and write files on a computer, making it capable of processing large datasets by maintaining notes between context-window resets.
- hallucination
- When an AI model confidently generates information that is factually incorrect or fabricated — a common failure mode when the model's context is overloaded and it can no longer verify earlier details.
- concatenate
- To join multiple files or text strings end-to-end into a single, larger file — used here as an attempted workaround for file upload limits that still hits context-window constraints.
- Codex
- OpenAI's autonomous AI coding and task agent, capable of reading and writing files on a computer — mentioned as an alternative tool that supports the same externalized-memory technique.
- Gemini CLI
- Google's open-source command-line AI agent, capable of reading and writing local files, usable as an alternative to Claude Code for the same memory-externalizing workflow.
- context file
- A Markdown or text file maintained by the AI during a long task that stores accumulated background knowledge so it can be reloaded after a context window is cleared.
- todos file
- A task-tracking file the AI writes and reads between processing loops, recording what has been done and what remains — the mechanism that allows the agent to pick up where it left off.
Things they pointed at.
01:55toolCodex (OpenAI)
01:56toolGemini CLI
05:49linkPrompt template (linked in description)
Lines you could clip.
00:00
“I just analyzed 50 meeting transcripts in thirty minutes using Claude Code. And despite the name, you don't need to write any code.”
01:23
“The fix here is surprisingly simple. All we have to do is externalize the AI memory through a series of files that act like notes.”
09:13
“This AI can run for thirty minutes, forty minutes. I have seen them run up to an hour and a half to two hours for myself.”
17:24
“Every question represents friction.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
metaphoranalogystory
00:00I just analyzed 50 meeting transcripts in thirty minutes using Cloud Code. And despite the name, you don't need to write any code. Here's the problem.
00:08Every AI has a memory limit. So when you try to process large amounts of data, it loses track before it ever finishes. The trick is giving Claude a way to take notes as it works.
00:20Notes, it can read back after its memory resets. I'll show you exactly my setup and how to do this yourself, so let's get into it. Okay.
00:27So this is the problem that most of you have probably faced either in ChatGPT and Claude and Gemini fill in the blank, where the constraint that you're limited to is the size of the AI's memory. So you can imagine in this animation, we have . You can kind of understand this as the AI's memory, and it's limited in space.
00:48So it may be unintentional that the AI forgets what you've asked or goes off the rails or hallucinates, but that's just the limitations that we're working with right now. And you can really feel this when you use Gemini, ChatGPT, or Claude when you say try to drop in a lot of files. So say you try to drop in 50 transcripts.
01:03When you do this, you'll immediately realize that there's caps on how many files any model can take in a chat. Some are 10. Some are 15.
01:09So you'll have to reduce the amount of files you share. But say you try to be smart with this, and you take all these files and you concatenate them into one massive file, and you're like, okay, I'll just give you one big file. Sometimes the AI will take it, such as ChatGPT.
01:23But when it takes it, it's deceiving because it says that, oh, I processed it and I did what you've said, But oftentimes, it's only looking at 25% of what you've shared because its memory, again, is limited, so it can't look at everything. So this is a big frustration for a lot of use cases that people have. And the fix here is surprisingly simple.
01:38All we have to do is externalize the AI's memory through a series of files that act like notes. The only way that we can do this is by using a tool that allows the AI to write and read files on our computer, and there's tons of them out there. Today, I'm gonna talk about Claude Code, but you can use Claude Code.
01:53You can use Codecs from OpenAI. You can use Gemini CLI or anti gravity from Google, and a variety of others. We just need something that can write and read files on our computer.
02:02So what we're gonna do here with externalizing the memory is we're gonna have the AI write the notes out. When its memory gets cleared, it'll then go back and read those notes that it previously wrote so it can extend that working session and continue going without the quality decreasing. Okay.
02:17So my guess is if you're enjoying this, you might appreciate two more things. First off, Blow is a free thirty day AI insight series. Completely free, you'll get 30 insights in your inbox so I can apply AI to your business and your work.
02:28The second thing is if you'd like to work with me, blow our series of offerings to see if there's good fit between the two of us. Now with that being said, let's get back in the video. And the way that we're gonna do this is through four primary components.
02:38So with this process, we have a piece of data that we wanna process. So it's gonna either be maybe our entire inbox of all of our emails or hundreds of transcripts or a bunch of tickets or documents or something else.
02:49You have files you want the AI to process. Then we want the AI to create three files to extend its memory. The first file is going to act as a reminder of the goals that we initially started out with in the conversation.
02:59Conversation. That's That's gonna gonna be the context file. The next file is gonna act as our checklist.
03:04So this is gonna be basically one through 50 steps, and it's gonna check those steps off as it does it. So when its memory gets wiped and it has to start fresh again, it can look at the checklist and say, okay, I could see I stopped at, you know, point 11.
03:16I need to now move on to point 12. And then finally, we have our insights file. So this is where all the insights are gonna be stored as the AI works through all these files that it's processing.
03:25And those are the four components that we need. The next thing here is the cycle. So this is the cycle that runs in a loop.
03:30What's gonna happen is we start out with the AI processing the files. So we ask it to process the files. It's gonna update the notes that we have mentioned previously, those three files that it's gonna update.
03:39Once its memory gets wiped, because again, it's limited still, it's going to reference those notes that it wrote previously to resume working and do that indefinitely. Now, before I show you some examples of actually how this works and the benefits of the use cases, I'm gonna show you how to set this up. And the beautiful part is you don't have to know anything about terminals or code or anything else.
03:56So what you wanna first do well, since we're using Claude code, you're gonna use Claude. So you're gonna download Claude for desktop. So if you have Claude on the web, when you log in, it looks just like ChatGPT.
04:06You just wanna download this for your desktop. Once you've downloaded the Claude for your desktop, you're gonna get something that looks sort of like this.
04:14So here I have the chat on the left hand side, and I have code on the right hand side. So the chat is basically everything that you've seen before. So this is basically like a chat with ChatGPT.
04:24We're gonna select code because we want to use Claude code on our machine so it can write and read files so it can extend the memory. Once you've clicked into here, the first thing you wanna do is you wanna select the folder you wanna work in. So you're probably gonna create a folder in your desktop, and you're gonna drop all your transcripts in there or all your emails or whatever else in there, and you're gonna name it.
04:41Once you've named it, you're gonna select that folder from your browser actually, your desktop. So I'm gonna do that here. I'm gonna select let's do synthetic transcripts.
04:48And you can either do it from the drop down, which is recent, or you can go to choose from your folder, and it's gonna go to your finder or file explorer depending on the operating system you have. And it's important we have this set to local because, again, we wanna do it on our computer. After you've set that up, you then wanna go down here where it says ask.
05:02You're gonna select this. You're gonna go to act instead because we want the AI to act on our behalf continuously. And then finally, one other thing we wanna make sure is set up correctly is these three dots here when you select this.
05:13You wanna make sure you have Opus four dot five set up because this is the highest quality model currently available. And depending on the plan that you have so I have the max plan, so I have a lot of extra bandwidth I can use these models for. So if you're limited on the amount of usage you can get from the model, you can knock it down to Sonnet.
05:28And if that's if you use that too much, then you can knock it down to Haiku. But I'd recommend starting with Opus and then working your way down if needed. And that's all you need to do.
05:35All we have to do is give it the prompt and it'll do the work for us. So I'm actually show you what the prompt looks like through a few examples. So these are examples that I've seen my clients and myself get a lot of benefit from.
05:44And the beautiful part about this process is the number of examples and use cases is almost infinite. It really just comes down to the different problems and things you're trying to solve and leverage you're trying to create within your business or within your job.
05:56So the first example I'm gonna share with you here is using customer language to create marketing, ad copy, and content to actually answer the questions, the pain points, and the problems that they have through their word usage. So we're gonna drop in a bunch of transcripts for our AI. So imagine this is 50 or 60 transcripts from a bunch of prospect and client calls.
06:16We're then gonna ask the AI to extract out different types of phrases and descriptions associated to frustration, stress, fear, confusion, etcetera. And once we've extracted out all those items, we're then gonna have the AI process it. And let me show you what that prompt looks like.
06:29So this is the exact prompt that I've used time and time again. And it's very straightforward and very simple to use, and you can actually copy and paste this and use it yourself because I'll make sure that below is linked to presentation. You can copy this prompt out.
06:39Now, usually, I structure the prompt the same way every time, irrelevant of the use case. So So at the very top, we have we're setting the goal. So this is the goal for the AI.
06:48And here, we're asking the AI that I want you to analyze all the meeting transcripts in this folder. So this is important where I say this. Because remember, in Cloud Code, I opened up the folder that I care about, which is that synthetic scripts.
06:59You wanna open up the folder that you've named and say that you're actually in the folder that matters. And after that, I say I want you to basically pull out the problems, questions, etcetera, associated to those transcripts. And then I even give a a harder constraint on what actually matters for what I wanted to pull out, saying that if it doesn't cause frustration, stress, fear, confusion, then it actually doesn't count, so ignore it.
07:19So that's us setting the goal. After we set the goal, there's three key things that matter that we wanna structure into our prompt. We wanna give it context of what to do before you start, as you're working, and then finally, some additional constraints on what I want you to pull from the transcripts or the data, irrelevant of transcripts, emails, etcetera.
07:34So we'll start here with before you start. So before you start, there's three files that I need you to create because I'm not creating anything. I'm gonna have the AI do everything on my behalf.
07:42So I explicitly tell the AI to create a context file. I then say I wanted to create it in Markdown. I do that because it allows the AI to check boxes when necessary and make additional edits, but also, it's it's less heavy on the AI's memory just based off the file format.
07:56Then I tell it what's inside of the context file or what to put in it, which is primary the goal for what I want you to do. After that, then I say, okay, I want you to create the to dos file, same as a markdown. In the to dos file, you're gonna treat this as kind of like a checklist so you can track your progress.
08:10And then below that, I say I want you to create an insights file that you'll iteratively update over time as you progress through each one of the transcripts. So this is important where I state iteratively. So it's saying that I need you to do that every single time that you finish a transcript.
08:22The same thing applies for other datasets as well. So that's saying before you do anything. After I've stated this, I then move on to what I wanted to do as it works.
08:30So, again, I'm reaffirming the the importance of it iteratively updating the insight insights file. The same thing I've just said here.
08:37After that, I say I want you to check off each transcript and the to dos as you progress through each transcript. So, again, I'm reaffirming the thing that I stated here in point two. And in addition to this, I also emphasize the importance of making sure that the to dos are up to date before your memory gets wiped because the memory will get wiped as it works because remember, it's limited in space, so it's gonna get compacted, which is basically wiping away most of its past.
09:00And then after, here on the third point, after the memory gets wiped, I want you to then go back and read the context file as well as the tattoo file before you do anything else. And that's going to ground it and what its goal is and where it's currently at in the checklist.
09:13And then after this, we go down through a few points around here saying, you know, here's some specifics around what I care about when it comes to extracting information. And then finally, a really important piece down here is I say I want you to work through all the files until you're complete. So basically, keep going.
09:26Don't stop until you're done, which means that this AI can run for thirty minutes, forty minutes. I've seen them run up to an hour and a half to two hours for myself. And that's our prompt.
09:35It's very basic. And I can actually show you what this looks like in action. So this previous conversation here is one that I ran, and it ran for about twenty five minutes.
09:42And I ran it over, I think it was 15 transcripts or 10. And if I go to the very top here, if I scroll to the top, you can see this prompt here is the exact prompt I just showed you.
09:51I just copy and pasted this into here and pushed enter. And what AI did is it worked through the entire process. So it looked through all the files, it created the context file, it then created the to dos file, and it works through all the transcripts.
10:03And after it created the insights file, then you can see it's working through it. It created its to dos, and it's checking them off one at a time. And as it keeps going, if I scroll down here to the very bottom, you'll see that it finished all the to dos right here.
10:14So these are all the transcripts it processed, and it finished the insight insights file with all the insights from those conversations. And that's the overall process. It's very straightforward.
10:22Another use case we could apply this to. So that was just for customer language and content. Now we're gonna focus on FAQs.
10:28So oftentimes, when you read FAQs, they're usually based off of a small subset of questions that customers ask or based off of theory. But we can create FAQs that are grounded in reality based off of real client conversations, or another way is creating a series of objection handling FAQs for future prospects.
10:46Because I'm sure as you know and as I know, oftentimes when somebody asks a question, when they're explicit about asking that question, there's probably 10 to 20 people that didn't have the either time and or attention to ask the question. So if we answer this question effectively that came from a real client or prospect and do that either in an f o FAQ page or a landing page, we're saving ourselves time from having to answer the question for future clients and or prospects.
11:09So the process is very similar. Like I said, it's identical. Just it maps across different use cases.
11:15So, again, we have the transcripts, all the transcripts from the meetings, and or calls with prospects. And then in here, we're gonna be explicit about what we want to extract.
11:23So here, wanna extract the confusion points, the uncertainty points, gaps in understanding, etcetera. We're gonna take out all the questions. We're then gonna categorize those questions based off of topic context.
11:32We'll look at how the questions were answered by our team on the call, and then we'll even draft up any follow-up questions that either happened in the meeting or likely would occur based off of the quality of the answer our employees made. And the prompt, again, is the same. So I'm not gonna go through the entire thing since I already walked you through in detail the first one, but, again, we have the same structure.
11:50At the very top, we have the goal that we're setting. We're stating that it's inside of this folder because, again, you wanna open it inside of that folder. We have the three core components where it says, before you start, create these files.
12:00As you work, update these files. And at the end, I want you to really focus on these certain parts of the transcript and extract these out for our use cases. And, of course, at the very bottom, we have the reminder here of saying I want you to run indefinitely until you're finished.
12:13And as you can see here with this prompt and the previous prompt, there's a common structure across all of them. And that's what I wanna show here. Well, when you're setting this up, the AI is going to set up and is always gonna set up with those three files.
12:23It's gonna have the context, it's gonna have the to dos, and it's gonna have the insights. Again, the context provides the goal, the to dos is our checklist, and the insights is what the AI is adding to.
12:32After this, the AI is gonna work basically in an infinite loop until it's finished. It's gonna update the insights with its progress iteratively. It's gonna check the to dos again iteratively as it works.
12:41Right before the memory gets wiped, I want you to make sure that to dos are checked. And then after your memory is wiped, the first thing you need to do is check the context file and the to dos to understand your primary goal as well as what progress you've made so far. And then the only thing that changes, and that's custom, is going to be the goal that you've set for the AI, what you wanted to extract and where it's coming from, and then what matters most when it's doing that extraction.
13:04And that's the common structure of how we can extend the AI's memory indefinitely. And as I mentioned previously, the number of use cases is almost infinite. Here are just some others that I've seen clients get a lot of benefit from when it comes to using this process.
13:14It's mitigating churn. So maybe you have a lot of client calls you're having, and you can assess from those client calls what are the common complaints you get from clients before they actually start to churn.
13:23Another one is actually getting feature ideas for either your service and or your product. You may have a lot of clients and or prospects asking for a specific product feature and or a service that you could provide, but you never get around to it. And you can aggregate those and figure out what are the top things people clients clients are asking for, and then you can add that to your offerings.
13:40And another one that I've got a lot of benefit from is I have a bunch of emails in my inbox that either I haven't read or haven't got back to responding to, and those are a lot of lost leads. There's a lot of leads in there that if I just responded, that could turn them from a prospect into a client.
13:53So I can easily export out all my emails, have the AI assess all of the areas that could be potential leads, and rank prioritize them based off of what it thinks is most likely to be easily converted from a prospect to a client. So you can use this not just for transcripts, but you can use it for emails, for tickets in Jira, for documents, all types of things.
14:11So as a quick recap, as we've talked through, there's three primary documents we want to add iCreate to extend its memory to an unlimited format. You need the context document, the to dos, and the insights. The context is the goal.
14:22The to dos is the checklist, and the insights is what the AI is adding to. And as it works through this whole process, it's going to write the notes before its memory gets wiped. After its memory has been wiped, it's gonna read read those notes that it previously wrote to remind itself where it is.
14:36And this is going to consistently keep the quality at a high rate and not degrade or hallucinate or run off the rails. And that's it. So if you enjoyed this, as a reminder, two things.
14:46First off, Below is a thirty day AI insight series completely free. You'll get 30 insights in your inbox how you can apply AI to your business and your work. The second thing is if you'd like to work with me, Below are a series of offerings to see if there's a good fit between the two of us.
14:58Now, what we just did is actually the first step towards building with AI. Once you see how Claude can work on its own, update files, and pick up where it left off, you start to wonder, what else can I build?
15:10I made a video that shows you the exact system I use to build apps and automations with AI. No code needed, Just three documents that tell AI exactly what to build and how to build it. You could check it out right here, so go ahead and click that video, and I will see you next time, Internet.
The Hook
The bait, then the rug-pull.
Fifty meeting transcripts. Thirty minutes. Zero code. That is the opener Dylan Davis drops before you have had a chance to second-guess clicking. What follows is a clean, repeatable system for turning Claude Code file access into a persistent memory layer that keeps quality high across arbitrarily long batch jobs.
Named ideas worth stealing.
05:50list
The 5-Part Memory Prompt
- Set the goal (name the folder explicitly)
- Before you start: create context.md, todos.md, insights.md
- As you work: update insights iteratively, check off todos before memory compacts
- After memory wipes: read context + todos before doing anything else
- Run indefinitely until complete
Reusable prompt skeleton that turns any Claude Code session into an autonomous batch processor.
Steal forAny JoeFlow batch job, session transcript mining, client call analysis, inbox triage
02:45model
The Three Memory Files
- context.md (goal + scope)
- todos.md (checklist of items to process)
- insights.md (accumulating output)
Persistent external state that survives context-window resets. AI writes before compaction, reads after.
Steal forAny long-running agent task where quality must stay consistent across resets
02:38list
The Four Components
- Source Data
- Context File
- Todos File
- Insights File
Minimum setup for an externalized-memory batch job.
Steal forTemplate slide or onboarding doc for JoeFlow Batch feature
How they asked for the click.
VERBAL ASK
14:58next-video
“I made a video that shows you the exact system I use to build apps and automations with AI. No code needed. Just three documents that tell AI exactly what to build and how to build it.”
Clean bridge CTA that mirrors the format of this video (three documents), making the next video feel like a natural continuation rather than a pitch.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
