Introduction to Rules, Memories, & Workflows

Overview

Imagine having an AI coding assistant that doesn’t just write code—it understands your team’s style, remembers your architecture decisions, and follows your exact development process. That’s the power of Windsurf’s Rules, Memories, and Workflows.

This foundational AI skill unlocks deep customization of Cascade, Windsurf’s intelligent coding agent, transforming it from a generic assistant into a personalized extension of your development workflow. Whether you're enforcing linting standards, documenting API patterns, or automating repetitive tasks, this skill gives you the tools to shape Cascade’s behavior to match your unique coding practices.

In today’s fast-paced development environment, consistency and speed go hand in hand. Off-the-shelf AI coders often generate technically correct but stylistically mismatched code—leading to friction during reviews and onboarding. With Rules, Memories, and Workflows, you eliminate that gap by teaching Cascade how your team codes, not just how code in general should look.

This isn’t about replacing developer judgment—it’s about amplifying it. By codifying best practices directly into your AI assistant, you ensure higher-quality outputs, reduce rework, and empower both junior and senior engineers with institutional knowledge at their fingertips.

Let’s dive into how this powerful trio works—and how you can install and start using it today.

---

Key Benefits

1. Enforce Team Coding Standards Automatically

With Rules, you define precise behavioral guidelines for Cascade—like “always use arrow functions” or “never mutate state directly.” This ensures every suggestion aligns with your project’s style guide, reducing nitpicks in PRs and accelerating code reviews.

Scenario: Your team uses Prettier with specific overrides. Instead of manually correcting AI-generated formatting, embed those rules so Cascade outputs compliant code from the first draft.

2. Preserve Institutional Knowledge Across Projects

Memories let Cascade remember key facts about your codebase—such as “We use Axios, not Fetch,” or “Authentication tokens are stored in authStore.” These persistent insights prevent redundant questions and keep suggestions context-aware.

Scenario: A new engineer asks Cascade to implement login logic. Thanks to Memories, Cascade knows which auth service to call, where credentials are validated, and even suggests logging via your internal analytics SDK.

3. Automate Repetitive Development Tasks

Workflows allow you to chain actions into reusable processes—like generating a React component, creating its test file, updating the storybook, and logging the change in a changelog.

Scenario: Need to add a new page? Trigger a workflow that scaffolds the route, component, CSS module, and unit test—all pre-filled with your preferred patterns.

4. Reduce Onboarding Time for New Developers

New hires spend less time learning tribal knowledge because Cascade carries it. Rules and Memories act as living documentation, guiding them through complex systems with real-time, contextual assistance.

Scenario: A junior dev joins and needs to modify the payment flow. Cascade recalls past decisions (e.g., “All payments go through Stripe Webhooks v2”) and applies relevant safeguards automatically.

5. Scale Best Practices Across Teams

Whether you’re a solo founder or part of a 100-person engineering org, these tools help standardize excellence. Once configured, Rules, Memories, and Workflows propagate consistently across projects, ensuring everyone benefits from shared wisdom.

---

Core Features

Feature	Description	Use Case Example
Rules	Define conditional behaviors that govern how Cascade writes and reviews code. Rules can enforce syntax preferences, ban anti-patterns, or require specific annotations.	Rule: “If file is in /legacy, avoid async/await; use Promises instead.”
Memories	Persistent knowledge entries that Cascade retains across sessions. These include tech stack choices, architectural decisions, naming conventions, and third-party integrations.	Memory: “Our frontend uses Redux Toolkit; slices live in /features.”
Workflows	Step-by-step automation sequences triggered by user commands. Combine code generation, file creation, edits, and external API calls into powerful macros.	Workflow: “Create Component” → generates .tsx, .test.tsx, .module.css, and Storybook story.
Contextual Awareness	Cascade dynamically combines Rules, Memories, and current context to deliver highly relevant responses. It adapts based on folder location, recent changes, and project history.	When editing /api/users, Cascade recalls rate-limiting policies stored in memory and suggests appropriate headers.

---

How to Get & Install

The Introduction to Rules, Memories, & Workflows skill is completely free and available through Windsurf University—the official learning platform for mastering Cascade customization.

