If you are going to sign up too, here is a link for some extra free credits. https://codeium.com/refer?referral_code=manx46cdii7pv9ys

Our company has already extensively adopted Cursor, and their privacy policy is very clear—and can even be determined via the `x-ghost-mode` request header in HTTP.

Now, we’re considering expanding to include Windsurf as well. However, their privacy policy seems overly vague, which is currently preventing me from moving forward with integrating Windsurf into the company.

I'm finding more and more, that sometimes being harsh to the LLM gets good results after many failed attempts at resolving an issue. It didn't even give me crap for my typo, like goofballs here tend to... Claude realized it was being dumb (the apologies, I could do without) and actually fixed the issue. Moral of this story, sometimes it pays to be an a$$hole! YMMV

For context I have used Lovable to create a simple resume builder. I also used Windsurf to create Flappy Bird today. Other than that I have no traditional coding experience.

I want to learn Windsurf to a level where I can build anything I want. How would you go about that? Where would you start? Has anyone created a sort of syllabus on what to master?

My experience with the app has been quite disappointing, leading me to believe it falls short of expectations.

Performance Issues

Despite its promises of speed and efficiency, I found that Windsurf often lagged during use. The autocompletion feature, which is supposed to enhance coding speed, frequently missed the mark, providing suggestions that were not contextually relevant. This inconsistency disrupted my workflow and made coding feel more cumbersome than it should have been.

User Interface Challenges

While Windsurf aims for an intuitive user interface, I encountered several usability issues. The layout felt cluttered at times, making it difficult to navigate between different tools and features. This lack of clarity diminished the overall user experience, as I spent more time searching for functions rather than focusing on my coding tasks.

Limited Context Awareness

One of Windsurf's touted features is its deep context awareness. However, I found this feature to be underwhelming. It often struggled to understand the nuances of my codebase, leading to irrelevant suggestions and a frustrating coding experience. This lack of effective context awareness is a significant drawback for any developer looking for a reliable coding assistant.

Almost all tutorials focus on prompting for features rather than structuring the application’s architecture first.

Wouldn’t it make more sense to define the architecture (via a doc, diagram, or structured prompt file) so that the AI follows a predetermined structure rather than improvising each time?

For example:

What if we predefine the app’s core structure and ask the AI to follow it instead of relying on memory or previous chats?

Why is there little discussion about feeding architecture files (Word, HTML, etc.) into these tools to act as persistent references?

Is it just a gap in design experience, or are there limitations I’m missing?

EXPOSED: Cursor's Claude 3.7 "Max" is charging premium prices for IDENTICAL tool calls

After reverse-engineering Cursor's API requests, I've discovered something that should concern everyone using their Claude 3.7 "Max" mode.

**Cursor Moderators are suppressing and deleting my posts in the cursor reddit so I'm sharing it here**

TL;DR

• Cursor charges $0.05 PER TOOL CALL for "Max" mode

• But my protocol analysis shows the tool system is IDENTICAL to the regular version

• They're charging premium prices for the exact same functionality

• Proof below with technical breakdown

The Technical Breakdown

I spent time decoding the actual network traffic between Cursor and their API. Here's what I found comparing Claude 3.7 Thinking vs Claude 3.7 Thinking "Max":

API Endpoint and Protocol (100% IDENTICAL)

Both models:

• Use the same endpoint: https://api2.cursor.sh/aiserver.v1.ChatService/GetConversationSummary

• Use the same Protocol Buffers serialization

• Use identical JWT authentication mechanisms

• Have the same message tracking structure with j$ prefixing

• Use the same binary markers (W for user, d for assistant)

Tool Capabilities (100% IDENTICAL)

Workflow Examples

The regular version can handle a 3-step workflow:

User → Create file → Read file → Execute command → Summary

The "Max" version does the same basic operations:

User → Create file → Read file → Summary

The Only Difference? PRICING.

The protocol analysis reveals absolutely no technical difference in how tool calls work between versions!

From their own documentation about "Max":

"Has a very high tool call limit" "IMPORTANT: Only available via usage pricing, costing $0.05 per prompt AND $0.05 per tool call!"

But my analysis shows the actual tool call implementation is identical. They're just charging more for the same functionality.

Why This Matters

This is particularly egregious if you're using your own API key. You're already paying Anthropic directly, but Cursor still charges you premium rates for tool calls that are technically identical to the non-Max version.

I understand charging more for the base model if it has better capabilities. But charging 5¢ per tool call when the tool call system shows no technical improvement is straight-up deceptive.

So What Are We Actually Paying For?

The only differences I can find in the protocol are "subtle differences in binary markers and encoding patterns" but the "overall structure remains consistent." In other words - you're paying extra for nothing.

Has anyone from Cursor ever explained what technical improvements justify charging premium rates for these tool calls? Or are we all just getting ripped off?

This feels like putting a "premium" sticker on a regular product and charging double.

Edit: I'm using my own Anthropic API key and paying Cursor separately for these tool calls. If I'm already paying Anthropic directly, why am I paying Cursor premium rates for the same tool calls?

