Supported IDEs Overview

VDK CLI provides native integration with multiple AI-powered IDEs and code editors. Each integration is specifically tailored to work with the IDE's unique rule format and configuration system.

Supported IDEs

IDE	Status	Format	Auto-Detection	Setup Command
Claude Code	✅ Stable	Markdown Memory	High	`vdk integrations --setup claude-code`
Cursor	✅ Stable	MDC (YAML + Markdown)	Medium	`vdk integrations --setup cursor`
Windsurf	✅ Stable	Markdown with XML	Medium	`vdk integrations --setup windsurf`
GitHub Copilot	✅ Stable	JSON Guidelines	Low	`vdk integrations --setup github-copilot`
Generic IDE	✅ Stable	Standard Markdown	Always	`vdk integrations --setup generic`

Quick Setup

Automatic Detection

VDK can automatically detect which IDEs you have installed:

# Scan for installed IDEs
vdk integrations --scan

Example output:

🔍 Scanning for IDE integrations...

✅ Detected IDE Integrations:
   • Claude Code (high confidence)
     Format: Markdown memory files, Path: CLAUDE.md + .claude/
   • Cursor AI (medium confidence)
     Format: MDC (YAML + Markdown), Path: .cursor/rules/

💤 Available IDEs (not detected):
   • Windsurf
   • GitHub Copilot

Setup All Detected IDEs

# Initialize VDK with automatic IDE integration
vdk init --ide-integration

# Or setup manually after scanning
vdk integrations --scan
vdk integrations --setup claude-code
vdk integrations --setup cursor

Integration Architecture

VDK uses a plugin-based architecture for IDE integrations:

┌─────────────────────────────────────────────────────────────┐
│                    VDK Integration Manager                   │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌──────┐ │
│  │   Claude    │  │   Cursor    │  │  Windsurf   │  │ ...  │ │
│  │    Code     │  │     AI      │  │             │  │      │ │
│  │ Integration │  │ Integration │  │ Integration │  │      │ │
│  └─────────────┘  └─────────────┘  └─────────────┘  └──────┘ │
├─────────────────────────────────────────────────────────────┤
│                    Base Integration                         │
│  • Rule Generation  • File Management  • Validation        │
└─────────────────────────────────────────────────────────────┘

Integration Features

Common Features

All integrations provide:

Project Context Awareness: Understanding of your tech stack and patterns
Automatic Rule Generation: Smart rules based on project analysis
Configuration Management: IDE-specific settings and preferences
Rule Validation: Ensuring rules meet IDE requirements
Team Synchronization: Sharing rules across team members

IDE-Specific Features

Each integration offers unique capabilities:

Claude Code

Memory Management: Persistent project memory in CLAUDE.md
Custom Slash Commands: /vdk-analyze, /vdk-refresh, /vdk-deploy
Watch Mode: Continuous updates during development
Context Preservation: Maintains conversation context across sessions

Cursor

MDC Format: YAML frontmatter + Markdown content
Real-time Updates: Live rule updates as you code
AI Chat Integration: Enhanced chat context with project rules
Custom Directives: Cursor-specific XML-like tags

Windsurf

XML-Enhanced Markdown: Rich formatting with XML tags
Multi-project Support: Handle multiple projects simultaneously
Advanced Templating: Custom rule templates and snippets
Code Generation: Enhanced code generation with project context

GitHub Copilot

JSON Configuration: Structured rule definitions
Workspace Integration: VS Code workspace-aware rules
Suggestion Enhancement: Improved code suggestions
Pattern Recognition: Better understanding of project patterns

Detection Logic

VDK uses multiple methods to detect IDE installations:

1. Command Line Detection

# Check if IDE CLI is available
claude --version     # Claude Code
cursor --version     # Cursor
windsurf --version   # Windsurf
gh copilot --version # GitHub Copilot

2. Process Detection

# Check running processes
ps aux | grep -i claude
ps aux | grep -i cursor
ps aux | grep -i windsurf
ps aux | grep -i "vs code"

3. Configuration File Detection

# Look for IDE-specific config files
~/.claude/settings.json           # Claude Code
~/.cursor/settings.json           # Cursor
~/.windsurf/preferences.json      # Windsurf
~/.vscode/extensions/             # VS Code + Copilot

4. Application Detection (macOS)

# Check installed applications
ls /Applications/ | grep -i cursor
ls /Applications/ | grep -i windsurf
mdfind "kMDItemDisplayName == 'Visual Studio Code'"

