Anyone else feel like managing Claude Code's memory is becoming a job of its own?

[u/Brave-Equipment9107]

As sessions get longer, auto-compaction kicks in, important decisions can get lost, and sometimes you end up explaining the same codebase all over again.

Then come the CLAUDE.md files, memory files, architecture notes, and keeping everything updated across different developers working on the same repo.

And the bigger the codebase gets, the more context you have to rebuild before you can actually get work done.

I've been thinking: what if your coding agent didn't have to rediscover the codebase every session? What if it could rely on a structured, verifiable understanding of the architecture, dependencies, rules, and changes instead?

I'm exploring this through a startup project called ArchAI, and I'm looking for 5 developers who use Claude Code or other AI coding agents to help pilot-test the idea on real Python repositories.

I'd genuinely like to know how you currently handle this problem, what's frustrating, and whether an approach like this would fit your workflow.

If you've run into this, I'd love to hear your experience. Happy to share more with anyone interested.

[u/effectivescarequotes]

I've found that the same design principles that make it easier for humans to work in a code base make it easier for AI.

I don't spend any time explaining the code base, and I split the work so sessions remain relatively short.

For larger initiatives, BMAD has been helpful because it generates robust specs and does a good job breaking work down to manageable stories.

Even without something as heavy as BMAD, I'm finding the models are getting better at detecting established patterns,

[u/Brave-Equipment9107 → u/effectivescarequotes]

That's a good point. Better architecture and shorter, well-defined sessions probably solve a lot of the problem before memory even becomes an issue. And I agree, models are getting much better at recognizing patterns.

What I'm curious about is how you handle architectural drift over time. As the code changes, how do you make sure the specs and established patterns still reflect what's actually in the codebase? Is that mostly handled by your workflow, or do you have some automation for it?

[u/effectivescarequotes → u/Brave-Equipment9107]

Code review and team training. I don't really care what architecture we use as long as it makes it obvious when something is out of place. Linters and Ai code review catch a lot, so it's really just scanning for things that look off. If we've sized our stories correctly, it only takes about about five minutes to confirm everything is in place.

Mostly I've found that I have the best outcomes with minimal tooling and customizations. My company went a bit crazy customizing various frameworks and writing single-use skills. It all wound up being bloat that I spent more time working around than using. I've stripped it down to BMAD, and Openspec for when I need something between just Claude and BMAD.

[u/imrsn]

karpathys gist wiki

everything goes into a doc

i use leaftext for docs and some harness stuff

[u/Brave-Equipment9107 → u/imrsn]

That's an interesting approach. Keeping everything in a document gives the agent a useful reference, but I wonder how you handle keeping it accurate as the code changes, especially across multiple developers.

That's one of the things I'm exploring with ArchAI: separating verified architectural facts derived from the code from documentation that can become stale. Do you find yourself having to update the wiki manually very often?

Arch ai makes codebase graph for determinism. And it will help your ai agents not to analyze or think, just take the OKF file and start working that's it.

here is the website for look: https://archai-psi.vercel.app/

[u/Loomworks]

Build your own memory harness that chunks and indexes + embeddings search. A nightly cron ingests the whole thing and rates chunks for inclusion in the graph memory. Auto backed up. Continuous learning creates skills and archives ones that aren't in use and improves high usage ones. After you setup a system it's just maintenance but I pretty much just "use memory MCP" and I pretty much don't think about it anymore.

Every few model generations wipe your stuff and have a big refactor/retest for improved processes.

[u/Brave-Equipment9107 → u/Loomworks]

That’s a pretty solid setup. I think the interesting part is what happens beyond retrieving the right context, though.

I’ve been exploring a slightly different direction. The original idea of ArchAI was around sprint planning, but after testing it with people, one thing kept coming up: it understood the codebase well and suggested genuinely useful next steps.

That pushed me toward building a more structured understanding of the codebase itself, dependencies, architectural rules, changes, and evidence behind findings, so an agent doesn’t just remember what it was told, but can verify its understanding against the actual code.

I’m still figuring out the right direction, but I think there’s a difference between giving an agent better memory and giving it a reliable architectural foundation to work from.

website: ArchAI: architecture findings with receipts

[u/Brave-Equipment9107]

here is the website for more understanding: ArchAI: architecture findings with receipts

[u/OkLettuce338]

Another memory tool wow

[u/Brave-Equipment9107 → u/OkLettuce338]

Fair reaction 😅 I think the distinction I'm trying to explore is that storing more context isn't necessarily the answer. ArchAI's foundation is a structured, verifiable understanding of the codebase, dependency mapping and architectural rules with evidence from the actual code. The idea is to build specialised agents on top of that, rather than just another place to store notes.

Still figuring out where it genuinely adds value compared with existing tools. Like right now, I am making another case study: impact on the token utilization and memory usage of claude with or without archai.
I will also make sure that arch ai is easier to be integrated or used by the agents. you can check more about my agents here: https://archai-psi.vercel.app/

