Create persistent feature, spec, and other memories in Claude Code

Hi, I'm Alex Andervile and today I'm going to take you through something a little bit different, which is how we and our development team use the memories feature to create persistent memories in Claude Code Code X and the other things we're using in our development process. Now, a lot of development teams we speak to are starting to run into this. They've been transforming their SDLC processes. They've gone from maybe using basic LLMs to treating AI more seriously in the development process. And you start to run into where you're going to store a lot of stuff.

And what I mean by that is we still have documentation for features and that belongs in the repo. But once we're using agents more seriously, we start keeping track of the decisions that have been made and harnessing them better. And where do we put that? At some point you end up with hundreds of different markdowns in the repo that you have to maintain and don't make sense. One of the other things we like to do is keep track of all the bugs that have been resolved so that we can look at them, see what's common, maybe we need to change the process or scan through them every week.

So, to jump straight in, what I'm going to do is I have Aisle open here and I'm going to go to memories. I'm just going to create a new folder here. We could call this, you know, development documentation, for example. And it's up to you. I'm going to turn on searchable by AI because I prefer a vector search to get some deeper results.

Once this folder has been created, all we need to do is press settings here. And if you didn't know, any memories folder you can actually create an external MCP that you can use in other tools, Claude Code, Cursor, Claude, ChatGPT, it doesn't matter. So, I'm going to press add a connection here. You can actually create several. And I won't scroll all the way down.

Uh it's okay, we'll just delete this later. Uh so that you can basically copy-paste this into your settings. You'll see there instructions for different tools here and how that you would deal with adding it. Once this memory server has been added, it's really easy. I'm actually just going to toggle over now to a terminal window that we have lined up in a demo environment with Claude Code.

And this is just thinking about our task SDK and maybe trying to add some better date stuff. So, I'm going to see, you know, let's add this, you know, little feature here and press enter. And now that this memory server's been added, and obviously there's a little bit of system prompting involved, it's actually going to go through and search that IO memories folder first to see if there's any relevant documentation that's going to help it solve that feature. One of the things we do is we actually allow agents to write to these folders, to write updates. And if you've seen any of our memory videos before, you'll note any changed to memories versions.

So, you can go back and see what's been changing over time. Now, to perhaps help you visualize as this is running, I'm going to click back and show you some of these folders. So, this is actually hooked up. This is all demo data here to an IO features demo folder that has some, you know, basically spoofed documentation about our features and what we'd be having the agents track. So, you can see we have this basic, you know, agent-written documentation here in terms of what is the task SDK, you know, what is it, how does it work, and what are some references.

Uh, I can't explain to you how useful this has been through the development process to have agents basically be allowed to self-document things that they find interesting and then be able to search it themselves later across different code sessions, across different developers. And it kind of becomes this self-documenting engine. Uh, the honest answer is there's probably 10% of crap in here that we don't need, but it's much better to have all of this than to not as we're having agents go through and re-solve the same problems uh quite repeatedly. And you just don't have time to prompt through everything correctly. To give you another example, we often go through and have an agent, you know, at the end of a feature write a blog.

And I like to have a little bit of fun and tune it to roast me at the end. What did I do well? What didn't I do well? If you're laughing about me, what would you say? And it starts to write these really nice reflective blogs in terms of, you know, what did I do?

What made this task harder than it looked? What did we do that we're not proud of? And how did the code base screw you up? And the amount of times that I've gone through these blogs and I've then just started another session saying, "Why don't we fix this properly?" has been an incredibly useful reflective loop while keeping the agent that I care about on target. So, it's a very short video here, but hopefully what you're following is that you can come here, create a bunch of memory folders, use them to store things like feature documentation that an agent is going to self-document as it's working on a feature over here, uh any bugs that it's finding, uh even, you know, things like the roasting blog, and it lets you start to build an agent that has persistent memory across developer sessions, and it even doesn't matter if you start moving from Claude Code to Codex.

And you might be thinking, "Why don't we put all this in the repo? Docs belong in the repo." The answer is our main line docs do go into the repo, but we don't want two to 300 markdown documents of agents that have reasoned through features, but keeping and persisting that decision log and what we did on the way has really started to reward us over the last period. So, thank you for watching. As always, we're around. Uh reach out for any support.

Give us any feedback, and we'll talk soon.