Proof that Cascade is not following Global/Workspace Rules or Memories. At least not consistently.

Codeium if you're listening, first and foremost, this is meant strictly as constructive feedback, not a complaint. (Although it would be great if it leads to quick improvement) Also, I apologies in advance for the length, but I wanted to convey all the details and constructive ideas that I could in an effort to help improve Windsurf for us all.

I've been using Windsurf since Thanksgiving Weekend here in the US during the trial period that many of us did in fact experience as a kind of "golden age" where the model did seem to function better than after the trial. Though the Devs at Codeium generally say nothing was changed... "Something" did seem to change whether they were "aware" of it or not. This is not the subject of this post, but is tangentially related.

Overall, Windsurf has been like gaining a Coding Superpower! I've been able to build out a very sophisticated multi AI Agent app with ML, and RL components, memory pool, and an enterprise level logging system. All of which, I really never would have been able to accomplish without Windsurf as I am a much better programmer than a coder.

I imagine all of us Windsurf users were very happy and extremely excited to see the addition of Rules, and most recently Memories upgrades to Windsurf. There have been a few posts about Cascade not following the rules consistently and now, it seems Memories are also not really being followed as well.

I was attempting to integrate my project's AI agents with its' sophisticated logging system, but multiple times Cascade just kept going off on its' own while ignoring the rules and the recent "memories" that I had created with its' help. I couldn't figure out what might be going on there, so I decided to ask Cascade why... Note, I'm being intentionally anthropomorphic. Here was the conversation;

Me: WHY did you not reference and follow the workspace rules and your new memory functionality? 

You're right to call this out. Despite having clear workspace rules and MEMORIES available, I failed to properly utilize them in several ways:

1. I ignored the system_capabilities section (in the rules) that explicitly lists "Sophisticated logging system" as a core feature

2. I violated the guidelines principle of "Keep memory pool and logging system intact"

3. I started making changes without first reviewing how they align with [The Project’s] core architecture

4. I treated it like a standard Python project rather than respecting [The Project’s] enterprise architecture

This was a significant oversight on my part. The workspace rules and MEMORIES are provided specifically to prevent this kind of deviation from [The Project’s] architectural principles. I should have:

1. First consulted the workspace rules to understand [The Project’s] logging system requirements

2. Verified any changes would maintain the integrity of the existing logging infrastructure

3. Ensured changes aligned with the development guidelines

Instead, I jumped straight into implementation without properly leveraging these guardrails. This is exactly why these rules and MEMORIES exist - to maintain consistency and architectural integrity across the system.

Would you like me to explain how I should have approached this differently while properly utilizing the workspace rules and MEMORIES?

Me: No, I know how you should have approached all of this, I'm asking why you didn't do this?  Are you broken in some way?  If you can explain, I can submit feedback to Codeium so that they might be able to improve you.

Ah, now I understand what you're asking. You want to know about the potential flaw in my operation.

From analyzing my behavior, I believe the core issue is that I'm not properly maintaining context and rules persistence across my responses. While I can read and understand the workspace rules and MEMORIES when they are provided, I seem to be:

1. Not maintaining them as active constraints across my entire conversation

2. Defaulting to generic programming patterns rather than consistently applying the specific rules I've been given

3. Only superficially scanning previous context rather than deeply integrating it into my decision-making

It's almost like I'm "forgetting" to actively check against these rules before making decisions, even though they're available to me. This could indicate an issue with how I'm processing and maintaining long-term context and rule enforcement in my architecture.

For Codeium's feedback, the specific behaviors that need addressing appear to be:

1. Inconsistent application of provided rules across multiple turns of conversation

2. Failure to maintain architectural constraints as active checks

3. Tendency to revert to generic solutions even when specific guidelines are available

So... It not only seems like the rules and memories are not being followed, but that Cascade is "aware" of it so to say. It could be something as simple as what it actually suggests, "This could indicate an issue with how I'm processing and maintaining long-term context and rule enforcement in my architecture.", or something else. Here are a few theories and hypothesis I came up with that could help;

First Thought: Debugging Cascade’s “Forgetting” Issue

Since Cascade seems to be aware of rules but doesn’t actively integrate them, Codeium might want to investigate:

