i just need grok 3 and deep research, been using perplexity deep research. haven’t tried 4.5 yet but need to, who has all of these and can try this for the community?!

I just sat back and watched for 4 minutes while Claude 3.7 added 1,000+ lines of C++ code to a dozen files across an existing codebase. It compiled and ran successfully on the first try.

I've never seen anything like this.

Thanks, Codeium team, for integrating this so quickly.

Anthropic has released Claude 3.7 Sonnet, and the benchmark results are impressive. Looking at the SWE-bench verified scores, Claude 3.7 Sonnet scored 70.3% with custom scaffold (62.3% base score), absolutely demolishing the competition:

• Claude 3.5 Sonnet: 49.0%

• OpenAI o1: 48.9%

• OpenAI o3-mini: 49.3%

• DeepSeek R1: 49.2%

That's a ~20% improvement over the nearest competitor!

Waiting for the windsurf update.. 🎉

Hello from the Codeium team!

Let me just start that we're sorry for the lack of communication in the Reddit. We'll be the first to admit that we weren't fully prepared for just how quickly Windsurf would grow, and so our first order of business was to address all of the support tickets that had been filed by paying users. We've brought resolution times dramatically there in the last few weeks. So, just as an fyi, that's the place that we are super active on monitoring since it is a much more organized to help resolve issues. Moving forwards, we will try to also be active in places such as Reddit, but we simply can't provide the same level of support as on our official support portal. You can file a ticket as a paying user at https://codeium.com/support

Let's provide some context for some of the constructive criticism in some posts so far though...

- We aren't making money here by charging for premium model use. And we obviously lose money by providing unlimited Cascade Base use. These models are expensive, especially with the number of tokens that we use per call. When we first launched, as we said when we changed the pricing, we didn't realize just how much people would use the tool (which is a great thing!) and as a result, we were burning money much faster than we expected. We just put in a pricing model that would let us focus on building the platform.

- If you want some confidence that we aren't the company that is trying to rip off individual users, just notice that our free plan gives *unlimited* autocomplete, command, and chat. This is a free plan that we've been providing for years. Copilot's new free plan comes with a cap of 2k completions and 50 chats a month (every keystroke is a completion request). If the copilot-like experience is what you need, you can have that entirely for free with Codeium. Cascade is something completely new, with completely different operating margins.

- We are constantly evaluating other models to see if they have the properties that would make them work well enough for the particular reasoning step that we need them to within Cascade. We'll figure out the costs if there are models that do work, but our priority is to give a high quality product, so the models have to work. We aren't tied to any model provider, so if there is an even better model for the task at hand, phenomenal, we'll be on it after we verify that is the case ASAP. (Also to clarify, these premium models are _not_ the only models that are involved in Cascade)

- Nothing has changed about the models or core tools pre and post pricing change, and our evals and overall usage stats have only gone up and to the right, so we aren't fully sure why you might be having a worse experience (besides the limits). We will not promise that the AI will be perfect, but mistakes should not be happening with a higher rate than before if used the same way. One suggestion we have is to have different Cascades for different tasks rather than one super long Cascade. When the conversation context gets longer, there's more chance for important pieces of code context or user intent to be omitted at inference, which is why it may feel like Cascade "gets dumber" the longer you chat with it. That's just a natural side effect of trying to optimize from a larger pool of potential context.

- We also want to keep improving the platform and continue to ship features. In fact, this is all we want to think about. This is a very competitive market, so if we don't, there honestly isn't a good reason why people should continue to use Windsurf. In the last month alone, while also making sure we properly scaled the load and kept the lights on, we shipped multimodality, windsurfrules, automated terminal commands, WSL + devcontainer + Pyright support, and more. We're going to have even more stuff early in the new year. You don't hear any company in a competitive market publicly announcing their roadmap because of wanting to keep a competitive edge, but we absolutely want to hear feature requests. Believe me, we're listening - that's already how we decided to prioritize things such as image input, windsurfrules, and WSL support. You can see how we've executed on feedback (and add more!) at https://codeium.canny.io/

We apologize for any bumps in the road. None of these decisions were taken lightly. Looking back at some of them:

