Last time I talked about giving your AI assistant an actual memory. Today I’ll show you how to set it up, and here’s the best bit: you barely have to write anything yourself. I didn’t want a new note-taking tool, I wanted someone else to take notes for me.

The whole system runs on markdown files and folders. That’s it. But the magic is that Claude (or ChatGPT, etc) does the heavy lifting for you.

**Pointing out the obvious:**
This whole setup assumes you have access to an LLM/AI client, and may make use of some features which are paid-for. I haven't tried this on any of the free plans yet - so please let me know if you do!

First Things First: The Setup

Before we dive into the fun stuff, you need a way for your AI to actually read and write files on your computer. This is where most people get scared off, but it’s super simple.

I use Claude Desktop with an MCP (Model Context Protocol) tool called Desktop Commander . I won’t go into what MCP is , or how to install one (there are good instructions for Desktop Commander on their website). Suffice to say that MCPs extend the functionality of your LLM client.

Once the tool is installed, Claude can now:

  • Read files from your computer

  • Create new files & directories

  • Search folders and files for specific patterns

  • Update existing documents

The setup takes just a minute or two, and then you’re cooking with gas.

How This Started

I didn’t sit down one day and decide to build an entire memory system. It evolved from a simple problem.

I had meeting transcripts or summaries from Zoom. I had a growing list of technical and strategic documents to read.

So I started doing this:

  • Export meeting transcripts from Zoom/Teams/whatever

  • Drop them into Claude

  • Prompt: “Please read these meeting transcripts and create individual summaries, then write them to my AI-Context folder following the pattern ‘YYYYMMDD-A-brief-description-based-on-meeting-context.md’”

That was the beginning. And yes, I’m one of those people who says please and thank you to the machines. 😇

The Simple Structure That Emerged

After a few days of having Claude process meeting transcripts and docs, I noticed patterns. Some summaries were about team dynamics. Others were project updates. Some captured strategic decisions.

So I asked Claude to create folders according to what it recommended based on the files created to date. Then to move all the files into the appropriate places:

`AI-Context/
├── Meeting-Insights/
├── Team-Knowledge/
├── Project-Insights/
├── Decision-History/
└── Strategic-Documents/`

Nothing fancy. Just buckets that matched what my “memory” already contained.

It was about now that I realised I wanted to start enforcing some structure. So I modified the project instructions (which are like a system prompt for Claude Desktop) with stuff like the expected filename format:

20250704-Team-Planning-Session.md

Starting with the date means everything sorts chronologically. More importantly, it creates temporal context. When I ask about “our infrastructure decisions”, Claude doesn’t just know what we decided - it knows when, what led up to it, and what happened next.

Your First Memory (The Lazy Way)

Want to try this? Here’s the laziest possible start:

  • Set up Claude Desktop with MCP (or your preferred AI client with file access)

  • Create an “AI-Memory” folder somewhere sensible (I limit the MCP’s access to only this parent folder to ensure it can’t do anything unexpected)

  • Find a recent meeting transcript or important document

  • Give it to Claude with this prompt:

“Please read this document and create a summary focusing on key decisions, action items, and important context. Save it as a dated markdown file in my AI-Memory folder.”

That’s literally it. Claude does the work.

What Actually Goes in These Files?

When I started, I’d give Claude specific instructions about what to capture. Now it’s mostly been rolled up into context or instruction files, but here’s what works:

For meeting summaries:

  • Who attended and their roles

  • Key decisions made

  • Action items and owners

  • Unresolved questions

  • Important context or background mentioned

For strategy documents:

  • Core objectives

  • Key stakeholders

  • Success metrics

  • Risks and dependencies

  • Timeline markers

The beauty is you can iterate. Start simple, see what’s useful, adjust your prompts.

Making Connections

So far we’ve got some files on our filesystem, but this isn’t actually a “memory” system since you’d have to get your AI to ingest all files before each conversation.

Instead what I started doing was getting Claude to read all files each week or so, and create “memory summary” files which I then loaded as Project Knowledge within the Claude Project (essentially persistent context that Claude always remembers between conversations).

This type of system can be slowly improved (and the best bit is you can ask the AI to both recommend improvements, as well as implement them!). Below is an example of an instruction contained in a much larger instruction file, just to give some flavour:

`Scan the AI-Memory/Curated directory for new files since the last memory update. Create a manifest of files to process and an update plan. Store the results in a new dated directory `/AI-Memory/Working/YYYYMMDD-memory-update/` with files: `scan-manifest.md` (list of new files found, template located at `/AI-Memory/Working/scan-manifest-TEMPLATE.md`) and `update-state.json` (tracking progress, template located at `/AI-Memory/Working/update-state-TEMPLATE.json`).`

The Compound Effect

Here’s what I didn’t expect: after about a month, the system became genuinely indispensable.

Not because of any single document, but because of non-obvious connections it would start highlighting unexpectedly.

These insights come from having context that spans time. It wasn’t about any individual note, but rather about the connections it could identify over time.

Building the Habit (Without the Hassle)

The reason most knowledge management systems fail? They require too much discipline. This doesn’t.

After every important meeting, I spend 30 seconds dropping the transcript into Claude. After reading a strategy doc, same thing. Contract review? Technical design? Team feedback? Into Claude it goes.

I still keep some notes (but mostly because old habits die hard). More and more though I find myself just feeding the machine and letting it build out a “memory”.

What’s Next

Once you have a few dozen files spanning a few weeks, the system comes alive (not literally, not yet 🤖). You start having conversations with Claude that assume context. Instead of explaining everything from scratch, you jump straight to: “Given what you know about our platform strategy, what are the risks in this new proposal?”

Next post, I’ll show you how the system evolved - how I added automation, created reusable templates, and built commands that made it even easier to use and a little more consistent.

But for now, just start. Create that folder. Process a few documents. Give your AI something to remember.

The magic isn’t in the technology. It’s in figuring out how to use the existing tools in more interesting ways.

Cheers, Dave

Also in this series: