u/krk2183

Hey everyone,

If you’re using agentic AI platforms or web-based AI tools (like Claude or Bolt) to build your startup or prototype, you’ve probably hit the point where after a long session, the AI completely forgets your project layout and recreates errors you fixed an hour ago.

Not only this wastes time, but it also kills momentum and burns through token costs.

To fix this for my own workflow, I built Remora. It’s a simple webhook tool that takes your essential project details, compresses them, and saves them directly to GitHub or the AI's memory so your code structure never gets lost.

The early tester registration is live now and I'm looking for early founders/builders to test it out and give feedback.
For early testing the tool will be completely free of charge

You can join the early waitlist here: https://remora-jade.vercel.app/

We’ve all been there: Your auth and DB work perfectly. You ask Bolt for a simple layout change, and it suddenly wipes out your database schema or spins in a circle trying to fix the same console error over and over.

Boom - 10 million credits gone in an hour.

This isn't a bad prompt issue. It's Context Poisoning. Feeding error logs back into the browser chat anchors the AI's attention onto its own failure path, completely destroying its debugging efficiency.

Local terminal hacks don't work inside cloud sandboxes. So, I built a zero-config, cloud-native circuit breaker.

It connects via a GitHub webhook. When Bolt loops out, you drop the error into a web dashboard. It strips the noise, generates an immutable negative constraint file, and silently commits it to your repo. Bolt pulls the update on the next prompt and is structurally barred from repeating the mistake.

Testing it on complex loops tonight. What specific integration (Stripe, Supabase) is draining your credits right now?

Has anyone else noticed that Cursor Agent/Composer starts completely self-sabotaging around prompt 15 or 20 in a deep refactor?

You can be deep in a complex feature, and it will suddenly rewrite a completely working, unrelated file or entirely ignore your .cursorrules parameters.

The structural reason is caleld Context Overload Drift. As your active chat window grows, the attention heads anchor heavily on the recent failure logs you've pasted. The weights shift away from your system markdown files, causing the model to silently "forget" core repo constraints to satisfy the immediate query.

Most current workarounds are local bash scripts or manual .cursorignore tweaking, which get tedious on large codebases.

I have been testing a cloud utility that bypasses the chat window entirely. It uses a Git webhook to dynamically rewrite core repo rules directly in the file tree the millisecond an agent hits a recursive loop error twice. Because the boundary conditions are inherited via the repository structure on the very next call, it forces alignment without bloating your chat context or burning your fast token tiers.

I am running a few optimization tests on larger project trees tonight. What stack are you guys tracking your biggest token drains on right now?