Windsurf Cascade Skills can turn repeat work into fast, consistent workflows inside your editor.

You pick a Skill, you give clear inputs, and Cascade runs a focused sequence of actions across your codebase.

This guide shows How to use Windsurf Cascade Skills Feature (10 Real use case example) with exact steps, copy-paste prompts, and practical checks so you can ship changes with fewer mistakes and less back-and-forth.

Key Takeaways

• You use Cascade Skills by selecting a Skill, setting scope, giving inputs, and reviewing a plan before applying edits.
• Clear constraints make Cascade faster: file paths, frameworks, coding style, and acceptance criteria.
• Use “plan first” prompts to control risk, then apply changes in small batches with tests.
• Skills work best for tasks that repeat: scaffolds, refactors, tests, docs, migrations, and bug triage.
• Windsurf can use ChatGPT if your Windsurf setup supports that provider; you pick the model in settings.
• You can use Windsurf in Visual Studio Code by installing the Windsurf extension and connecting your model provider.

What Windsurf Cascade Skills are and why they matter

Cascade is Windsurf’s agent workflow that can read your project, propose a plan, and apply edits across files.

A Skill is a reusable workflow template. A Skill defines what Cascade should do, what inputs it needs, and what output you should expect.

What a Skill does in plain terms

• It sets intent: “Generate tests,” “Refactor module,” “Write docs,” or “Create endpoint.”
• It sets structure: steps, checks, and typical files to touch.
• It reduces prompt work: you provide specifics instead of rewriting the full process each time.

When you should use a Skill

• You need changes across multiple files.
• You want consistent output, like test style or doc format.
• You want a plan, then controlled edits.
• You want a repeatable workflow for your team.

When you should not use a Skill

• You need a one-line change in one file.
• You do not have time to review the plan and diffs.
• Your project has no tests and no quick way to validate changes.

How to use Windsurf Cascade Skills Feature (step-by-step)

These steps work for most Skills. You can reuse this checklist for every run.

Step 1: Open Cascade and pick a Skill

• Open your project in Windsurf.
• Open the Cascade panel.
• Select a Skill that matches your task (tests, docs, refactor, scaffold, migration, and so on).

Step 2: Set scope so Cascade edits the right files

• Limit scope to a folder or module when possible.
• List the key files if you already know them.
• State what Cascade must not touch (for example, “do not change public API names”).

Step 3: Provide inputs in a strict format

Use a short template like this. It keeps your request NLP-friendly and reduces guesswork.

• Goal: one sentence.
• Context: framework, language, and constraints.
• Inputs: endpoints, schemas, file paths, or examples.
• Acceptance criteria: what “done” means.
• Validation: commands to run (tests, lint, build).

Step 4: Ask for a plan first

• Tell Cascade to propose steps before editing.
• Ask it to list files it will change.
• Ask it to note risks and open questions.

Step 5: Apply changes in small batches

• Approve edits in chunks.
• Run tests after each chunk.
• Stop and correct direction if outputs drift.

Step 6: Review diffs like you would review a PR

• Check for hidden behavior changes.
• Check naming, error handling, and edge cases.
• Check that the Skill followed your constraints.

How to use Windsurf AI effectively (rules that prevent bad output)

Windsurf AI works best when you treat it like a fast junior engineer. You set the task, you set the rules, and you review the work. These rules keep output accurate and consistent.

Use “inputs + constraints + checks” in every prompt

• Inputs: exact endpoints, schemas, file paths, examples.
• Constraints: style, libraries, patterns, and “do not change.”
• Checks: tests, lint, typecheck, build, and manual steps.

Prefer deterministic instructions

• Say “Add unit tests for these functions” instead of “Improve test coverage.”
• Say “Use Jest and Testing Library” instead of “Use common tools.”
• Say “Keep function signatures unchanged” instead of “Try not to break anything.”

Use a two-pass workflow

• Pass 1: plan, file list, and questions.
• Pass 2: code edits, then tests.

Ask for tradeoffs when there are multiple valid options

• Example: “Give two options. Pick one and explain why.”
• This reduces random choices that do not match your team style.

10 use cases, with Cascade prompts + SKILL.md templates

1) Deploy to Production (safe, repeatable release)