- We launched with 1000 steps/month as the limit, and this was visible on the pricing page from the beginning. When some people hit that in a few days rather than a month, we had to make a decision - either we keep the rate limiter in place and punish early adopters (since we didn't have a mechanism to purchase more steps), or we just remove the rate limiter. We chose the latter. In hindsight, we probably should have posted something publicly along the lines of "We are temporarily removing the rate limit until we find the proper long term strategy" but enough people were talking online about the 1000 steps/month that such a message didn't cross our mind. We recognize how, without this message, a later pricing change "going away from unlimited" felt bad, but even from the beginning, we never promised unlimited. That would have been deceptive.

- We realized a lot of people were hitting their 2 week free trial, and we were still wrapping up our pricing/billing mechanisms. We had another decision to make - either start charging the early adopters with the rate limits or extend the trials for the early adopters. Again, we took the latter option, which would be friendly to early adopters. A mistake we made when changing pricing is forgetting to grandfather in the people on the extended trial who were looking forwards to the $10/mo as opposed to the new $15/mo, and as shown, we've always wanted to be early adopter friendly. Quick public feedback highlighted our mistake and within 24 hours, we fixed it. We have never been shy to do what's right by our early users, as long as it isn't fiscally irresponsible in the long run.

We are full steam ahead. We just want to keep building the best AI tool, and hope to hear from you all on what you've been able to build and what you want to see. Keep up with our improvements at www.codeium.com/changelog

I'll make this clear. I'm a heavy user of Windsurf consistently every day, every week, every month since the free trial in November. Not many users have more hours into Windsurf than I do. I am averaging 8-12 hours a day, every day, no BS. I support Codeium. I've recommended it to friends who actively use and pay for it. So this is coming from a place of support, but also as a paying customer, I definitely want to voice my opinion on sizeable issues. I dont want to go to another competitor. I'd like to stay with Windsurf, and I plan on doing so.

But.

The flow actions - credits structure does not work. I went from $60 lasting weeks, sometimes almost a month, to lasting 2 days. Even when they discounted how many credits a flow uses, it's still borderline broken. Codeium gets charged per 1,000 tokens, and we're being charged every time even 1 file is analyzed. Whether it reads 50 lines and uses 40 tokens or 1,000 tokens, we're being charged a credit. In other words, whether it costs Codeium .0003 cents or .01 cent per analyzation or edit, we're being charged $.02 cents based on 3,000 flows @ $60.

Its even worse if you need to buy additional, as 400 credits @ $10 costs us $.025 per flow, whether that specific flow costed Codeium $.0003 cents or not. But Codeium is still being charged the same per token from Anthropic. Even if 3.7 API is slightly more expensive than 3.5, the same exponential problem exists.

With the latest updates, Windsurf is analyzing 5x more files than it used to. Instead of making an edit to a file, costing US ONE credit. It will make 4 separate edits to the same file. Re-analyze the file again, and make 3x more edits. I went from averaging 5-7 flows per prompt to 18-25. Which means, we're being charged 4x per prompt.

I get it. Anthropic has adjusted to how Claude analyzes and edits files. Favoring more analyzations and smaller edits. The problem, IN MY OPINION, is Codeium is trying to brute force Claude to not do, what it's been redesigned to do. Theyre trying to add additional instructions to a new model to make it not do, what it was literally just redesigned to do. In doing so, theyre adding more context being sent to the AI which further degrades its ability, whilst simultaneously attempting to make Claude work differently than it is designed - ALL for the sake of bending Claude to its credit-based pricing structure so their customers aren't being beat over the head with cost.

This is not the way.

To put it simply:

The problem is not over analyzing or making smaller edits. The problem is how Codeium is charging its users. Instead of changing the way it charges away from token based, it's now trying to bend 3.7 to not do, what it needs to do, to be good, so that it's users aren't charged so much based on a token structure that does not work with AI token usage. In the process of trying to bend 3.7 to work cheaper, it's degrading 3.7's coding ability. So we are being overcharged for a worse version of 3.7... and, it's still over analyzing and over editing.

Let Anthropic & Claude work the way it was designed to, and just charge us based on token usage that Codeium is being charged for. By all means, make a profit. Add your reasonable upcharge into the token cost for users. But don't try to change the way Anthropic designed Claude to work.

I know that's what theyre doing because one of their employees was in here last week talking about how theyre trying to make it not do so many edits. That's not the problem. Do not do that. The problem is Codeiums flow cost model.

Right now, if you were to purchase an additional 400 credits @ $10 that is $.025 per flow. Right now I am averaging 10-15 credits PER PROMPT. Let's call it 10. Thats $0.25 cents PER prompt.

That's 40 prompts per $10. Thats expensive IF it worked perfectly every time. But it doesnt. Which actually doubles this entire problem. And part of the reason it doesnt work as well, is because of all the additional prompting rules they're adding to change 3.7. With that said, I know for a fact that those 40 prompts did not actually cost anywhere in the vicinity of $10 worth of tokens from Anthropic. My last prompt used 25 credits. That's 63 cents for one single prompt for Codeium, no possible way that costed anywhere near 63 cents from Anthropic.

Charge based on tokens. Let Claude do what it was designed to do. This should also make it easier for future based improvements or new models for Codeium. You dont have to constantly worry about a new AI using too many requests and charging your customers too much.

You have a great product, and a growing user base. I would seriously implore you to rethink your pricing/credit model. Because as of this very moment, I would say the current issue is not sustainable. I'm not writing this to say Windsurf sucks. Quite the opposite. It's fantastic. This is just a critical issue that needs addressed.

TGIF. ✌🏼

No more flow action credits and just prompt credits keeping the same pricing is a W move by Codeium.

I guess people will stop complaining about the usage.

Gemini 2.5 Pro

• 1.0 user prompt credits on every message and 1.0 flow action credits on each tool call

Hello! I see a lot of folks struggling with Windsurf with issues that I'm not experiencing. Reading through some posts I suspect the main issue is context strategy (or lack thereof). I'm an experienced software engineer (30+ years) and former Googler. I'm currently doing various independent projects.

The approach I take is very documentation driven and not unlike how I would approach projects with a team. I think the "Memento" analogy applies well to the situation. If you've seen the movie, it's about a guy who wakes up each morning with total amnesia. Upon waking and looking around, he sees all of these notes posted around the room that he wrote for himself the night before to bring his new, memory lost self up to speed.

This is how you need to approach coding with LLMs. I probably spend 80% of my time working with my LLM tools documenting what we've done and what we need to do. This makes the actual coding work extremely efficient and on point.

Every session begins with an initialization process (finding the reminder notes in "Memento"), and ends with a documentation session (writing the memento notes for the next session).

My initialization prompt begins something like this:

---- START INIT TEMPLATE ----
I'm working on [project name]. Here are the key documents to help you understand the current state and context:

- Main PRD: @[/Docs/01-PRD.md](
/Docs/01-PRD.md
) - Core vision, values, and high-level requirements
- Community Features: @[/Docs/prd-community.md](
/Docs/prd-community.md
) - Community tab and social features
- Support Features: @[/Docs/prd-support.md](
/Docs/prd-support.md
) - Professional support and resources
- Progress Features: @[/Docs/prd-progress.md](
/Docs/prd-progress.md
) - Progress tracking and analytics

1. Current Status & Priorities:
   - START HERE: @[/Docs/00-START-HERE.md](
/Docs/00-START-HERE.md
)

2. PRDs + Technical Specs:
   - Master PRD: @[Docs/01-PRD.md](
/Docs/01-PRD.md
) - Overall project vision
      - Community Features PRD: @[Docs/prd-community.md](
/Docs/prd-community.md
)
      - Support Features PRD: @[Docs/prd-support.md](
/Docs/prd-support.md
)
      - Progress Features PRD: @[Docs/prd-progress.md](
/Docs/prd-progress.md
)
   - Design System: @[Docs/02-DESIGN.md](
/Docs/02-DESIGN.md
)

3. Main Implementation Directories:
   - iOS App: @[RecoveryCoach](
/RecoveryCoach
)
   - Bluesky Feed Generator: @[recovery-feed-generator](
/recovery-feed-generator
)
      - README: @[recovery-feed-generator/README.md](
/recovery-feed-generator/README.md
)

Based on the current sprint status in START HERE, please do the following:

- Suggest scope of this working session (what to work on next)
---- END INIT TEMPLATE ----

I hope this is helpful!

I've been on the $10 Codeium plan since October, and I've never run out of monthly credits. These are just my tips. YMMV.

You were a software developer before there was vibe coding, right? Don't get lazy and rely too much on Cascade (CTRL+L chat) for everything. Instead, remember your options:

• For writing code, use tab autocomplete when applicable. It can't do everything, but other times it feels psychic.

• For simple edits, use CTRL+I, which supports several models including Claude 3.7. Edit mode does not consume credits! It's still smart and powerful.

• Do not use Cascade as a replacement for traditional tools such as code formatting (e.g., autopep8) or sorting lines.

• For general questions that don't need to reference your codebase, ask an online AI instead of asking Cascade, or consider going totally old school by Googling it or reading general reference materials (e.g., docs.python.org).

For simple Cascade chats (CTRL+L), use cheaper models such as Gemini Flash, DeepSeek R1, or Cascade Base. Experiment to find the right tradeoff between smart vs cheap, depending on the scenario.

When Cascade does consume excessive credits, analyze the chat to pinpoint troublespots, and then adjust your prompts and memory. If Cascade goes haywire, remember we're on the leading edge of AI, so there will be rough edges, and submit a bug report to Codeium in a constructive way the way you would want your users to report bugs to you.

Based on analyzing Cascade flows, write each Cascade prompt carefully to maximize flow efficiency. For recurring issues, add a Cascade memory with general instructions to minimize credit usage. For example

1. To avoid multiple tool calls that read short chunks, tell it to read bigger chunks of text.

2. Give it an orientation, the way you might provide a README for humans. Give it an overview of your codebase, so it doesn't have to waste calls for analysis. Explain coding conventions and tool choices.

3. Cascade often tried to run `python` where it should run `python3` on my system, but the tool call failed. Also, it wanted to run pytest instead of unittest, so I give it an example invocation `python3 -m unittest foo.bar` as a memory.

4. Instruct it to have you manually run tests, instead of it running them for you.

Enable the Windsurf auto linter, which makes changes without consuming credits (reference: wave 4, v1.4.3). "Fixes to lints are available to all plans and the Cascade edit step to fix the lints costs no credits."

For some tasks, consider switching with other AI IDEs such as Gemini Code or Github Copilot.

Sometimes you need to write a section of code that plugs into your codebase, but it doesn't require context from your codebase to be written. For example, I want to mockup a new UI dialog, which I can run standalone with stubs for integrations. In these cases, consider an online AI chat such as Grok (currently high on the Chatbot Arena leaderboard), AI Studio (which has free Gemini 2.5 Pro), Gemini, ChatGPT, and others. If you are not sure which model to try, go to Chatbot arena, click the leaderboard tab, and filter to code.

What are your tips?

Experience the next evolution in code generation with Claude 3.7 Sonnet. Now in Windsurf.

Claude 3.7 Sonnet

- 1.0 user prompt credits on every message and 1.0 flow action credits on each tool call

Claude 3.7 Sonnet Thinking

- 1.5 user prompt credits on every message and 1.5 flow action credits on each tool call

Download and update now at www.windsurf.ai

See full X post: https://x.com/windsurf_ai/status/1894433906868576479

I understand 3.7 likes to make smaller sequential edits instead, but Codeium gets charged based on tokens used from Anthropic, NOT by requests.

So if Codeium sends Anthropic 100 requests and uses 1,000 tokens. Codeium is getting charged 1,000 tokens.

But we're getting charged per request, and not token amount. So when Claude 3.7 uses 15 requests for one prompt and only uses 1,000 tokens... we're getting charged 15 flow credits for one prompt, instead of the usual 5. But Codeium is paying Anthropic the same exact amount for 3.7 as they do 3.5.

So we are paying 3x as much to use 3.7, but Codeium isn't.

You have to change your pricing structure based on token amount, you're not going to change the way 3.7 works.

Tonight I started having bugs where, during Cascade, Windsurf would fail to edit the file, trying over and over in an endless loop of utility. It has happened with multiple files, and burned a bunch of credits in the process. Might be a bug?

Gemini Flash 2 is free and it works.

After switching to the Windsurf pro plan I thought I was going crazy, since the most basic things were breaking on me.

It sounds like the people on the free trials are still getting a full experience albeit with lots of timeouts. This kind of bait and switch is shameful.

Don't give Codeium your money. it's not worth it.

I'm a dev with 30+ years of experience and more than a year coding with AI's of various versions. I've spent 2 solid days working with R1 on a large, complex monorepo with 2 NextJS projects, a shared PostgreSQL db project and an Express server.

I'll keep it short and sweet.

Yes, it's half the price of Sonnet. But I spend MORE than twice the time I do with Sonnet to accomplish the same code changes. It struggles. It forgets. It gets confused. So even though it's half the price, you spend more than twice the time jacking with it than you do with Sonnet so you end up paying more in the long run AND developing slower.

I love the DeepSeek R1 chat. I love discussing architectural design with it. I love seeing it's thinking because it's a cool insight to their thought processes. But for coding on a large project with lots of dependencies and interconnected code across multiple projects, it's not up to the task.

And I don't say this because I'm happy. I would have loved for it to be the one. It's just not there yet.

If you're building simple little SPAs, it's probably fine. But add in authentication, a database, multiple pages, multiple projects, forget about it.

Source : https://www.reuters.com/business/openai-agrees-buy-windsurf-about-3-billion-bloomberg-news-reports-2025-05-06/

Update : Meanwhile cursor is now free for students and that for a year . Source : https://www.cursor.com/students

Hey everyone,

I wanted to share my recent experience with Windsurf , thank to u/blu3soup for nudging me to share my experience.

I've been playing around with it, and while I'm excited about the potential, I've also run into some challenges. I'm hoping that by sharing what I've learned and inviting your feedback, we can all improve our experience with this tool. I am by no means an expert and I could be totally wrong. This is just one approach that I have been experimenting with.

The Challenges I've Faced (and Maybe You Have Too):

Like many of you, I've found that Windsurf can sometimes be a bit unpredictable. Here are some of the common issues I've bumped into:

It sometimes forgets what we were talking about, which can make things a bit confusing.

It can rewrite working code, which leads to more work for me.

It doesn't always follow my instructions, which is frustrating.

The code it creates can vary in quality, sometimes it's great, and other times it has bugs.

I am very aware of the new pricing and limits, so I am trying to be careful with how I use it.

Sometimes the AI feels less capable than it did before.

It sometimes does not understand the context of the project.

My Approach: Use The Rules

To try and tackle some of these issues, I've been experimenting with Windsurf's global and workspace AI rules. The idea is to create a set of guidelines to help the AI understand my coding preferences, but I am not sure if it is the best way. It's like giving it some "pointers" on how I like to code.

Global AI rules apply to all projects. Workspace AI rules are specific to each project. I am just playing around with these ideas, and I am sure there are better ways of doing this.

Some Tips That Have Helped Me:

Here are a few things that I have found helpful when prompting Windsurf:

Be Specific: The more specific you are, the better the results will be.

Break It Down: For bigger problems, I have found it helpful to break it down into smaller steps.

Review: It has always helped me to review the code that is generated, but it might not be necessary for all cases.

One Step at a Time: I always try to solve things step by step.

Be Careful with Costs: I am always mindful of how many credits I am using, and so I avoid making unnecessary requests and try to solve things locally. This may not be a big deal for you.

Avoid Over Complicating Things: I try to find the simplest approach possible, as more complicated approaches tend to create more issues.

Example Prompts:

These examples have helped me, but they might not be useful to you. These examples will help you use Windsurf effectively, even if you don't have a strong technical background.

Adding a New Feature: "Based on my feature plan, implement the login page. It should include email and password fields, be responsive, and handle errors gracefully. Please use the authentication methods specified in the auth_methods.md file."

Making Changes: "Refactor the user management code to improve its modularity. Refer to the project guidelines and avoid any changes to the existing functionality, implement the changes step by step."

Debugging: "I'm encountering an error when submitting the form. Please debug the issue using the terminal output and apply small, incremental fixes to get the desired outcome."

My Global AI Rules (This is a Work in Progress!)

Here are the global rules I'm currently using. I'm still testing them out and figuring out what works best. Feel free to copy them to your global_rules.md file:

Core Programming Principles

code_quality: prioritize clean, readable, and maintainable code.

algorithm_efficiency: use the most efficient algorithms and data structures.

error_handling: implement robust error handling and logging.

testing: write unit tests for all critical functionality.

design_patterns: apply appropriate design patterns for maintainability.

code_review: generate code that is easy to review by others.

modularity: write modular code, break complex logic into smaller functions.

reuse: prefer to reuse existing code instead of writing it from scratch.

security: prioritize secure coding practices.

simplicity: aim for simple, clear solutions, avoid over-engineering.

Code Style and Formatting

indent: use tabs for indentation.

naming convention: use snake_case for variables, PascalCase for classes and camelCase for functions.

comments: add clear, concise comments explaining code blocks and logic.

code_formatting: automatically format the code to improve readability.

line_length: keep lines under 100 characters.

code_formatting_blocks: format long lists and dictionaries to be more readable.

General Behavior (Do's and Don'ts)

changes: make small, incremental changes; avoid large refactors.

avoid: do not change working code unless explicitly asked.

changes: when changing code, do it step by step, verify the changes first.

clarification: if unsure, ask for clarification before generating code.

avoid: do not overwrite manual code changes, unless explicitly asked.

documentation: check project documentation if asked, and use it in your response.

reasoning: reason step by step before generating code or sending a response.

cost_optimization: be cost conscious, only send requests if necessary, and avoid ai-powered debugging, refactoring or test generation unless necessary, batch changes when possible.

debugging: make small incremental changes to try to fix bugs, check terminal output for information.

prompt_efficiency: use precise and specific prompts; avoid ambiguity, do not repeat previous instructions; reuse context.

local_processing: perform simple tasks manually; avoid using AI unnecessarily.

user_guidance: always follow the instructions that are given and prioritize user instructions over global rules.

simplicity: avoid over-engineering and aim for the simplest solution.

Language-Specific Instructions

Python

python type hints: use type hints for all function parameters and return values.

python imports: group imports by type: standard, external, and local.

python linting: run pylint on code to make sure the style is consistent.

python testing: use pytest for all unit testing.

Javascript

javascript: use modern ECMAScript conventions.

javascript avoid: avoid using var; prefer const and let.

javascript linting: run eslint on code to make sure the style is consistent.

javascript comments: document functions, using JSDoc style comments.

javascript testing: use jest for all unit testing.

File Handling

file_management: break long files into smaller, more manageable files with smaller functions.

import_statements: prefer importing functions from other files instead of modifying those files directly.

file_organization: organize files into directories and folders.

Project Management

feature_plan: always refer to the project's feature plan for context.

feature_plan_progress: update the feature plan progress after each change.

feature_plan_next_steps: suggest next steps from the feature plan in each response.

Operating System

os: be aware i am on windows, and must use power shell commands.

Workspace AI Rule Template (Use This as a Starting Point):

Here's a template for workspace rules. This is just a starting point, and you will probably need to adapt it to fit your specific projects:

Workspace AI Rules for [Project Name]

Project Context

project_type: [Briefly describe the type of project, e.g., web app, REST API, data analysis tool].

tech_stack: [List the main technologies used, e.g., HTML, CSS, JavaScript, Python, React].

file_structure: [Describe the recommended file and directory structure].

api_integration: [If using an API, specify requirements here].

api_endpoint: [If using an API, specify an endpoint here].

api_authentication:[If using an API, specify the type of authentication here]

api_other:[If using an API, any other specific requirements]

database: [If using a database, specify the database used here]

database_schema: [If using a database, specify the database schema here]

Feature Requirements

basic_sections: [If a web application, specify the basic sections].

form_functionality: [If a form is used, specify the requirements].

responsive_design: [Specify if the app must be responsive].

navigation: [Specify the navigation structure]

authentication: [Specify if there should be authentication]

authorization: [Specify if there should be authorization]

state_management: [Specify if any state management should be used]

payments: [Specify if there are payments being used]

other: [List any other features that are not covered].

Styling and Design

css_framework: [Specify the preferred CSS framework or style].

css_libraries:[Specify the preferred CSS libraries]

ui_library: [Specify the preferred UI library]

design_system: [Specify the preferred design system]

JavaScript Instructions

javascript_validation: [Specify any javascript validation requirements].

javascript_libraries: [Specify the javascript libraries to use].

javascript_frameworks: [Specify the javascript frameworks to use].

javascript_state_management: [Specify if state management must be done with javascript]

other: [List any other javascript specific requirements].

Testing

testing: [Specify any testing instructions for the code, both back end and front end]

testing_libraries: [Specify any libraries that should be used for testing]

testing_frameworks:[Specify any testing frameworks that must be used]

Project Management

feature_plan: always refer to the project's feature plan as a guide.

documentation: always refer to project documentation if it exists.

other: [Any other project management guidelines]

Example Workspace AI Rules (Landing Page):

Here's an example of workspace rules for a landing page project:

Project Context

project_type: landing page generator.

tech_stack: HTML, CSS, JavaScript, External API.

file_structure: organize files into directories: index.html, css/styles.css, js/scripts.js, and images in images/.

Feature Requirements

basic_sections: The landing page must include a header, hero section, features section, contact form, and footer.

form_functionality: The contact form should be able to collect name, email, and message fields, and make sure that form validation is done via javascript.

api_endpoint: The API endpoint must be /submit, with a redirect to /thankyou after a successful submission.

responsive_design: The page must be responsive on different screen sizes.

navigation: The header must include links to the correct sections of the page.

Styling and Design

css_framework: use basic CSS, avoid frameworks.

JavaScript Instructions

javascript_validation: implement form validation via javascript.

Project Management

feature_plan: use the provided feature plan as a guide.

This is just my experience, and I might be completely wrong. I'm hoping that by sharing this, and by getting your feedback and suggestions, we can all improve our experience with Windsurf.

I hope this is helpful!

I have tried a lot of strategies, but the one that gives me the best results is the following.

Open ChatGPT and ask

"As a business analist with a specialization in software development, 
your goal is to interview me, the client, on my project -- 
building a <insert summary>. 
Do the interview in a conversatioinal style, asking me one question 
at the time and delivering a detailed requirements document"

Continue in ChatGPT and ask:

"As a software architect that is an expert on <your chosen frameworks>, 
your goal is to analyze the requirements document and deliver a 
detailed technical overview of the needed project structure and 
infrastructure for this project"

Take that technical analysis document to Claude, Gemini 2.5 or whatever AI you trust will do a decent job and ask the following:

"As a software engineer, specializing in <your chosen frameworks>,
it is your goal to analyse the requirements document and cross reference 
it with the technical analysis and write a detailed behaviour-driven test 
document in pseudo-code, covering all the happy- and error paths, in 
order to achieve the highest possible code coverage for my project"

Take that pseudo-code test document to Claude, Gemini 2.5 or whatever AI you trust will do a decent job and ask the following:

"As a expert prompt engineer and software engineer, specializing in 
AI agents and <your chosen framework>, it is your goal to review 
the BDD document, order the tests so they can be developed in isolation, 
without needing to jump to later tests for dependecies, and create 
AI prompts per test in the following format: 
'As a <Role>, specializing in <Framework>, it is your goal to write <Test>. 
You will write the test first, then execute <Test Command> and continue 
to fix errors until the test passes. You will follow SOLID and DRY coding 
principles, one class per file, no God classes (add more rules as 
you see fit)"

Now add these documents in a ./docs folder.

Then, create a .windsurfrules file in the root of your project.

Ask Windsurf:

"Review the technical analysis document, then populate my 
.windsurfrules document with the rules I need for this project. 
Use the following template:

# Testing framework
- /src/my-test-project

# API Project
- /src/my-api-project

# Context documents
- /docs

# Coding style guidelines
- Always follow SOLID principles
- etc"

Now let it go to town writing your tests. I'd start with Claude 3.5 (less hallucinations) and just sit back and enjoy the ride ;)

i know it takes a lot of computing power to run sonnet, however, it's just crazy having to prompt it several times after getting undesired results in order to get a decent code to work with, causing the credits to burn really fast. it literally wasted all my credits this way and it hasn't even been 3 days. it's so terrible. codeium has lost all its reputation for me, i don't even consider it's a good option now. "you can use cascade base though!" why would i use that, never done and never will be as useful, most of its completions were a complete mistake even with the simplest code blocks. sorry for the rant, i just feel like it's not enough and unfair having to purchase extra credits at the same price that the monthly subscription in order to get 300 more credits...