Training course · Windsurf · JavaScript & TypeScript

Windsurf for JavaScript and TypeScript Developers

Develop with the Windsurf AI IDE and its Cascade agent: flows, memories, rules, workflows and safe use across the team.

Duration
2 days (14 hrs)
Format
Online or on-site
Language
German or English
Participants
open dates or exclusive for your team
Certificate
Certificate of attendance

Overview

This course connects Windsurf with the everyday processes of JavaScript & TypeScript. Participants work on realistic scenarios and leave with prompts, workflows and checklists they can use straight away.

Windsurf is an AI-powered development environment built around its agent, Cascade. Cascade understands the structure of your project, follows your actions in the editor and terminal, and works with you according to the flow principle: you and the agent take turns on the same task without having to re-explain context over and over. In this two-day course you will learn how to use Cascade effectively for features, debugging and refactoring, and how to make the most of intelligent completion in your daily development work.

To keep results consistent across a team, you steer Cascade with global and workspace rules, rely on memories for lasting project knowledge and automate recurring procedures with workflows that run from a slash command. You will connect external tools through MCP, control how terminal commands are executed and decide which data Cascade is allowed to see. Finally, you will define rules for code review, security and data protection so that Windsurf can be used responsibly within your organisation and its existing processes.

JavaScript and TypeScript now run in the browser, on servers, in build pipelines and on edge platforms. That breadth comes with complex toolchains: bundlers, transpilers, linters, package managers and an npm ecosystem that never stands still. AI coding assistants and agents remove a great deal of that friction. They migrate JavaScript modules to TypeScript incrementally, derive precise types from API responses, fix ESLint findings, write Vitest or Jest tests and explain nested generics in plain language. For the output to fit your project, the tools need clear guardrails: tsconfig strictness, module system, coding guidelines and test commands. This course shows you how to provide that context deliberately and how to scrutinise generated code.

The course is delivered live – either online in a virtual classroom or on-site in our training rooms in Munich, Salzburg, Berlin, Augsburg, Hanover, Bremen, Stuttgart and Kaiserslautern. We can also run it exclusively for your team.

Who is this course for?

  • Front-end and full-stack developers working in JavaScript or TypeScript
  • Teams migrating an existing JavaScript codebase to TypeScript
  • Library and SDK maintainers in the npm ecosystem
  • Tech leads who own tooling, linting and build processes

Typical challenges we address

  • Gradual type erosion through any, type assertions and lax tsconfig settings
  • Complex toolchains mixing bundlers, transpilers, ESM and CommonJS that are hard to debug
  • Huge dependency trees carrying security and maintenance risk
  • Asynchronous code with hard-to-reproduce race conditions and gaps in error handling

What you will be able to do

  • You use Cascade productively in flow for features, debugging and refactoring.
  • You steer Windsurf’s context precisely and keep sensitive content protected.
  • You maintain memories and rules that reliably enforce your project conventions.
  • You automate recurring procedures with workflows and connect external tools via MCP.
  • Use AI agents deliberately for TypeScript migrations, typing work and test generation.
  • Feed assistants your tsconfig, lint rules and project conventions so generated code fits your existing stack.
  • Critically assess proposed npm dependencies and generated code for type safety and security.

Course outline

Day 1

Module 1 Getting to know Windsurf and Cascade
  • Installation, importing existing editor settings and basic configuration
  • Cascade in code and chat mode: when the agent edits and when it only advises
  • The flow principle: how Cascade takes your editor and terminal actions into account
  • Intelligent completion and inline commands in everyday development
Module 2 Steering context
  • Understanding codebase indexing and referencing relevant files or directories
  • Bringing documentation, web sources and terminal output into context
  • Excluding sensitive content from context with ignore files
  • Structuring sessions and starting afresh when the topic changes
Module 3 Memories and rules for consistent results
  • Reviewing and maintaining auto-generated and manually created memories
  • Creating and versioning global and workspace rules
  • Expressing architecture, style and testing guidelines as effective rules
  • Activating rules selectively by file pattern or occasion
Module 4 Workflows and automation
  • Defining recurring procedures as workflows and launching them via slash command
  • Building workflows for release preparation, testing or code maintenance
  • Connecting MCP servers for issue trackers, databases or internal services
  • Controlling terminal command execution with allow and deny lists

Day 2

Module 5 Quality, review and governance
  • Tracing Cascade’s changes, accepting them partially or reverting them
  • Using a test-driven approach and preview features for verification
  • Team settings, data protection options and handling of secrets
  • Defining review processes and accountability for AI-generated code
Module 6 Practice lab: JavaScript & TypeScript
  • Incremental TypeScript migration
  • Deriving types from APIs and schemas
  • Writing Vitest and Jest tests
  • Fixing ESLint findings and code smells
  • Debugging build and bundler issues
  • Upgrading dependencies
Module 7 Data protection, quality & transfer to daily work
  • The npm ecosystem is a frequent target of supply-chain attacks, so vet every dependency the AI suggests for provenance, maintenance and licence (for example copyleft terms). Keep API keys and tokens out of prompts and clarify contractually whether your source code may be used to train the provider’s models.
  • Ground rules for safe AI use in your team
  • Checking results: facts, sources, tests and the four-eyes principle
  • Personal action plan for the next 30 days
  • Open questions, outlook and resources for further learning