Cascade prompt (auto):
“Deploy the current branch to production safely, run all checks, and include a rollback plan.”

Cascade prompt (manual):
@deploy-to-production Deploy current branch to prod, run checks, and document rollback.

Suggested supporting files in folder

• deployment-checklist.md
• rollback-procedure.md
• env-prod.example
• release-commands.md

2) Deploy to Staging (preview, QA, stakeholder review)

Cascade prompt (auto):
“Deploy this PR to staging, seed test data, and share a QA checklist.”

Manual:
@deploy-to-staging Deploy PR to staging and generate QA checklist.

Supporting files

• staging-deploy-steps.md
• qa-checklist.md
• seed-data.sql
• staging-env.example

3) Hotfix + Rollback (minimize blast radius)

Cascade prompt (auto):
“We need an emergency hotfix, ship the smallest patch, and prepare rollback steps.”

Manual:
@hotfix-and-rollback Create minimal hotfix, deploy, and include rollback plan.

Supporting files

• hotfix-branching.md
• rollback-steps.md
• incident-log-template.md

4) Code Review (style + security + performance)

Cascade prompt (auto):
“Review this PR for correctness, security issues, style compliance, and performance risks.”

Manual:
@code-review Run full PR review with security checklist and produce review comments.

Supporting files

• style-guide.md
• security-checklist.md
• review-template.md
• perf-redflags.md

5) Add Feature with Tests (TDD-ish workflow)

Cascade prompt (auto):
“Implement feature X, add unit and integration tests, and update docs.”

Manual:
@feature-with-tests Implement feature, add tests, update docs, open PR-ready summary.

Supporting files

• test-guidelines.md
• acceptance-criteria.md
• pr-description-template.md

6) Refactor Safely (no behavior changes, add guardrails)

Cascade prompt (auto):
“Refactor module Y for readability, keep behavior identical, and add regression tests.”

Manual:
@safe-refactor Refactor module, preserve behavior, add regression tests, show risk checklist.

Supporting files

• refactor-checklist.md
• regression-test-template.md
• benchmark-notes.md

7) Run Tests Like CI (local parity, faster debugging)

Cascade prompt (auto):
“Make my local test run match CI, fix failing tests, and explain the root cause.”

Manual:
@run-tests-like-ci Mirror CI locally, run the right commands, fix failures, summarize.

Supporting files

• ci-workflow.yaml
• test-commands.md
• flake-triage.md

8) Database Migration (safe schema changes + rollback)

Cascade prompt (auto):
“Add a migration for table Z, ensure backward compatibility, and include rollback guidance.”

Manual:
@db-migration Create safe migration, ensure compat, add rollback steps, update docs.

Supporting files

• migration-guidelines.md
• rollback-migration.md
• db-checks.sql

9) Incident Triage (debug fast, communicate clearly)

Cascade prompt (auto):
“We have errors spiking, triage the incident, identify likely cause, and draft an incident update.”

Manual:
@incident-triage Triage spike, propose cause, immediate mitigations, draft status update.

Supporting files

• incident-runbook.md
• status-update-template.md
• log-queries.md

10) Release Notes (from commits and PRs, consistent format)

Cascade prompt (auto):
“Generate release notes for version X, include highlights, fixes, and upgrade notes.”

Manual:
@release-notes Generate release notes for this release, include breaking changes and credits.

Supporting files

• release-notes-template.md
• label-mapping.md
• breaking-change-checklist.md

What prompt to use on Cascade (practical patterns)

A) Let Cascade auto-invoke the right skill

Use a direct request that matches your description, for example:
“Deploy to staging and produce a QA checklist for this PR.”

Because auto invocation is driven by the skill’s description, keep descriptions specific and action-oriented.

B) Force a specific skill (recommended when you want consistency)

Type @skill-name then your task, for example:
@deploy-to-production Deploy current branch to prod and include rollback steps.

Can Windsurf use ChatGPT?

Yes, Windsurf can use ChatGPT if your Windsurf setup supports OpenAI as a model provider. The exact steps depend on your Windsurf version and your account settings, but the workflow stays the same: you add an API key or connect a provider, then you select a model for Cascade and inline suggestions.

