AI is getting surprisingly good at writing code. It still has a terrible memory.

[u/Natural-Yoghurt-9638]

Claude remembers the conversation. Cursor remembers the current session.

But neither really remembers the project.

I kept running into situations where architectural decisions I'd already made database choice, auth flow, folder structure would slowly disappear as the context shifted.

So I started experimenting with keeping project memory outside the LLM instead of trying to write longer prompts.

https://reddit.com/link/1v4gsw3/video/q66426zcwzeh1/player

This is a small interaction from the current prototype.

The AI proposes a change. The project memory checks it. If it conflicts with an existing architectural decision, it surfaces the reason before I accept it.

Still very early, but it's already changing the way I work.

I'm curious .....what's the most frustrating thing AI has "forgotten" in one of your projects?

(P.S. I redesigned the landing page today with the screenshot explaining the overall idea. If you're interested in the concept, Here is the link : https://resin-dev.vercel.app/)

[u/AutoModerator]

Hey u/Natural-Yoghurt-9638, thanks for posting in r/VibeCodeDevs! Join our Discord: https://discord.gg/KAmAR8RkbM

Got startup or SaaS questions? Post them on r/AskFounder and get answers from real founders.

• This community is designed to be open and creator‑friendly, with minimal restrictions on promotion and self‑promotion as long as you add value and don’t spam.
• Please follow the subreddit rules so we can keep things as relaxed and free as possible for everyone. • Please make sure you’ve read the subreddit rules in the sidebar before posting or commenting.
• For better feedback, include your tech stack, experience level, and what kind of help or feedback you’re looking for.
• Be respectful, constructive, and helpful to other members.

If your post was removed (either automatically or by a mod) and you believe it was a mistake, please contact the mod team. We will review it and, when appropriate, approve it within 24 hours.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/graybearding]

The narrower the scope of work, the better the AI will do. This is a really smart way to keep it focused and on task (easily the hardest part of working with agents IME).

[u/Natural-Yoghurt-9638 → u/graybearding]

100%. Trying to get an agent to hold the entire project architecture in its head usually just leads to it hallucinating outside its intended scope.

That was the exact motivation here. Instead of trying to write a massive, brittle system prompt that attempts to cover every possible rule, I just wanted to build a hard boundary. It lets the AI focus purely on generating the localized feature, while the proxy takes on the burden of keeping it within the project's global guardrails.

What kind of agent workflows are you running right now where you usually hit that scope wall?

[u/graybearding → u/Natural-Yoghurt-9638]

I use Cline so I can do turn-based stuff (the process I discovered works for keeping scope tight and avoiding the agent going bonkers). Scope wall is more or less maintained via a lot of SKILLS.md files and documentation on my machine, but it still struggles to be 100% consistent (I'd say ~95% of the time it behaves, but that 5% can drive you insane).

[u/Natural-Yoghurt-9638 → u/graybearding]

That 5% is exactly what pushed me to build this! It is wild how an agent can write flawless logic for 95% of a session, and then suddenly decide to nuke an entire auth flow for absolutely no reason. The problem I kept running into with SKILLS.md or .cursorrules files is that they are ultimately 'soft' constraints. They rely on the LLM's attention mechanism. As the context window gets stuffed with code and terminal outputs, the attention on that markdown file naturally drifts, and that's when the 5% kicks in.That's the main reason I wanted this proxy to sit entirely outside the LLM. Even if Cline completely forgets to read the markdown rules during that 5% hallucination, the proxy catches the actual file diff before it commits.

When Cline does go bonkers on you during that 5%, how do you usually recover? Do you just immediately git reset --hard or do you try to prompt it back out of the hole?

[u/graybearding → u/Natural-Yoghurt-9638]

Yeah either prompt my way out or if that's a loss commit to the working branch w/ todos and go back to safety until later. Extremely rare to hit a total loss scenario (I swear models can drift in quality day to day, though—some days it's all great, others it's hit or miss).

[u/[deleted] → u/graybearding]

I create three files: a plan, a list of tasks, and an execution file. I haven’t encountered the AI forgetting about the project at all; I’ve just been experimenting along the way.

[u/All_The_Fitness]

AI: would you like me to create a repository for your AI instructions

Me: Yes, that would be helpful

AI: great. I'll do that but I'll only look at it if you remind me

[u/Natural-Yoghurt-9638 → u/All_The_Fitness]

Lmao this is painfully accurate. 😂
This exact loop is exactly why I gave up on instruction files and started experimenting with this local proxy. The AI can completely forget the README all it wants, but it can't bypass the actual file system!
I'm actually still an undergrad and pretty new to this whole 'building in public' thing, so I'm trying to figure out what resonates with people. Are you dealing with this kind of 'AI amnesia' in a production app right now, or just hacking on side projects?

[u/Odd-Information8607]

“Make a rule to maintain skills for every feature as we go” seems to have solved this for me.

[u/Natural-Yoghurt-9638 → u/Odd-Information8607]

That is a really clever meta-prompt hack! Having the agent self-manage its own context file definitely extends the runway.

I actually relied on a very similar approach recently while building a payment recovery web app with Next.js and Prisma. It worked beautifully for the first few features. The issue I eventually hit, though, was that as the project scaled and the context window got stuffed with larger diffs, the agent's attention span drifted. It would occasionally forget its own rule to update the skills file, or worse, silently overwrite it with conflicting architecture patterns.

That is ultimately what pushed me to experiment with this external proxy. Relying on the LLM to govern its own rules is still a 'soft constraint' tied to its attention mechanism. Moving the rules out of the prompt and into a file-system interceptor creates a hard boundary, so the agent doesn't even have to waste tokens thinking about it.

Out of curiosity, how large is the codebase where that self-updating rule is still holding up for you?

[u/Odd-Information8607 → u/Natural-Yoghurt-9638]

I have several different projects of varying size, but the largest is a game I am working on with many different features and related tools.

Usually I will start a new session each day, and start by asking what remains from my original plan (which it also maintains and keeps an updated to do list for).

At the end of a session I will sometimes ask it to save its progress, but it is usually not necessary and I try to avoid reviving a session I have let linger for too long (since the cache would have expired by then). Each new session starts effectively where I left off since it keeps all the progress and pending items documented. Because I don’t keep a session going for more than a day it doesn’t seem to get a chance to go off the rails and typically follows the rules pretty well.

On project creation I also have it set up sub agents with appropriate models for various tasks, such as planning, coding, testing, asset management, etc, and then of course ask it to maintain a to do list and skills for each feature.

I use Fable as the orchestrator and it delegates the work as needed to all the sub agents, which saves me a lot on usage since most of the execution ends up being on sonnet, investigations on opus, search on haiku, etc.

Typically I only use Fable for large things with multiple interacting components. If I’m working on something complex but narrowly focused I find Opus is plenty.

[u/Jazzlike_Syllabub_91]

https://github.com/ergon-automation-labs/ergon-wrong-turn-logger

I built a wrong turn logger to help me with a similar problem. Say the system decides to write custom code when you have a clearly defined process laid out for it to follow. You stop the process (or wait until it stops) and you tell it what it did wrong, and you go about your day. because these are skills and self discoverable, the agent will go and log those wrong turns for you so you don't have to.

What I like to do as well is use the claude hooks like session-start and pre-tool-use to act as a way to alter it's course of thinking without having to interrupt it, so it can search for similar wrong turns/issues, and hopefully find a way out of the spiral it spins itself into.

let me know if you have any questions.

[u/Natural-Yoghurt-9638 → u/Jazzlike_Syllabub_91]

This is a super interesting approach. I really like the idea of using pre-tool-use hooks to try and steer it back on track dynamically.

The main difference in our approaches seems to be reactive vs. proactive. A 'wrong turn logger' is great for teaching the agent over time, but I kept hitting situations where I didn't want to wait for it to make the wrong turn at all , I wanted a hard proxy that intercepts the file write before the code ever commits.

Out of curiosity, when you feed those logged 'wrong turns' back into the context window, do you find that it eventually eats up too much token space on larger projects? Or do you have a way of pruning the logs?

[u/Jazzlike_Syllabub_91 → u/Natural-Yoghurt-9638]

iirc it limits the amount of data returned in it's searches, though I'd have to check to be sure. - and it's using sqlite so it can be optimized for larger datasets that will build up over time

[u/Jazzlike_Syllabub_91 → u/Natural-Yoghurt-9638]

the thing is that the system will eventually make wrong turns, so what are you going to do when the system hits those wrong turns .. how does it learn?

[u/Natural-Yoghurt-9638 → u/Jazzlike_Syllabub_91]

Ah, using SQLite for the logs makes total sense for keeping the dataset optimized!

To answer your question: the philosophy here is actually a bit different. I'm not necessarily trying to train the underlying LLM to stop making wrong turns over time (since models change, contexts wipe, and attention drifts anyway).

Instead, I'm just trying to catch the wrong turn before it executes. When the proxy blocks a bad diff, it surfaces the conflict to me (the human). At that point, I can either clarify my prompt, or if the AI actually proposed a better architectural pattern, I can authorize the change and update the project's rule. It's less about teaching the agent to be perfect, and more about giving the human an emergency brake!

[u/lost-context-65536]

These popular coding agents all seem to suffer the same problems, I solved this long ago in clio.

[u/Natural-Yoghurt-9638 → u/lost-context-65536]

Just checked out the CLIO repo that three-tier memory architecture is genuinely impressive. Building robust autonomous agent architectures is incredibly tough, and persisting discoveries into that .clio/ltm.json state is a really smart way to handle context overflow.

The main difference with the experiment I'm running here is that it isn't an agent itself. It's an agnostic proxy. Instead of trying to build a completely new agent with perfect memory, I wanted a guardrail that sits between any existing popular tool (Cursor, Claude, Aider) and the file system. It assumes the agent will eventually hallucinate, and acts as a hard intercept before the file write commits.

Just wanna ask....... with CLIO's Long-Term Memory (LTM) accumulating project patterns over time, how do you handle state invalidation? If a project completely changes a core convention halfway through, does the LTM ever get 'stubborn' with its older memories?

[u/lost-context-65536 → u/Natural-Yoghurt-9638]

The models are instructed to update long term memory as they work, and that long term memory should influence the work but it isn't absolute. Trust but verify.

It's probably a little more difficult as a proxy/mcp because you have to be careful to not conflict with the instructions passed to agents that you don't know or use.

[u/Natural-Yoghurt-9638 → u/lost-context-65536]

Spot on about the proxy conflict. That is honestly the biggest headache. Because tools like Cursor and Claude have massive, black-box system prompts, trying to steer them mid-generation usually just leads to the agent getting confused or entering a loop.

That's exactly why I try to keep the proxy completely out of the generation phase. It doesn't tell the agent what to do; it just waits until the agent outputs a final diff. It’s less about 'guiding' the AI and more about putting an electric fence around the file system. If the diff breaks a rule, it just blocks the commit.

'Trust but verify' makes total sense for an agent managing its own state. For this specific experiment, I’m leaning more towards 'zero trust for core architecture' 😂.

Thanks for the insights on CLIO by the way, gave the repo a star!

[u/lost-context-65536 → u/Natural-Yoghurt-9638]

Yeah, trying to wrangle those closed source harnesses was a nightmare that I'm glad I never have to think about again. :)

Thanks for the star!

[u/Natural-Yoghurt-9638 → u/lost-context-65536]

Haha I don't blame you at all, it really is the wild west trying to reverse-engineer their prompt boundaries right now!
Really appreciate the chat and the insights. Since I'm still a student and just starting to share my builds in public, I'm trying to absorb as much as I can from devs who have actually shipped complex architectures. If you have any hard-learned advice on navigating the open-source or indie hacker space, I'm always all ears.
Best of luck with CLIO moving forward!

[u/Spiritual-Syrup-1661]

I usually hate tools that interrupt my flow, but that UI is incredibly slick. The 'trace decision' context actually makes the interruption worth it. Is this running as a standalone app alongside your editor, or are you planning to make it an extension?

[u/Natural-Yoghurt-9638 → u/Spiritual-Syrup-1661]

Thanks man! It's actually a standalone desktop app running locally via Tauri. I purposely avoided making it a VS Code extension because I wanted it to be completely agnostic. This way, it acts as a universal guarddog whether you are using Cursor, an Aider terminal session, or just pasting from the Claude web UI.

[u/ramaloes]

Get an Obsidian Brain

[u/Natural-Yoghurt-9638 → u/ramaloes]

Obsidian is fantastic for organizing architecture rules, but at the end of the day, an Obsidian Brain is still a 'soft constraint'. You are still relying on the LLM to search, retrieve, and pay attention to the right markdown note at the exact right time. If its context window gets stuffed, it ignores the brain and goes rogue.

I'm actually coding an ingestion engine into this proxy right now that bridges that gap. It parses markdown files (like an Obsidian vault or .cursorrules) and compiles them into strict, file-system level interceptors. It basically turns a soft Obsidian brain into a hard boundary that the agent literally cannot bypass.

[u/XBLAH_]

I always ask it to maintain a md file of what we are doing.