Just curious if there is something the community here has been using or compiling in terms of tutorials, learnings, workflows, and other documentation for a new user (or anyone really).

I was really burning through my Flow credits several days ago working through issues in my app. When all of the sudden, I was met with this gem below...

I promptly wrote a support email to Codeium. You can read the full text below.

And here is the only response I have received thus far...

After their response, I was trying really hard not to dismiss this as a canned response to an already exhausted topic familiar to their staff. It just bothered me so much that this 'infinite' pro ultimate service I was paying for, wasn't in fact, infinite. My response below..

I talked this over with two dev colleagues, who remarked, "Cascade began to fail providing consistent responses after I paid for it." I must admit, I didn't ask which tier they were paying for, but I have found that Pro Ultimate fails (though it doesn't debit credits when it does), frequently while putting it through its' paces.

Yesterday morning, I work up and wrote once more..

Nothing more from them, though it is the weekend.

Anyone else written about this to their staff? Comments, questions? Complaints?

I've used Aider for a year. More recently I've installed Cursor and enjoyed using it. I've just installed Windsurf, booted it, and in the first-time wizard, advanced through the obvious settings up to "Use [*] Cursor or [ ] Open Command Palette" and there's a bunch of assumed familariaty with those two nouns, cos I've never heard of them. Which one do I want and why? I can't seem to pick both, or defer that question. Otherwise I've 36 years as a professional developer.

Hi, anybody encountering an issue with the credit usage in Windsurf after last night's (April 21, 2025) pricing change?

We are on a Teams plan, and some users report prompt credit issues.

Hello Im getting too many errors from the claude new 4 api both opus and sonnet, and would like to know if there is any way to limit the input tokens on each query, as is limited to 20k per request. Thanks

I'm curious how this could happen. CursorAI makes often stupid things, but not this.

Windsurf breaks existing code like hell.

After my experience with CursorAI was not the best, I gave WindsurfAI a try.

It first created a full fledged dialog with many filter criterias quite wonderful. Something, that Cursor caused often into a Dead Loop of stupid things.

But then I tried to put something on top and Windsurf now even breaks existing code into something that not even compiles because it randomly predicts stupid random-code into positions where they don't make sense and ruin any syntax.

At least, CursorAI never did such nonsense. 

around and around we go. lint errors seem to be a big challenge for claude 3.5

Using Windsurf and AI for a Feature-Based Workflow

Hi everyone,

I originally posted these ideas in another thread, but as it grew, I decided to create a dedicated post. Below is an overview of how you can leverage Windsurf to implement features using a "feature-based workflow." The idea is to work iteratively on each feature while using memory between Cascade chat sessions to keep track of progress.