Unlike plugin-based systems (e.g., Claude Code), this is a universal educational skill designed to teach you how to configure and leverage advanced Cascade capabilities within the Windsurf IDE. There's no single command to activate it—instead, you learn and apply concepts directly in your environment.

Here’s how to get started:

✅ Step 1: Access the Full Course

Visit the official Windsurf University module: 👉 https://windsurf.com/university/general-education/intro-rules-memories

This interactive course includes:

• Video tutorials
• Hands-on exercises
• Sample configurations
• Quizzes to test your understanding

You’ll walk through real-world examples of setting up Rules, capturing Memories, and building your first Workflow.

✅ Step 2: Open Your Project in Windsurf IDE

Ensure you’re using the latest version of the Windsurf IDE (v1.8+). You can download it at windsurf.com/download.

Once open:

1. Navigate to Project Settings > AI Behavior
2. Click Customize with Rules & Memories

This opens the configuration panel where you can begin defining your custom logic.

✅ Step 3: Configure Your First Rule

To create a simple rule (e.g., enforce semicolon usage):

# .windsurf/rules.yml
rules:
  - id: enforce-semicolons
    description: "All statements must end with semicolons"
    condition:
      file_extension: ".ts"
    action:
      enforce_trailing_semicolon: true

Save the file and restart Cascade. Now, when suggesting TypeScript code, Cascade will automatically include semicolons—even if you forget to mention it.

✅ Step 4: Add a Memory

Teach Cascade a key fact about your app:

# .windsurf/memories.yml
memories:
  - key: "state-management"
    content: "We use Zustand for global state. Stores are defined in /stores and named XxxStore.ts."
    tags: ["zustand", "state"]
    persistence: permanent

Now, when asked to “create a store for user preferences,” Cascade will follow the correct pattern without being told.

✅ Step 5: Build a Simple Workflow

Automate component creation:

# .windsurf/workflows.yml
workflows:
  - name: "Create React Component"
    trigger: "/component"
    steps:
      - action: "generate_file"
        path: "src/components/{{name}}.tsx"
        template: "react-component-arrow-function"
      - action: "generate_file"
        path: "src/components/{{name}}.test.tsx"
        template: "jest-react-test"
      - action: "append_to_index"
        file: "src/components/index.ts"
        content: "export * from './{{name}}';"

Now type /component UserProfile and watch Cascade build everything in seconds.

💡 Pro Tip: Start small. Begin with one rule and one memory. Test thoroughly before scaling.

---

Use Cases

These are ideal scenarios where Rules, Memories, and Workflows make a dramatic impact:

1. Migrating Legacy Codebases

Use Rules to block outdated patterns (e.g., var declarations) while Memories track migration status per module. Workflows automate refactoring scripts and update documentation.

2. Maintaining Design System Consistency

Enforce strict component usage rules (e.g., “Only import Button from @design-system/react”) and auto-generate variants via workflows.

3. Onboarding New Team Members

Load project-specific Memories so new developers instantly access critical context. Pair with guided workflows for common tasks like bug fixes or feature additions.

4. Compliance & Security Enforcement

Create Rules that flag insecure practices (e.g., hardcoded secrets, unsafe eval usage). Store security policies in Memories so Cascade explains why certain patterns are banned.

5. Scaling Monorepos

Apply different Rules and Memories per package. For example, backend services might require OpenAPI comments, while frontend modules prioritize accessibility attributes.

---

Tips for Success

🔹 Start with High-Impact, Low-Effort Rules

Focus on rules that catch frequent pain points—like inconsistent imports or missing error handling. Quick wins build team confidence in the system.

🔹 Treat Memories Like Living Documentation

Review and update Memories quarterly. Outdated memories cause more confusion than no memories at all. Tag them clearly and link to source docs when possible.

🔹 Name Workflows Clearly and Keep Them Composable

Instead of one giant “Build Feature” workflow, break it into smaller pieces: “Generate API Client,” “Create Slice,” “Add Route.” Reuse components across workflows.

---

Disclaimer: This guide covers the educational skill "Introduction to Rules, Memories, & Workflows" provided by Windsurf. While the core concepts are universal, implementation details may vary slightly depending on your Windsurf IDE version. Always back up configuration files before making bulk changes. Windsurf reserves the right to update APIs and configuration formats; refer to official documentation for the latest syntax.