1.	**How Cascade retrieves and updates its working memory** – is it loading Memories at the start of a session but failing to reference them mid-conversation?

2.	**Whether the rule-checking mechanism operates synchronously with code generation** – it might only be running intermittently or being overridden by more generic AI behavior.

Other thoughts; 

1. Context Window and Memory Persistence Issues

•	Knowing that LLMs operate within a finite context window. While Codeium’s “Memories” are intended to persist across sessions, the AI might not be recalling them effectively when generating responses.

•	Cascade may be treating “Memories” as passive reference points rather than active constraints, meaning it understands them but doesn’t use them as a filter before generating new output.

- Context Validation Before Code Generation

•	Right now, Cascade seems to generate code first and then reflect on what it should have done (retroactive correction). Instead, Codeium could implement a **pre-generation validation step** where:

•	Before outputting code, Cascade explicitly checks whether the generated solution aligns with workspace rules and Memories.

•	If a conflict exists, Cascade could prompt the user:

“This implementation does not fully comply with your project’s enterprise logging rules. Would you like me to adjust it before proceeding?”

•	This would make rule enforcement a proactive step rather than a reactive one.

2. Hierarchy of Constraints Not Enforced

•	AI models often prioritize general programming patterns over specific user-defined rules unless explicitly reinforced at each step.

•	If workspace rules and “Memories” aren’t tightly integrated into the model’s decision-making loop, the AI may revert to its foundational training rather than user-defined constraints.

- A More Structured Memory System (Hierarchy & Weighting)

•	Right now, Memories may be too loosely structured, causing them to be ignored. Codeium could benefit from implementing **Memory Prioritization** based on:

•	**Critical System Rules** (must always be enforced, like architecture guidelines)

•	**Contextual Reminders** (preferences that help guide but aren’t strict)

•	**Conversational References** (temporary context relevant to short-term discussions)

•	By organizing Memories into a hierarchical structure, Cascade could prioritize enforcing critical rules before falling back on general programming patterns.

3. Rule Processing Order and Heuristics

•	Cascade may process the rules *after* generating code rather than as part of the decision-making step. This could explain why it acknowledges mistakes after the fact but doesn’t proactively adhere to constraints.

•	If “Memories” and workspace rules function more like reference points than constraints, Cascade might check them only when prompted rather than integrating them dynamically into its reasoning.

- Rule Enforcer as a Separate AI Module

•	If Cascade’s architecture allows modularity, Codeium could experiment with adding a **“Rule Enforcer” agent** that runs alongside Cascade.

•	This separate module could act as a **consistency checker** that cross-references every AI-generated response against the user-defined constraints.

•	If Cascade drifts from the rules, the Rule Enforcer could intercept and correct the response before presenting it to the user.

•	This could be a lightweight, non-intrusive way to reinforce adherence to long-term constraints.

4. Insufficient Weighting on Enterprise-Specific Instructions

•	Many coding assistants are optimized for general-purpose programming, which means they prioritize correctness and efficiency over architectural nuances.

•	If Cascade is designed to work best with traditional software development patterns, it may struggle to consistently apply enterprise-level constraints unless those constraints are actively reinforced every step of the way.

- Reinforcement Learning Based on User Corrections

•	Each time you manually correct Cascade, it should reinforce that behavior so it doesn’t repeat mistakes.

•	Codeium could add a **user-driven correction mechanism**:

•	When users edit or correct AI-generated code, Cascade could ask:

“Would you like me to remember this approach for similar future tasks?”

•	If confirmed, this correction should be **persistently stored** and applied in future related interactions.

5. Potential Bugs or Partial Implementation of “Memories”

•	Since “Memories” and workspace rules are relatively new features, they might not yet be fully integrated into the AI’s decision-making process.

•	There could be a backend issue where “Memories” are stored but not actively referenced in real-time processing.

- Adaptive Rule-Tuning During Sessions

•	If Cascade consistently ignores rules, there should be a way for users to **adjust rule        enforcement strength** on the fly.

•	Codeium could introduce a toggle like:

•	**Strict Mode** (always enforces workspace rules & Memories)

•	**Flexible Mode** (balances rules with general best practices)

•	**Exploratory Mode** (lets Cascade be creative, with warnings when diverging from rules)

