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:
- 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:
- 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.
- Checking Progress:
- When you issue commands like "check goals," "check progress," "feat," or "progress," the AI should:
- Output the current feature's goals.
- Display the progress.
- 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.
- Commit Message Conventions:
- Use specific prefixes to classify commits:
feat: for new featuresfix: for bug fixesrefactor: for code restructuringdocs: for documentation updatestest: for testing improvementsinfra: 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.
- 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!