Practical scenarios from your field

Incremental TypeScript migration

The agent converts JavaScript files to TypeScript module by module, infers types from usage, replaces any with precise types and tightens tsconfig strictness in controlled steps until the compiler runs clean.

Deriving types from APIs and schemas

JSON samples, OpenAPI specifications or database schemas are turned into TypeScript interfaces and Zod schemas for runtime validation, so front end and back end share one consistent contract.

Writing Vitest and Jest tests

For utilities, hooks and services, the AI generates unit tests with sensible mocks, fake timers and snapshot strategies, runs them and fixes failing cases on its own.

Fixing ESLint findings and code smells

The assistant works through lint warnings systematically, replaces outdated patterns such as callback chains with async/await and explains for each rule why the change makes sense.

Debugging build and bundler issues

Error output from Vite, webpack or esbuild is analysed, ESM/CommonJS conflicts are resolved and configuration for path aliases, tree shaking or source maps is corrected.

Upgrading dependencies

The AI reads changelogs for major npm package upgrades, adapts code to breaking changes, updates lockfiles and verifies everything through a type check and a full test run.

Possible hands-on projects

Type-safe API client

A small TypeScript package that generates a type-safe fetch client with Zod validation from an OpenAPI specification, ready to publish to npm with tests.

Browser extension

A TypeScript browser extension that analyses page content and copies it to the clipboard in a structured format – including manifest, content script and automated build.

Monorepo health check

A Node script that inspects workspaces in a monorepo, detects duplicate or inconsistent dependency versions and proposes a clean-up plan.

Prerequisites

You program regularly in at least one language and are familiar with Git and a modern IDE. Good command of modern JavaScript, a working knowledge of TypeScript and experience with npm, pnpm or yarn and Git.

Technical requirements

Your own laptop with the Windsurf editor, Git and your usual toolchain installed; a Windsurf account with access to Cascade is required.

Data protection & compliance

The npm ecosystem is a frequent target of supply-chain attacks, so vet every dependency the AI suggests for provenance, maintenance and licence (for example copyleft terms). Keep API keys and tokens out of prompts and clarify contractually whether your source code may be used to train the provider’s models.

Suggested dates

All dates are suggestions – your preferred date is always possible.

  • Tue, 24 November 2026 – Wed, 25 November 2026 Online Request
  • Mon, 30 November 2026 – Tue, 1 December 2026 Hanover Request
  • Thu, 17 December 2026 – Fri, 18 December 2026 Online Request
  • Wed, 13 January 2027 – Thu, 14 January 2027 Online Request
  • Thu, 21 January 2027 – Fri, 22 January 2027 Munich Request
  • Wed, 3 February 2027 – Thu, 4 February 2027 Online Request

Frequently asked questions

What does Windsurf mean by flows?

Flows describe the close collaboration between you and Cascade. The agent observes what you do in the editor and terminal and takes those actions into account in its next steps. As a result you do not have to keep explaining where you are, and you can move smoothly between doing the work yourself and delegating it to the agent.

How do memories, rules and workflows differ?

Memories store knowledge that Cascade has gathered while working or that you have explicitly recorded. Rules are guidelines you write that shape the agent’s behaviour permanently. Workflows are reusable sequences of steps for recurring tasks, launched with a slash command. Together they keep results consistent across the whole team.

Can I use Windsurf with my existing projects and languages?

Yes. Windsurf is language-agnostic and works with your existing toolchain, including build tools, package managers and test frameworks. Whether you work on back end, front end, data processing or infrastructure code, what matters is giving Cascade good rules and clear context. Each course variant adds the specific focus for your field.

How well do AI assistants handle complex TypeScript types?

Current models understand generics, conditional types and mapped types very well and can explain them clearly. For highly complex type constructions, though, the compiler remains the ultimate judge. On the course you learn to have the agent run tsc iteratively, so suggestions are not merely plausible but genuinely type-correct before you accept them.

Is the course suitable for pure front-end developers?

Yes. The focus is the language and its tooling – typing, tests, linting, builds and dependencies – which matter equally on the front end and the back end. If you want to go deeper into React or Node.js specifically, our catalogue includes dedicated course variants for those stacks.

How much does “Windsurf for JavaScript and TypeScript Developers” cost?

The course costs a flat €949 plus VAT per participant – whether online or on-site. This includes 2 training day(s) with a live trainer, course materials, a lab environment and a certificate of attendance.

Can I suggest my own date?

Yes. Our suggested dates are just a guide. In the request form you can always describe your preferred date or period in free text – we check availability and confirm within one working day.

Is the course online or on-site?

Both are possible: live online in a virtual classroom or on-site in Munich, Salzburg, Berlin, Augsburg, Hanover, Bremen, Stuttgart or Kaiserslautern. We can also run the course exclusively for your team.

More courses for JavaScript and TypeScript Developers

More Windsurf courses

All 32 Windsurf courses

Windsurf · MunichWindsurf · SalzburgWindsurf · BerlinWindsurf · AugsburgWindsurf · HanoverWindsurf · BremenWindsurf · StuttgartWindsurf · KaiserslauternWindsurf · Online