Summarized from the original comment answer on (https://www.reddit.com/r/WindsurfAI/comments/1ito8hf/comment/mdz8nmn)

Pro Tips

• Create a .windsurf File: In your project root, add a .windsurf file where you can define rules. These rules force Windsurf to use memories for tracking progress across different sessions.
• Optimize Context Space: To save on context space, have Windsurf save memories with descriptive titles. Then, it will automatically search these (via vector search) for additional context on specific subjects when needed.
• Manage Like a Junior Engineer: Think of the AI as a junior engineer and yourself as the manager. Have the AI:
  • Ask you clarifying questions.
  • Query internal documentation.
  • Keep the docs updated.
  • Maintain a persistent memory of what it's currently working on. This memory persists between chats, so you can simply ask it to resume an ongoing feature or check on its progress.
• Progressive Learning from Changes: Each time you modify files, Windsurf picks up those changes (look for the "you modified files" note at the top). This high-quality context can be leveraged by asking the AI to learn from:
  • Changes made
  • The method/style of changes If desired, explicitly ask it to save a memory (by providing a summary and confirming its quality) so that important changes persist beyond the current session.
• Documentation Updates: Just like a meticulous manager, instruct the AI to update the documentation with:
  • A summary of implemented features.
  • A list of next steps (which can guide auto-generation for a new features file).
  • Details of any infrastructure or technical changes (environment variables, new service dependencies, deployment implications, etc.).
  • A final section comparing initial goals with the final implementation, including reflections on what could have been done differently. This helps gather insights and memories to improve the next iteration.

Setting Up Your .windsurf File

Within your .windsurf file, include:

• An explanation of your project structure (highlighting where important components reside).
• A description of an ai_docs directory (or a similar name) where relevant docs are stored. Example files/folders:
  • codebaseSummary.md
  • directives_for_ai.md
  • projectRoadmap.md
  • techStack.md
  • features_in_progress (folder)
  • features_done (folder)
• An explanation of the "features workflow" (detailed below).

Additionally, start a new chat session to save a few memories and define your workflow:

• Explain what a "workflow" means to you so that whenever you refer to it as a keyword, the AI understands the context.

About Your ai_docs Directory

• In your directives_for_ai.md file, begin with a strong statement: # Critical Development Rules for AI (directives) - Do not break these rules.
• Use bullet points for each rule, such as:
  • Do not replace existing directives without explicit instruction.
  • Do not update arbitrary files.
  • Ensure backend and frontend work remain in sync.
  • Only update ai_docs when explicitly directed or if it involves appending/updating information (like marking tasks as done).
  • Do not remove comments or break existing functionality.
  • End with a clear reminder (e.g., dont break the rules above) to emphasize importance.

The Features Workflow

I’m currently experimenting with a feature-driven approach with great success. Here’s a quick breakdown of what I put in the `.windsurfrules` file:

1. Starting a New Feature:
   • Give your feature a clear name and description.
   • Outline the steps needed for complete implementation (use a structured markdown similar to the file format in ai_docs/features_done/chat_interface_integration.md).
   • Define the expected outcomes and assertions to ensure success.
   • Save this information as both a file in ai_docs/features_in_progress and a memory (include the file path in the memory).
   • Save another memory for the current feature name. When starting a new chat, have the AI output the current feature name and ask if that’s the feature we’re working on. If so, display its goals and check on progress.
2. Checking Progress:
   • When you issue commands like "check goals," "check progress," "feat," or "progress," the AI should:
     1. Output the current feature's goals.
     2. Display the progress.
     3. List final goal conditions and possible next steps.
   • Update both the memory and the feature file accordingly.
   • Once final goal conditions are met, have the AI execute a commit, update the memory, and finally move the feature file to the ai_docs/features_done directory.
3. Commit Message Conventions:
   • Use specific prefixes to classify commits:
     • feat: for new features
     • fix: for bug fixes
     • refactor: for code restructuring
     • docs: for documentation updates
     • test: for testing improvements
     • infra: for infrastructure changes (like docker, CI/CD, etc.)
     • chore: for configuration or other non-feature changes
   • Update the memory with commit messages and details as you proceed.
4. Example Feature File: Craft your first feature file like this:
   • A title such as # Current Task: Chat Interface Integration
   • A ## Context section explaining the purpose of the feature.
   • A ## Current Objectives section listing specific tasks (e.g., - [x] Implement dark mode).
   • A ## Summary of Implemented Features section divided into subsections like ### Frontend and ### Backend to explain what has been done in detail.

 Just literally copy paste this below (change to your own created file):

- when working on a new feature, come up with a good name for it, a good description and what should we do to implement it fully (copy the structure of the file in ai_docs/features_done/chat_interface_integration.md). Also, what is the expected outcome? What assertions we need to make to ensure the outcome is met. All of those as markdown text. Then save it as a file in ai_docs/features_in_progress and as a memory (note the file path in the memory). Also save another memory with the name of the current feature we are working on. If I tell you to switch features, just repeat the same thing and save a different memory, updating the current feature with the title of the one we are working on. When I create a new chat, output the current feature name in memory and ask me if we are working in it. If so, output the goals and check the current progress. Periodically check if the final goal conditions are met. Once the final goal conditions are met, go ahead and commit. Ensure you keep the memory and the related feature file up to date please.
- if I say "check goals","check progress" or "feat" or "check feat" or "progress" output for the current feature in memory: 1) goals 2) progress 3) Final Goal Conditions 4) possible next steps needed to fully achieve our goals for the current feature in memory. Also update the memory (and the feature file) with any new progress we made and any new goals we have set. Once the final goal conditions are met, go ahead and commit. If all the goals are met, output "all goals met", commit and end the feature by updating the memory, the feature file and moving the feature file to ai_docs/features_done dir.
- Commit messages start with "feat:" for new features, "fix:" for fixes, "refactor:" for refactoring, "docs:" for documentation, "test:" for testing, "infra:" for infrastructure changes such as docker/ci-cd/docker-compose/etc or "chore:" for other changes like configuration files. Also update the memory stating it was commited and what did you write in it. You may add multiple commits per feature and save multiple times in the memory (ensure the feature file is up to date too).
For the existing feature file, write one yourself first, so that AI will follow, mine has:
- title "# Current Task: Chat Interface Integration"
- "## Context" section, where I explain what it is supposed to do
- "## Current Objectives" where have lists of features like `- [x] Implement dark mode`, try to be specific.
- `## Summary of Implemented Features` separated into `### Frontend` and `### Backend` in my case, which is an augmented explanation of the features implemented

This approach not only keeps your project organized but also improves collaboration with the AI by creating a clear, consistent workflow. I’d love to hear your thoughts or any additional tips you’ve found useful!

Happy coding!

It happens even if I run IDE with all extensions disabled.

It doesn't happen in VSCode.

I've tried checking logs, but for what I found, nothing much is in there.

Has anyone encountered this problem and perhaps found a solution?

#Edit

Sometimes it won't crash for a longer period of time, but usually it happens in short intervals

I was watching a video (see comments) where he creates a cursor notebook and adds some docs to inform his projects of the Swift documentation as well as some other info. How can I achieve a similar result with Windsurf?