Rule Format Comparison

Each IDE has its own rule format requirements:

Claude Code Format

# Project Memory

## Project Context
This Next.js project uses TypeScript and Tailwind CSS.

## Coding Conventions
- Use TypeScript for all files
- Components in PascalCase
- Utilities in camelCase

Cursor Format (MDC)

---
title: "Project Rules"
version: "2.0.1"
schema: "cursor-mdc-v1"
---

# Project Rules

<cursor:context>
Next.js project with TypeScript
</cursor:context>

<cursor:rules>
- Always use TypeScript
- Prefer server components
</cursor:rules>

Windsurf Format

# Project Guidelines

<windsurf:project-context>
Technology Stack: Next.js, TypeScript, Tailwind CSS
</windsurf:project-context>

<windsurf:coding-standards>
1. Use TypeScript for type safety
2. Follow component naming conventions
3. Implement proper error handling
</windsurf:coding-standards>

GitHub Copilot Format

{
  "version": "2.0.1",
  "guidelines": [
    {
      "pattern": "**/*.tsx",
      "description": "React component guidelines",
      "rules": [
        "Use TypeScript interfaces for props",
        "Implement proper error boundaries",
        "Follow naming conventions"
      ]
    }
  ]
}

Configuration Options

Global Configuration

Set default IDE preferences in ~/.vdk/config.json:

{
  "integrations": {
    "preferredIDE": "claude-code",
    "autoDetect": true,
    "setupAll": false,
    "updateFrequency": "daily"
  },
  "defaults": {
    "claude-code": {
      "memoryFormat": "comprehensive",
      "enableCommands": true,
      "watchMode": true
    },
    "cursor": {
      "format": "mdc",
      "enableDirectives": true
    },
    "windsurf": {
      "xmlTags": true,
      "templateMode": "advanced"
    }
  }
}

Project-Level Configuration

Configure integrations per project in vdk.config.json:

{
  "integrations": {
    "enabled": ["claude-code", "cursor"],
    "claude-code": {
      "memoryFile": "CLAUDE.md",
      "settingsPath": ".claude/settings.json",
      "enableCommands": true,
      "watchMode": true
    },
    "cursor": {
      "rulesPath": ".cursor/rules/",
      "format": "mdc",
      "autoUpdate": true
    }
  }
}

Multi-IDE Setup

You can set up multiple IDEs simultaneously:

# Setup multiple integrations
vdk integrations --setup claude-code
vdk integrations --setup cursor
vdk integrations --setup windsurf

# Or setup all detected IDEs
vdk integrations --setup-all

# Check status of all integrations
vdk integrations --list

Example Multi-IDE Project Structure

my-project/
├── .ai/rules/              # Universal VDK rules
├── CLAUDE.md               # Claude Code memory
├── .claude/
│   ├── settings.json
│   └── commands/
├── .cursor/
│   └── rules/
│       └── project.mdc
├── .windsurf/
│   └── rules/
│       └── guidelines.md
├── .vscode/
│   └── .copilot/
│       └── instructions.json
└── vdk.config.json

Best Practices

1. Choose Your Primary IDE

While VDK supports multiple IDEs, choose one as your primary:

# Set primary IDE
vdk config set integrations.primary claude-code

# Focus on primary IDE setup
vdk integrations --setup claude-code --focus

2. Team Coordination

Establish team standards:

# Document team IDE choice in project
echo "Primary IDE: Claude Code" >> README.md

# Share integration settings
git add .claude/ .cursor/ vdk.config.json

3. Keep Integrations Updated

# Regular update workflow
vdk integrations --scan          # Check for new IDEs
vdk update                       # Update rules from hub
vdk integrations --sync-all      # Sync all integrations

4. Troubleshooting Integration Issues

# Debug integration problems
VDK_DEBUG=true vdk integrations --scan
vdk integrations --validate
vdk integrations --repair claude-code

Next Steps

Explore detailed guides for each IDE:

Claude Code Integration - Complete setup and usage guide
Cursor Integration - MDC format and advanced features
Windsurf Integration - XML tags and templating
GitHub Copilot Integration - VS Code workspace integration
Generic IDE Integration - Standard Markdown rules for any IDE

For advanced usage:

Custom Integrations - Build your own integrations
Integration API - Programmatic integration management

Supported IDEs

On this page