How to confirm you are using ChatGPT (model provider check)

• Open Windsurf settings.
• Find the AI or Model Provider section.
• Select OpenAI (or a provider that offers GPT models).
• Select the model you want for Cascade and completions.

What to do if ChatGPT is not available in your provider list

• Update Windsurf to the latest version.
• Check if your plan or workspace policy restricts providers.
• Use another supported provider and keep the same prompt structure.

How to use Windsurf in Visual Studio Code

You can use Windsurf in Visual Studio Code by installing the Windsurf extension (if available for your environment) and connecting your model provider. After setup, you can run Cascade actions from the extension UI, similar to how you run them in the Windsurf editor.

Setup steps in VS Code

• Open VS Code.
• Open Extensions.
• Search for “Windsurf” and install the official extension.
• Open extension settings and connect your AI provider (OpenAI, Anthropic, or other supported provider).
• Open a project folder so the agent can read files within your workspace.

How to run Cascade actions in VS Code

• Open the Windsurf panel.
• Select a Skill (or start a Cascade task).
• Set scope to the right folders.
• Ask for a plan first, then approve edits.

Safety checks for VS Code usage

• Make sure the extension only has access to the workspace you intend.
• Use git branches for every Cascade run.
• Run tests locally before you push.

Common mistakes when using Cascade Skills (and how to avoid them)

Most bad results come from unclear scope or missing constraints. Fix those, and Cascade becomes predictable.

Mistake 1: Asking for “improve code quality” with no target

• Fix: name the exact files and the exact goal, like “remove duplication in src/payments/* without changing API.”

Mistake 2: Letting Cascade edit too many files at once

• Fix: restrict scope to one module, then expand after tests pass.

Mistake 3: Skipping the plan step

• Fix: always request “plan + file list + risks” before edits.

Mistake 4: No acceptance criteria

• Fix: define “done” with test commands, output formats, and edge cases.

Mistake 5: No regression test for a bug fix

• Fix: require a failing test first, then the fix, then passing tests.

Prompt templates you can reuse for any Cascade Skill

These templates keep your prompts short and clear. They also help Cascade stay on task.

Template A: Plan-first template

Goal: [one sentence]
Context: [language, framework, key libraries]
Scope: [folders or files]
Inputs: [schemas, endpoints, examples]
Constraints:
- [rule 1]
- [rule 2]
Acceptance criteria:
- [check 1]
- [check 2]
Validation:
- [command 1]
- [command 2]
First: propose a plan, list files to change, and ask questions.

Template B: Edit-only template (after you approve a plan)

Proceed with the approved plan.
Apply changes in small commits.
After each step:
- run tests
- report results
- stop if a test fails

Template C: “Do not touch” rules

Do not:
- rename public exports
- change API response fields
- change database schema beyond the requested migration
- add new dependencies
If you need any of these, stop and ask.

Frequently Asked Questions (FAQs)

How to use Windsurf cascade?

Open Cascade, pick a Skill, set scope, provide inputs and constraints, ask for a plan first, then approve edits in small batches and run tests after each batch.

How to use Windsurf AI effectively?

Give exact inputs, strict constraints, and clear acceptance criteria. Ask for a plan before edits. Limit scope. Validate with tests, lint, and typecheck.

Can Windsurf use ChatGPT?

Yes, if your Windsurf setup supports OpenAI as a provider. Connect your provider in settings, select a GPT model, then use it for Cascade and completions.

How to use Windsurf in Visual Studio Code?

Install the Windsurf extension in VS Code, connect your model provider, open your project folder, then run Cascade tasks from the Windsurf panel.

Do Cascade Skills replace code review?

No. You still need diff review, tests, and a PR review. Skills speed up work, but you own correctness and safety.

What is the fastest way to get better results from Skills?

Use a plan-first prompt, limit scope to one module, and add acceptance criteria that include tests and edge cases.

Final Thoughts

How to use Windsurf Cascade Skills Feature (10 Real use case example) comes down to one repeatable workflow: pick the right Skill, set tight scope, give clear inputs, request a plan, then apply edits with tests and review. If you want faster output with fewer surprises, start by saving the prompt templates above, run one use case on a small module today, and turn your best workflow into a shared Skill for your team.