I Got Tired of Explaining Myself to AI, So I Built a System That Remembers
A Note on Expertise
I'm not writing as an "expert" or claiming to have all the answers. I'm a builder sharing my journey on what worked, what didn't, and what I learned along the way. The tech landscape changes constantly, and with AI tools now available, the traditional notion of "expertise" is evolving. Take what resonates, verify what matters to you, and forge your own path. This is simply my experience, offered in the hope it helps fellow builders.
If you have ever had a long conversation with an AI agent about a real project, you know what comes next. You explain your setup. You explain the context. You explain the decision you made yesterday. You get a helpful response. Twenty minutes later, the same agent in the same session has forgotten something you told it five messages ago, and you are explaining it again.
For a while I thought this was just how it worked. It was frustrating, but it was the trade-off for using a genuinely capable tool. Then one day I noticed something. The frustration was not about the agent. It was about me. I was tired of explaining myself. Over and over. In the same session. In the same chat. About the same project.
And once I noticed that, I could not unnotice it.
The real problem with AI memory
Most people talk about AI memory as a feature. Does your tool have memory? How much? Across sessions or within them?
That framing misses the actual problem. The real issue is that every serious project has more context than any AI tool can hold. Havnwright alone is over two hundred thousand lines of code. It has architecture decisions, failed experiments, abandoned directions, user-reported bugs, deployment history, and hundreds of small choices that only make sense when you know the bigger picture.
No agent can hold all of that in its head. Even with 1M context window that is available now, which sounds like a lot until you actually fill it with a real project. Before that, I was working with 200K tokens and having to compact the conversation every thirty minutes because we had discussed so much that there was no room left to think.
And compaction is a lossy process. You get a summary. You lose the detail. The next time you come back to a specific decision, the nuance is gone.
What built-in memory does not solve
Every major AI tool has added some form of memory by now. Claude has Projects. ChatGPT has memory. Cursor has its own approach. These are all improvements. They all help. None of them solved my problem.
Here is why. The problem was not really about features. It was about ownership.
When I rely on a vendor's memory feature, I am working with whatever they decided should be remembered, in whatever format they chose, with whatever limitations they imposed. When I hit a problem, I have two options: find a workaround, or wait for an update.
I did not want either option. I wanted to be able to look at a problem, understand exactly why it was happening, and fix it. If an agent across two different projects was losing context in a specific way, I wanted to trace the cause and patch it. Not next month. Now.
So I built my own.
What it actually does
I do not want to go too deep into the internals in this post. There are layers to this system, and honestly each one could be its own post. What I can say is this, at a high level:
The agent that I work with, whether it is Claude Code or another tool, connects to a system I built. That system keeps track of everything that matters across all my projects. Not just files, not just conversations, but decisions, context, relationships, things I have already tried, things I have rejected, ongoing work, and the current state of each piece of each project.
When I open a new session, the agent does not walk into a dark room. I already talked about this metaphor in a previous post. The lights are on. It knows which project we are in, what we did yesterday, what is in progress, what is blocked, and what decisions have already been made.
When I am mid-session and Anthropic compacts the conversation to free up tokens, I do not lose the detail. My system has its own way of preserving what matters, and the agent can pull it back in when needed. A compaction that used to wipe out context now just trims the surface.
That is the short version of what it does. There are many more layers. I will get into those in future posts.
Who this is for
When I started building it, I did not know who it was for. I did not even fully know what I wanted. I was just trying to fix my own problem. As the system grew, I started to see that the problem I was solving was not unique to me.
Anyone who works with AI agents on something real runs into this. Solo founders running multiple projects. Developers working on large codebases. People using AI every day for work that actually matters. The pain is the same. You have so much context to manage that no tool can hold it all, and you end up either explaining yourself constantly or accepting that the AI is only helpful for small slices of what you actually do.
If any of that sounds familiar, this system is for you. It is not ready for public release yet. There are things I need to figure out before I can make that promise. But it is coming.
A moment that still surprises me
A few days ago I was working on one of my projects. I had a lot of tasks to do and I could not remember them all. My conversation history had just been compacted, which usually means the details are gone. I asked the agent, almost as an afterthought, "what were all the tasks we discussed?"
It came back with about twenty of them. All of them. With context. With the reasoning behind each one. Things we had decided to do, things we had decided not to do, and why.
A year ago, that moment would have been impossible. Six months ago, it would have required me to have written everything down manually, which I had tried and which had created the documentation problem I wrote about in an earlier post. Now it just works, because the system is built around the idea that nothing important should ever be lost.
I used to go to bed dreading the next morning because I would have to explain everything to the agent again. Now I go to bed curious about what the agent will tell me when I open the project. That shift from dread to curiosity is the thing I am most proud of building.
Where it goes from here
The system is not finished. It is not going to be finished for a while, because as I use it, I keep finding new things to add. Most recently, I have been working on moving from a reactive system, one that responds to what I ask, toward a more proactive one. Something that can watch across projects and surface things I should know about before I have to ask.
That is the next layer. It involves trade-offs I am still working through, including how to keep AI agents accountable for the suggestions they make and the costs they incur. Those are also subjects for future posts.
For now, the core is solid. It works for me every day, across every project. And when I say I cannot imagine going back to working without it, I mean that literally. I would not know how to run what I am running without this system holding it together.
This is part of a series about building products as a solo founder. Earlier posts cover my personal journey, why I built Havnwright, the authentication pattern that came out of building it, and what building with AI actually looks like. More coming.
About the Author
Alireza Elahi is a solo founder building products that solve real problems. Currently working on Havnwright, Publishora, and the Founder Knowledge Graph.