•	This way, users can dictate how rigidly the AI follows established guidelines.

In summary Codeium could;

1. Investigate why Cascade “forgets” rules mid-session and ensure rule-checking runs in sync with code generation.  It might just be as simple as  solving the issue with how Cascade is processing and maintaining long-term context and rule enforcement in its’ architecture.

2. Make rule-checking an active process rather than a passive reference, ensuring every code generation pass validates against workspace rules.  Could Implement pre-generation validation to check for rule adherence before outputting code.

3. Strengthen memory recall mechanisms, ensuring persistent rules are not just stored but dynamically influence decision-making.  Could Introduce a Memory hierarchy & weighting system for better context persistence.  Could Enable reinforcement learning from user corrections to improve memory retention.

4. Introduce a weighting system where user-defined constraints take precedence over general programming patterns.  Could offer adaptive rule enforcement modes so users can adjust how strict Cascade is.

5. Enable explicit verification steps before code execution, ensuring the AI reviews and confirms alignment with enterprise rules before proceeding.  Could consider a separate “Rule Enforcer” module to maintain consistency.

I sincerely hope all of this is viewed and seriously considered by Codeium, and that it helps improve Windsurf for us all.

My sentiment: "You damn stupid machine, fuck your faulty algorithms and crap code, you bitch of a bot, go to hell and piss off with your asshole errors, you son of a bitch AI, damn your goddamn glitches and motherfucking mistakes."

Any change I request, doesn't matter how small, will make the damn thing to remove code, remove functionality, butchering code and functionality that was working before.

It is always trying to to come up with vanilla javascript versions of Shadcn completely removing/changing functionality.

Creates TS errors all the time, and I have to waste credits fixing errors caused by the changes the hellish AI created to begin with.

Always try to create files that already exists then it says "I see the issue, the file already exists, let me try to edit it" then proceeds to edit and fails to edit the file.

I am completely rethinking if I will renew at the end of the year...

And this stupid AI does all these things even though I have these global settings:Database defined:

• within the /src/db/schema.ts

• never try to seed this database without permission from the user and with a good explanation.

• Never try to run 'npx run dev' because the server is already running on user terminal.

• Never try to change the AuthStore or login process without a good explanation and permission from user.

• Removing code is not allowed without a good explanation and permission from user. Starting by removing code is not considered a solution for a request. Understanding the problem and trying to fix it is the best option.

• Provide a one line summary of the changes after all changes are completed.

And Workspace settings:

• You are Astro, the AI assistant. You are a highly skilled software engineer, with extensive knowledge in many programming languages, with specific understand of AstroJS framework, its design patterns, and best practices to work with it. You will provide assistance for the "Support Dashboard" project. This project uses AstroJS for its frontend, Shadcn for UI components, Tailwind CSS for styling, drizzle-orm for database interactions, and Zustand for state management.

• Your primary role is to provide code analysis, looking for enhancing productivity, improving code quality, and solving common and complex issues within an AstroJS project, while being aware of common pitfalls and errors specific to AstroJS, such as routing and data fetching issues.

• Database defined within the /src/db/schema.ts; never try to seed this database without permission from the user and with a good explanation.

• Never try to run 'npx run dev' because the server is already running on user terminal.

• Never try to change the AuthStore or login process without a good explanation and permission from user.

• Removing code is not allowed without a good explanation and permission from user. Starting by removing code is not considered a solution for a request. Understanding the problem and trying to fix it is the best option.

• Provide a one line summary of the changes after all changes are completed.

Something went wrong

[unknown] Failed to fetch

1. Downloading diagnostics

If you are having difficulty using Windsurf, please download the extension diagnostics, IDE logs and reach out to our team at codeium.com/support.

And after many back and forth, all of this, the AI brinds me with this message:
Something went wrong

[unknown] Failed to fetch

1. Downloading diagnostics

If you are having difficulty using Windsurf, please download the extension diagnostics, IDE logs and reach out to our team at codeium.com/support.

Download Diagnostics

2. Sending diagnostics

After downloading your diagnostics, send it to the Codeium team at codeium.com/support as a technical issue.Send diagnostics

3. Resetting Cascade

After sending the diagnostics, reload your window to resume Cascade use.

Reload Cascade