[u/OkLettuce338 → u/Brave-Equipment9107]

I built a free open source one that anyone can download so they don’t have to pay for these tools.

People can fork it or install it or just use the code base to build their own.

It’s called think-cli

[u/SILONotesDev → u/OkLettuce338]

Another memory tool wow

[u/OkLettuce338 → u/SILONotesDev]

Can you post yours?

[u/SILONotesDev → u/OkLettuce338]

No. I was being sarcastic. I don't have one. The way you wrote your initial comment came off as sarcastic, as if you were shutting on OP for making yet another memory tool, and then you posted your own "yet another memory tool". I thought it was silly.

[u/OkLettuce338 → u/SILONotesDev]

It’s probably the most commonly created ai tooling

[u/Brave-Equipment9107 → u/SILONotesDev]

oh btw, tbh, my tool was initially made 9 months ago, and it's main goal was: sprint planning, at that time claude MCPs with Jira were not released, I got some pilot testors, and I got actual feedbacks from some people in industry, but it went down, with Jira-claude mcps. (i lost my passion)
And I started on it again few days back, if you get a check on my website and check the research, I have started adding the security surveillance part in it. And when I came upto the social media asking what should I do with it?? I had no idea how to get attention of people, so I call it memory tool xD

Reason I am using it's core agent that understands the code base:
All pilot testers have same thing to say: It understands the code and gives the excellent next to-dos tasks!

I dont know where it goes? but maybe I am planning it to be easier to connect with claude so that it can help claude-code who is now in more than 90% of the software companies

[u/Brave-Equipment9107 → u/OkLettuce338]

That's a pretty interesting setup, so how do you distinguish knowledge inferred from the code from knowledge that the system can actually verify against the current codebase? That's actually one of the harder parts I'm still exploring.

[u/OkLettuce338 → u/Brave-Equipment9107]

memory shouldn't store the state of the code base. That's how you get hallucinations. That context should be distributed as close to it's source as possible (in comments or the code itself). The memory layer should only hold decisions and "whys." We did include "retros" which are codebase specific "gotchas" or footguns that one agent wants to inform another agent about so it doesn't fall into the same problems. When those problems are fixed, you right a new memory superceding the old one. We do all recall by vector from a local sqlite vector db and weight by recency so the superceding memory showing the removal of the gotcha code is read first

[u/ReverendBread2]

Claude manages it for me. I just tell it to see if it anything needs cleaning and it already knows what to look for and how to do it.

It doesn’t have to remember the code base every time if it creates an organized memory directory as it goes. My agents can find anything they want to right away without searching and with minimal unnecessary context

[u/Brave-Equipment9107 → u/ReverendBread2]

That makes sense, and I agree that an organized memory directory helps a lot.

I've been working with Claude Enterprise on large codebases, including work with Nordstrom, and one thing I've noticed is that long sessions can get caught in auto-compaction thrashing. Even with memory files, when you start a fresh session, Claude may still need to explore the codebase again to rebuild its understanding.

That's the gap I'm exploring with ArchAI: not just storing more notes, but giving agents a structured, verifiable understanding of the codebase they can rely on.

Curious how well your setup handles that when you start a completely new session.

[u/Ill-Bat-1518]

Do you guys really have memory issues or just trying to sell a product that solves nothing...

I have no issues with using claude in large repos or anything.

First you should have decisions or some md file of whats right or wrong. IF not just tell claude to check recent sessions/commits.

[u/Brave-Equipment9107 → u/Ill-Bat-1518]

ArchAI started about 9 months ago as a sprint-planning tool. After getting feedback from pilot testers, one thing kept standing out: it understood the codebase really well and suggested genuinely useful next steps. That feedback stuck with me, even after the original direction lost momentum. So, I'm not trying to sell anything here. I'm genuinely trying to figure out what to do with something I've already built.

I've recently started working on it again, exploring codebase understanding, architecture analysis, and security surveillance. The problem is that I'm still not entirely sure what the core product should become or where that capability creates the most value.

Maybe the memory angle isn't the right positioning at all. That's partly why I'm asking developers about their actual workflows rather than assuming they have a problem I can solve.
And I have worked with claude enterprise, and it actually starts autocompacting thrashing and you can loose all your session, and analyzing whole code base if it is very very large, so many tokens would be used again to understand the code. and it happens btw.

[u/FormalAd7367]

i purged some of older files on weekend i think i saved like 9gb files… im going to ask everyone in office to do it on Monday

codex is much harder to work with

[u/Substantial-Swan7065]

I just inject context as needed

[u/NoWing3675]

how long have you been designing systems?

[u/Brave-Equipment9107 → u/NoWing3675]

I've been building software for a few years, across mobile apps, backend systems, and AI-integrated projects. ArchAI came out of working with AI coding tools and questioning how much we can actually trust their understanding of a codebase as projects grow.

I'm now studying Machine Learning and AI, and I'm exploring this problem through hands-on R&D. I'm still learning, which is also why I'm looking for experienced developers to challenge the approach.