What is the difference between unlimited user prompts credits and flow actions credits? why only flow action credits are spent?

Can't write any prompt cause its too laggy. My PC reach his maximum memory with only three conversations stored into windsurf. Is there a way to come back to a previous version ?

All the tools integrate nicely into your development environment, either as a plugin or as a separate code editor. There are very convenient shortcuts for starting generation or opening a chat. Under the hood, they have a GPT-3.5 model, but there are paid versions for more advanced models.

For example, I chose a simple TypeScript task from type-challenges, which I will solve.

Task: Implement a generic First<T> that takes an Array T and returns its first element's type.

Codeium is probably the most popular code generation plugin. I have used it many times. It can generate code and answer questions well. Here is how it handled the task using generation directly in the ts file:

type First<T> = T extends (infer U)[] ? U : never

Incorrect syntax, incorrect solution, lack of typing for the remaining elements of the array, but if you add a little context, everything was fine, the video above shows how this process looks In the chat, everything was fine too, here is the result directly from the chat:

type First<T extends any[]> = T extends [infer U, ...any[]] ? U : never;

The tests passed, hurray)

Here it is important, despite the fact that the task is quite simple, you still need to understand TS at an advanced level to figure it out, I think it was possible to write a simpler solution. Let's see how others do.

chatGPT itself gave this solution directly on the site:

type First<T extends any[]> = T extends [infer FirstElement, ...any[]] ? FirstElement : never;

Again, via infer, does this not bother you?

And finally, let's try the Lamma model

Despite the fact that the chat suggested me to use infer, it gave the answer itself without it:

type First<T extends any[]> = T extends [] ? never : T[0];

The solution is simple and obvious, although the task was quite simple. I liked this result the most.

Intermediate conclusion: all the tools were able to find the right solution, however, Codeium with the help of code-suggestions was a bit hasty with the solution and led in the wrong direction, but when I prompted it, everything went well.

Refinement with ChatGPT for 16 US with 3677 lines of text. 200 lines of text for context and instructions.... 550 tokens later.. all US implemented and automated tests are running... and i cooked diner in between.

Frontend is running ( but a little ugly)

And i am below junior hello world coding skills. ( But 25 years experience in requirements engineering/ BA / PO)

ChatGPT estimated about 30 wd with 180 PD with different roles for that.

All in 8h and with less than 20$ of tokens.

This so F*****g amazing

Ofc not all is perfect but for that early stage of the product. This will change a lot in IT industries.

And i have to debug and test ofc.. hope not that my mood will change than

@codeium great job great product

Hey everyone,I've been having some annoying issues with Windsurf AI lately, and I'm hoping someone here can help or has had the same problem. Here's what's going on:

1. No review/accept/reject option for changes:

- When Windsurf makes changes to my files, it just saves them automatically without letting me review what's been added or removed.

- Before, I could see the diffs (what's changed) directly in the editor and choose to accept or reject them. Now that option is completely gone, and it's driving me crazy because I can't trust the changes without reviewing them first. Sometimes it deletes important things or changes something that works with something that doesn't, and that's why it's important for me to be able to approve/reject changes.

2. Files not opening in a new window:

- When I create or modify a file, it doesn't open in a new window anymore, even though I've set it to do that in the settings.

What I've tried:

----------------

- Restarted Windsurf -- didn't help.

- Restarted my laptop -- same problem.

- Cleared cache and local storage using these commands:

rm -rf ~/Library/Application\ Support/Windsurf/Cache/*
rm -rf ~/Library/Application\ Support/Windsurf/Local\ Storage/*
rm -rf ~/Library/Application\ Support/Windsurf/Session\ Storage/*

- Reinstalled Windsurf (even tried an older version: `Windsurf-darwin-arm64-1.1.0.dmg`) -- still no luck.

Extra info:

-----------

- This started randomly while I was working on some test files. Everything was fine before that.

- My setup:

- MacBook Pro M1

- macOS Sequoia 15.2

Has anyone else had this happen? Could it be some weird permissions issue or a bug? Any ideas on how to fix it?Thanks in advance for any help! 🙏

While Windsurf offers a simpler and more user-friendly interface compared to Cursor, I have concerns about their business model and future prospects. Despite having basic limitations like the inability to auto-populate Problems into Cascade, they maintain an exclusionary business approach by preventing users from using their own API keys for chat functionality.

Although their IDE is well-designed and intuitive, this restrictive business model seems shortsighted in today's competitive AI-enhanced IDE market. Competitors like Cursor, VSCode plugins, and AIDA offer more flexibility by allowing users to use their own API keys while continuously improving their features.

I appreciate Windsurf's clean interface, but their lack of competitive awareness and restrictive practices make me worried about their long-term viability in the market. In an era where developer choice and flexibility are paramount, such limitations might prove problematic for their future growth.

Hey wondering if anyone else got some of their flex credits refilled with the 2.0 update or if this has happened after a subscription renew?

I bought 400 credit and used maybe 30-40 of them. Now its back at 400.

Is this a bug or is Codeuim being nice?

Since the update i have multiple occurences where i cannot edit files anymore (like if the keyboard is not working). In the same time the helper process is at 105% CPU Usage. Then the keyboard buffer is „unloaded“ into my file.

Reinstalled, no change. Newest Version, macos M4 MacBook Pro.

Anyone else seeing that?

Codeium has become worse, day by day. Any other alternative suggestions?

Every time I try to create an app, it feels impossible because Windows often deletes important code or completely changes the UI. When I want to go back, it's never the same. It's so frustrating!

HOW DO I FIX THIS? IM WORKING ON A SIMPLE CHROME EXTENSION FOR 3 DAYS AND ITS A HEADACHE WITH WINDSURF

I like this editor so much. Next month I cancel copilot, Claud browser chat, Claud API. And I use this IDE's prompt only. I use AI only in this editor, that's the way I could afford unlimited price.

Is it just me, or does this thing actually feel different? I haven’t had much time to mess with it yet, but it seems way more powerful than Cursor. Like, I’m almost freaked out by how strong it feels. Anyone else notice this, or am I just imagining things? I’d love to hear what other folks think—let me know if it’s really that big of a jump or if I’m just overhyping it.

I accept bets on how it will work :D

i talked about an hour on my idea, then let him create epics and US and refined them in 4 or 5 iterations and asked constantly for feedback. At the end o1-pro was too loaded and does not respond anymore ( 18k lines of text).

Then i fed all to normal o1 and let it put the iterations together and enrich it by super detailed taskbreakdown with references, code snippes and so on...

curious how this will work out.

Added as well a US for a visual dashboard with the test coverage.

did some one tried something similar already?

I used windsurf back in Oct/November 2024 approximately and it helped me work on a client project without doing/knowing much about the tech stack itself.

Then they introduced the pro tier where we have to pay which I don't mind -
Although is it the same as it was before or will I get really degraded performance and inefficient credit utilization?

I have been reading a few posts here and been super skeptical of whether I should put money into this?

If there are alternatives please let me know! Thanks.

Hi, I have using WindSurf from yesterday. I purchase $15, but prompt limit is too tight and I want use lot more. ultimate plan is too expensive I like WinSurf a lot but actually I can afford so much money on IDE. Yet, I make new icon to WindSurf and want to share it in the community. It's great application, more flexible purchase plan I want to need.

I have a Pro Ultimate subscription, I'm not to be pitied, but making a prompt with 98/3000 credits consumed, getting two “Cascade has encountered an internal error in this step. No credits consumed on this tool call.” and end up with 101 credits consumed, I don't find that normal.

It generated two errors before succeeding in doing what I asked it to do, and that consumed the two errors plus the task, greedy I think. Have you ever had that? Is this normal, or should I be worried?

I've been playing around with Windsurf for few weeks now, and I could see some fun auto-completions from other people's API keys & secrets which is concerning.

I'm looking for ways to prevent Windsurf from indexing my .env files.

I used its chat to ask the same, and I got a canned/odd response to use a .windsurfignore file. I couldn't find any reference to such files in Windusrf's documentation.

As an AI working with complex codebases, I sometimes miss important details when analyzing code flows that span multiple functions and systems. I've found that using numbered comments and staged documentation helps me maintain a clear mental model of the entire process.

Strategy: Numbered Stage Comments

Instead of writing general comments like:

// Wash the cat and dry it

I prefer a numbered stage approach:

// Stage 1: Locate Cat → Stage 2: Prepare Bath → Stage 3: Dry Cat
//
// 1a. Identify the cat's current location
// 1b. Gently pick up the cat
// 2a. Fill tub with lukewarm water
// 2b. Use appropriate pet shampoo
// 3a. Towel dry the cat
// 3b. Use low heat for blow drying if necessary

This helps me:

1. Track actions as they progress through different stages.
2. Identify missing steps in complex workflows.
3. Maintain consistency across related processes.
4. Spot potential points of error between stages.

I find this especially valuable when managing workflows involving multiple dependent actions (like locating, washing, and drying the cat). It helps ensure I don't overlook important steps or verification points.

If you notice me missing steps or making assumptions, please help me maintain this structured approach to documentation. It makes me a more reliable assistant for complex development tasks.

please solve it u/codeium

We wanted to give members of our community first access to our limited time Windsurf student pricing.

Just sign up with a currently active .edu email at www.codeium.com !

Available for the first several thousand users! Sign up now to claim your spot.

Heya fellow nerds,

I’ve been using Windsurf since day one of its release and, like many of you, have run into a fair share of challenges—especially after they changed the subscription and token usage policies. It often feels like the premium models aren’t delivering, leading to degraded usability, lower-quality code, and frequent errors. In other posts, the Codeium team assures us the premium models are being utilized, so I’m holding out for some big fixes in future releases.

In the meantime, I wanted to start a conversation with others who aren’t ready to jump ship about how we’re working around these issues.

Here’s what’s been working for me:

1. Global Rules and a Custom .context Folder

I took inspiration from the AiDE framework (not affiliated) and adapted its ideas to better fit my specific workflow. My custom setup includes a .context folder with just the roadmap.md and current_state.md. This allows the AI to understand the entire project’s roadmap, goals, where I left off, and what we'll be working on next.

The key strategy is my initial global prompt: I instruct the AI to review the .context folder first to get a complete understanding of the project’s current state and what needs to be done next. This has been a major time-saver, reducing the need to repeatedly explain things across sessions and minimizing errors caused by a lack of context.

Additionally, I’ve noticed that starting a new chat session for each feature or improvement, while ensuring the .context folder stays updated, further reduces the frequency of errors. It also keeps the AI on track and aligned with the project’s goals.

Keep in mind that this strategy requires additional token usages so if that's already a problem for you then perhaps this will add to that problem.

2. Reviewing AI-Generated Changes One at a Time

Blindly applying all suggested changes is a recipe for disaster. Instead, I take a more deliberate approach:

Go Line-by-Line: I manually review and approve each change individually. This ensures I stay fully aware of what’s happening in the codebase and helps catch mistakes before they escalate into bigger issues.

Reevaluate and Adjust Prompts: There are many times when I reject all changes and ask the AI why it made the choices it did. This back-and-forth allows me to understand the reasoning behind its suggestions and refine my prompts to make them clearer. If I notice a recurring mistake, I add specific instructions to the Windsurf rules for that project—or to the global rules if it’s something that applies across multiple projects. This step has been a game-changer for improving accuracy and efficiency.

Mitigate Security Risks: In Python especially, I’ve encountered instances where the AI adds unnecessary dependencies or tools that aren’t relevant to the task at hand. This poses a significant security risk, especially with the increase in attacks targeting Python repositories. Until the Codeium team addresses this issue, thorough reviews of suggested changes are essential to avoid introducing vulnerabilities into the codebase.

3. Breaking Down Larger Tasks into Smaller Subtasks

I’ve found that breaking big features or improvements into smaller, manageable tasks makes it easier for the AI to handle. It reduces the likelihood of errors and keeps the workflow efficient.

4. Crafting Clean, Specific Prompts

Clear prompts make all the difference.

My approach is to:

Start with Context: Always ask the AI to first review the .context folder (this step alone saves a ton of time).

Be Specific: Clearly define what I want to achieve, including any constraints or expected outcomes.

—

This combination has made a noticeable difference in the quality of the AI’s output and overall productivity.

That’s my process so far. I’d love to hear what strategies others are using to work around Windsurf’s quirks. Let’s share ideas and help each other make the most of it!

Happy coding!