AI Coding Assistants 2025: Cursor vs Copilot vs Windsurf vs Claude Code

User: "Add user authentication with JWT tokens, including
      login/logout endpoints, middleware, and tests"

Composer:
1. Creates auth/jwt.ts with token generation/verification
2. Adds routes/auth.ts with login/logout endpoints
3. Creates middleware/auth.ts for protected routes
4. Updates app.ts to register new routes
5. Generates tests/auth.test.ts
6. Runs tests, fixes any failures

# Type: "def calculate_"
# Cursor suggests:
def calculate_total_price(items: list[dict], tax_rate: float = 0.08) -> float:
    """Calculate total price including tax."""
    subtotal = sum(item['price'] * item['quantity'] for item in items)
    return subtotal * (1 + tax_rate)

# Cursor understands your existing patterns
# If your codebase uses a specific ORM pattern:

# Type: "def get_user_by_"
# Cursor suggests based on YOUR existing code:
def get_user_by_email(email: str) -> User | None:
    """Fetch user by email using existing repository pattern."""
    return UserRepository.find_one({"email": email})

@auth.ts @middleware.ts How does the current auth flow work?

@docs Can you explain how to use the payment API?

@git-diff Review these changes for security issues

// .cursor/settings.json
{
  "cursor.cpp.enableIndexing": true,
  "cursor.general.gitGraphEnabled": true,
  "cursor.chat.showSuggestedFiles": true,
  "cursor.composer.enabled": true,
  "cursor.autocomplete.enabled": true,
  "cursor.autocomplete.useSupermaven": true,

  // Model preferences
  "cursor.models.default": "claude-sonnet-4",
  "cursor.models.composer": "claude-sonnet-4",

  // Context settings
  "cursor.context.maxFiles": 20,
  "cursor.context.includeOpenTabs": true
}

# .cursorrules

## Project Context
This is a TypeScript backend using:
- Express.js for routing
- Prisma for database ORM
- Jest for testing
- Zod for validation

## Code Style
- Use functional programming patterns where possible
- Prefer `const` over `let`
- Use early returns to reduce nesting
- All functions must have JSDoc comments
- Error handling with custom AppError class

## Testing
- Every new function needs unit tests
- Use test factories for mock data
- Integration tests for API endpoints

## Avoid
- Any use of `any` type
- Console.log in production code
- Hardcoded strings (use constants)

# Trigger agent mode from CLI
gh copilot agent --issue 123

# Or from GitHub UI:
# Click "Start agent" on any issue

// Type a comment describing what you want:
// Function to validate email addresses using regex

// Copilot suggests:
function validateEmail(email: string): boolean {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

/explain What does this function do?
/fix There's a bug in the sorting logic
/tests Generate unit tests for the selected code
/doc Add documentation to this class

## Summary
This PR adds user authentication with JWT tokens.

## Changes
- Added `auth/jwt.ts` for token management
- Created login/logout API endpoints
- Implemented auth middleware
- Added comprehensive test coverage

## Testing
- [x] Unit tests pass
- [x] Integration tests pass
- [x] Manual testing completed

// VS Code settings.json
{
  "github.copilot.enable": {
    "*": true,
    "markdown": true,
    "plaintext": false,
    "yaml": true
  },
  "github.copilot.advanced": {
    "temperature": 0.3,
    "top_p": 0.95,
    "max_tokens": 500
  },
  "github.copilot.chat.localeOverride": "en",
  "github.copilot.editor.enableAutoCompletions": true
}

# Copilot Instructions

## Language & Framework
- TypeScript with strict mode
- React 18 with hooks
- TanStack Query for data fetching
- Tailwind CSS for styling

## Patterns
- Use custom hooks for reusable logic
- Prefer composition over inheritance
- Use discriminated unions for state
- Error boundaries for error handling

## Code Generation
- Include TypeScript types for all functions
- Add JSDoc for public APIs
- Generate tests using Vitest
- Use `describe`/`it` test structure

# Install
gh extension install github/gh-copilot

# Explain a command
gh copilot explain "git rebase -i HEAD~3"

# Suggest a command
gh copilot suggest "find large files in git history"

# Ask questions
gh copilot ask "How do I squash commits?"

Session 1 (Morning):
"I'm building a REST API for a blog platform"
[Discusses architecture, creates initial routes]

Session 2 (Afternoon):
"Let's add comments to posts"
[Cascade remembers the blog context, existing routes, patterns]

Session 3 (Next day):
"Add authentication"
[Still has full context of blog platform, existing models]

/flow create-api
→ Walks through: endpoint design, validation, testing, docs

/flow refactor
→ Analyzes code, suggests improvements, applies changes

/flow debug
→ Examines error, traces cause, suggests fix

// Windsurf shows clear diffs:
- function getUser(id) {
-   return users.find(u => u.id === id);
- }
+ function getUser(id: string): User | undefined {
+   if (!id) {
+     throw new ValidationError('User ID is required');
+   }
+   return users.find(u => u.id === id);
+ }

// windsurf.config.json
{
  "cascade": {
    "enabled": true,
    "memoryDuration": "session",
    "contextWindow": 128000
  },
  "completions": {
    "enabled": true,
    "delay": 200,
    "multiline": true
  },
  "chat": {
    "model": "gpt-4o",
    "temperature": 0.2
  },
  "flows": {
    "enableBuiltIn": true,
    "customFlowsPath": ".windsurf/flows"
  }
}

# .windsurf/flows/create-component.yaml
name: Create React Component
description: Generate a new React component with tests and stories
steps:
  - prompt: "What should this component do?"
    variable: purpose

  - prompt: "What props does it need?"
    variable: props

  - action: generate
    template: |
      Create a React component that:
      - Purpose: {{purpose}}
      - Props: {{props}}
      - Include TypeScript types
      - Add unit tests
      - Add Storybook story

  - action: create_files
    files:
      - "src/components/{{name}}/index.tsx"
      - "src/components/{{name}}/{{name}}.test.tsx"
      - "src/components/{{name}}/{{name}}.stories.tsx"

# Initialize Claude Code in your project
claude-code init

# Ask about the codebase
claude-code ask "How does the authentication system work?"

# Get architecture overview
claude-code ask "Explain the overall architecture and key components"

claude-code edit "Rename the User model to Account across the entire codebase"

# Claude Code:
# 1. Finds all references to User
# 2. Updates model definition
# 3. Updates all imports
# 4. Updates all usages
# 5. Updates tests
# 6. Shows diff for approval

claude-code task "Add a caching layer for the API responses"

# Claude Code autonomously:
# 1. Analyzes current API structure
# 2. Determines best caching strategy
# 3. Implements Redis caching layer
# 4. Adds cache invalidation
# 5. Updates existing endpoints
# 6. Adds configuration options
# 7. Creates tests
# 8. Documents the changes

# claude-code.yaml
project:
  name: my-app
  type: typescript

context:
  include:
    - "src/**/*.ts"
    - "tests/**/*.ts"
    - "*.json"
  exclude:
    - "node_modules"
    - "dist"
    - "*.log"

preferences:
  model: claude-sonnet-4
  max_tokens: 8192
  temperature: 0.2

  style:
    typescript:
      strict: true
      prefer_interfaces: true
      use_type_imports: true

  testing:
    framework: vitest
    coverage_threshold: 80

  documentation:
    style: jsdoc
    require_for_public: true

hooks:
  pre_edit:
    - "npm run typecheck"
  post_edit:
    - "npm run lint:fix"
    - "npm run test"

from claude_code import ClaudeCode

# Initialize
cc = ClaudeCode(
    api_key="your-api-key",
    project_path="/path/to/project"
)

# Index the codebase
cc.index()

# Ask questions
response = cc.ask(
    "What are the main API endpoints and their purposes?"
)
print(response.answer)
print(response.relevant_files)

# Edit files
result = cc.edit(
    instruction="Add input validation to all API endpoints",
    files=["src/routes/*.ts"],
    dry_run=True  # Preview changes first
)

for change in result.changes:
    print(f"File: {change.file}")
    print(f"Diff:\n{change.diff}")

# Apply changes
if input("Apply changes? (y/n): ") == "y":
    cc.apply(result)

# Add to .bashrc/.zshrc
alias cc="claude-code"
alias cca="claude-code ask"
alias cce="claude-code edit"
alias cct="claude-code task"

# Quick commands
cca "What does this function do?" -f src/utils/parser.ts
cce "Add error handling" -f src/api/routes.ts
cct "Write tests for the auth module"

Traditional (Cursor, Cline):
┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ Your IDE    │───>│   LLM API   │───>│   Response  │
│ (local)     │    │   (cloud)   │    │   (local)   │
└─────────────┘    └─────────────┘    └─────────────┘
     ^                                       │
     └───────────────────────────────────────┘
              (runs locally)

Codex Architecture:
┌─────────────┐    ┌─────────────────────────────┐
│ Your IDE    │───>│      Codex Cloud            │
│ (local)     │    │  ┌─────────────────────┐   │
└─────────────┘    │  │   GPT-5.2-Codex     │   │
     ^             │  │   ┌───────────────┐ │   │
     │             │  │   │ Sandbox VM    │ │   │
     │             │  │   │ - Your code   │ │   │
     │             │  │   │ - Git clone   │ │   │
     │             │  │   │ - Test runner │ │   │
     │             │  │   └───────────────┘ │   │
     │             │  └─────────────────────┘   │
     │             └─────────────────────────────┘
     └──────── (PR/diff returned) ──────────────┘

# Start multiple agents working in parallel
codex task "Implement user authentication with JWT" --background &
codex task "Write comprehensive unit tests for the User model" --background &
codex task "Update API documentation with new endpoints" --background &

# Check status of all running agents
codex status

# Output:
# Agent 1: "Implement user authentication" - 67% complete
#   └─ Created: auth/jwt.ts, auth/middleware.ts
#   └─ Currently: Writing login route tests
#
# Agent 2: "Unit tests for User model" - 45% complete
#   └─ Created: tests/user.model.test.ts
#   └─ Currently: Testing edge cases
#
# Agent 3: "API documentation" - 89% complete
#   └─ Updated: docs/api.md, docs/auth.md
#   └─ Currently: Generating OpenAPI spec

# View specific agent details
codex agent view agent-1

# Cancel an agent
codex agent cancel agent-3

# Wait for all agents to complete
codex wait --all

Sandbox Specifications:
  OS: Ubuntu 22.04 LTS
  CPU: 4 vCPUs
  RAM: 16GB
  Storage: 50GB ephemeral
  Network: Configurable (default: restricted)
  Timeout: 30 minutes (default), up to 2 hours

Pre-installed:
  - Node.js 20.x, 18.x
  - Python 3.11, 3.10
  - Go 1.21
  - Rust 1.75
  - Java 21
  - .NET 8.0
  - Docker (rootless)
  - Common build tools (make, cmake, etc.)

Available on request:
  - Database servers (PostgreSQL, MySQL, Redis)
  - Custom Docker images
  - Specific language versions

# Enable network access for agents that need external APIs
codex task "Integrate Stripe payments" --sandbox-network=true

# Use a specific sandbox configuration
codex task "Build mobile app" --sandbox-config=mobile.yaml

# Custom sandbox with Docker
codex task "Test in production-like environment" \
  --sandbox-docker="postgres:15,redis:7"

# .codex/skills/security-review.yaml
name: security-review
description: Review code for security vulnerabilities
version: "1.0"

instructions: |
  Perform a comprehensive security review:

  1. OWASP Top 10 check:
     - SQL Injection
     - XSS
     - CSRF
     - Authentication issues
     - Access control
     - Security misconfiguration
     - Cryptographic failures

  2. Dependency vulnerabilities:
     - Run npm audit / pip-audit / cargo audit
     - Check for known CVEs

  3. Secret detection:
     - Scan for hardcoded credentials
     - Check for API keys in code
     - Verify .env files are gitignored

  4. Code patterns:
     - Unsafe deserialization
     - Command injection risks
     - Path traversal vulnerabilities

scripts:
  pre:
    - npm audit
    - npx secret-scanner
  post:
    - npm run lint:security

output:
  format: markdown
  sections:
    - severity_high
    - severity_medium
    - severity_low
    - recommendations

triggers:
  - on_pr: true
  - on_push_to: [main, develop]

# .codex/skills/migration-helper.yaml
name: migration-helper
description: Help migrate between versions/frameworks

parameters:
  from_version:
    type: string
    required: true
    description: Current version or framework
  to_version:
    type: string
    required: true
    description: Target version or framework

instructions: |
  Migrate codebase from {{from_version}} to {{to_version}}:

  1. Analyze current usage patterns
  2. Identify breaking changes between versions
  3. Create migration plan
  4. Implement changes systematically
  5. Update dependencies
  6. Fix type errors and deprecation warnings
  7. Run test suite, fix failures
  8. Update documentation

  Approach:
  - Make atomic commits for each logical change
  - Preserve git history where possible
  - Add migration notes as comments where behavior changed

# Run a skill
codex --skill security-review

# Run with parameters
codex --skill migration-helper \
  --param from_version="React 17" \
  --param to_version="React 19"

# List available skills
codex skills list

# Create skill from successful task
codex skills create-from-task task-abc123 --name my-new-skill

$ codex
Welcome to Codex! Type 'help' for commands.

codex> What does the payment processing module do?

The payment processing module (src/payments/) handles:
- Payment intent creation via Stripe
- Webhook handling for async payment events
- Refund processing
- Subscription management

Key files:
- stripe.ts: Stripe SDK wrapper
- webhooks.ts: Event handlers
- subscriptions.ts: Recurring billing logic

codex> There's a bug where refunds sometimes fail silently. Can you investigate?

I'll investigate the refund handling. Let me:
1. Read the refund code in src/payments/refunds.ts
2. Check the error handling patterns
3. Look at recent related commits

[Reading files...]

I found the issue. In `processRefund()` on line 45, errors from the Stripe
API are caught but not properly propagated:

```typescript
// Current (problematic):
try {
  await stripe.refunds.create({ payment_intent: intentId });
} catch (e) {
  console.error(e); // Error logged but not thrown
}

// Should be:
try {
  await stripe.refunds.create({ payment_intent: intentId });
} catch (e) {
  console.error('Refund failed:', e);
  throw new RefundError(e.message, { intentId, originalError: e });
}

#### CLI Commands Reference

```bash
# Authentication
codex auth login           # Sign in with ChatGPT account
codex auth logout          # Sign out
codex auth status          # Check authentication status

# Basic operations
codex "your prompt"        # Quick one-shot task
codex ask "question"       # Ask about codebase (no changes)
codex edit "instruction"   # Edit specific files
codex task "description"   # Full autonomous task

# Agent management
codex status               # List all agents
codex agent view <id>      # View agent details
codex agent logs <id>      # Stream agent logs
codex agent cancel <id>    # Cancel running agent
codex wait <id>            # Wait for agent completion
codex wait --all           # Wait for all agents

# Skills
codex --skill <name>       # Run a skill
codex skills list          # List available skills
codex skills show <name>   # Show skill details
codex skills create        # Create new skill
codex skills delete <name> # Delete a skill

# Configuration
codex config show          # Show current config
codex config set <k> <v>   # Set config value
codex init                 # Initialize project

# Git integration
codex pr create            # Create PR from agent result
codex pr list              # List Codex-created PRs

# Advanced
codex --model <name>       # Use specific model
codex --sandbox-network    # Enable network in sandbox
codex --timeout <mins>     # Set task timeout
codex --verbose            # Verbose output
codex --dry-run            # Preview without executing

# .codex/config.yaml (project-level)

# Model selection
model: gpt-5.2-codex          # Default model
model_fallback: gpt-4o        # Fallback if primary unavailable

# Approval modes
approval_mode: suggest        # suggest | auto-edit | full-auto
  # suggest: Shows diff, waits for approval
  # auto-edit: Applies non-breaking changes automatically
  # full-auto: Applies all changes (use with caution)

# Context configuration
context:
  include:
    - "src/**/*"
    - "tests/**/*"
    - "docs/**/*.md"
    - "*.json"
    - "*.yaml"
  exclude:
    - "node_modules/**"
    - "dist/**"
    - "*.log"
    - ".env*"
  max_files: 100              # Maximum files to include
  max_file_size: 100KB        # Skip files larger than this

# Skills configuration
skills:
  directory: .codex/skills
  enabled:
    - security-review
    - migration-helper
  disabled:
    - experimental-feature

# Sandbox configuration
sandbox:
  enabled: true
  network: false              # Disable network by default
  timeout: 1800               # 30 minutes
  memory: 16GB
  docker_images:              # Pre-pull these images
    - node:20
    - postgres:15

# Git integration
git:
  auto_commit: false          # Auto-commit changes
  commit_prefix: "[codex]"    # Prefix for commits
  branch_prefix: "codex/"     # Prefix for branches
  create_pr: prompt           # prompt | auto | never

# Output preferences
output:
  format: detailed            # minimal | detailed | verbose
  show_thinking: false        # Show agent reasoning
  syntax_highlight: true

# Safety settings
safety:
  max_files_modified: 20      # Warn if more files changed
  require_tests: true         # Require tests for new code
  no_force_push: true         # Prevent force pushes
  protected_files:            # Never modify these
    - ".env"
    - "secrets.yaml"

# ~/.codex/config.yaml (global defaults)

# Global preferences
default_model: gpt-5.2-codex
theme: dark
editor: code                  # Editor for viewing diffs

# Authentication
api_base_url: https://api.openai.com/v1

# Usage limits (for cost control)
limits:
  daily_tasks: 50
  concurrent_agents: 3
  warn_at_cost: 10.00

# Telemetry
telemetry: false

// VS Code settings.json
{
  "codex.enabled": true,
  "codex.model": "gpt-5.2-codex",

  // Inline suggestions (like Copilot)
  "codex.inlineSuggestions.enabled": true,
  "codex.inlineSuggestions.debounceMs": 200,

  // Agent panel
  "codex.agentPanel.position": "right",
  "codex.agentPanel.showOnStart": true,

  // Auto-apply settings
  "codex.autoApply.readOnlyOperations": true,
  "codex.autoApply.formatting": true,
  "codex.autoApply.imports": true,
  "codex.autoApply.codeChanges": false,

  // Keybindings
  "codex.keybindings.triggerAgent": "ctrl+shift+c",
  "codex.keybindings.explainSelection": "ctrl+shift+e",
  "codex.keybindings.fixError": "ctrl+shift+f"
}

// Cursor settings
{
  // Use Codex for agentic tasks, Cursor for autocomplete
  "cursor.autocomplete.enabled": true,
  "codex.inlineSuggestions.enabled": false,

  // Trigger Codex from Cursor
  "codex.cursorIntegration": true,
  "codex.cursorHotkey": "ctrl+shift+o"
}

# Create a batch file
cat > tasks.yaml << EOF
tasks:
  - name: "Add TypeScript types"
    files: ["src/legacy/*.js"]
    instruction: "Convert to TypeScript with strict types"

  - name: "Add error handling"
    files: ["src/api/*.ts"]
    instruction: "Add proper error handling with custom error classes"

  - name: "Generate tests"
    files: ["src/utils/*.ts"]
    instruction: "Generate comprehensive unit tests"
    depends_on: ["Add TypeScript types"]
EOF

# Run batch
codex batch tasks.yaml

# Monitor batch progress
codex batch status

# .github/workflows/codex-review.yaml
name: Codex Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run Codex Security Review
        uses: openai/codex-action@v2
        with:
          skill: security-review
          api-key: ${{ secrets.OPENAI_API_KEY }}

      - name: Run Codex Code Quality
        uses: openai/codex-action@v2
        with:
          prompt: |
            Review this PR for:
            - Code quality issues
            - Performance problems
            - Missing tests
            - Documentation gaps
          comment-on-pr: true

# GitLab CI integration
codex-review:
  stage: review
  image: openai/codex-cli:latest
  script:
    - codex auth login --token $OPENAI_API_KEY
    - codex --skill code-review --output=report.md
    - codex --skill security-review --output=security.md
  artifacts:
    reports:
      codequality: report.md

# Use a specific model version
codex --model gpt-5.2-codex-20250115 "task description"

# Adjust generation parameters
codex --temperature 0.2 --max-tokens 8192 "precise task"

# Use with fine-tuned model
codex --model ft:gpt-5.2-codex:my-org:my-finetune "specialized task"

# Start interactive session
gemini

> Explain the architecture of this project
[Analyzes codebase, provides overview]

> Generate a REST API for user management
[Creates complete API with routes, controllers, models]

> /image architecture.png What improvements would you suggest?
[Analyzes architecture diagram, provides recommendations]

# Generate code from description
gemini generate "A TypeScript function that validates credit card numbers using the Luhn algorithm"

# Output:
function validateCreditCard(cardNumber: string): boolean {
  // Remove spaces and dashes
  const cleaned = cardNumber.replace(/[\s-]/g, '');

  // Check if only digits
  if (!/^\d+$/.test(cleaned)) {
    return false;
  }

  // Luhn algorithm
  let sum = 0;
  let isEven = false;

  for (let i = cleaned.length - 1; i >= 0; i--) {
    let digit = parseInt(cleaned[i], 10);

    if (isEven) {
      digit *= 2;
      if (digit > 9) {
        digit -= 9;
      }
    }

    sum += digit;
    isEven = !isEven;
  }

  return sum % 10 === 0;
}

# Explain a file
gemini explain src/complex-algorithm.ts

# Review code

gemini review --security src/auth/

# Refactor
gemini refactor "Convert callbacks to async/await" src/legacy/

# Generate tests
gemini test src/utils/validation.ts -o tests/

# ~/.gemini/config.yaml
model: gemini-2.5-flash  # or gemini-3-flash for paid
temperature: 0.2
max_tokens: 8192

context:
  auto_include_open_files: true
  max_context_files: 50

output:
  format: markdown
  syntax_highlighting: true

project_detection:
  enabled: true
  config_files:
    - package.json
    - pyproject.toml
    - Cargo.toml
    - go.mod

# Start aider
aider

> Add input validation to the login form

# Aider:
# 1. Analyzes the codebase
# 2. Makes changes to relevant files
# 3. Automatically creates a git commit:
#    "feat: Add input validation to login form
#     - Added email format validation
#     - Added password strength requirements
#     - Added error message display"

# Use Claude
aider --model claude-3-5-sonnet

# Use GPT-4
aider --model gpt-4o

# Use local Ollama model
aider --model ollama/llama3.1

# Use DeepSeek
aider --model deepseek/deepseek-chat

# Start in watch mode
aider --watch

# Now edit files manually or with another tool
# Aider sees changes and can help integrate them

aider --architect

> Plan a microservices architecture for an e-commerce platform

# Aider creates a plan, then you approve before implementation

# .aider.conf.yml
model: claude-3-5-sonnet
auto-commits: true
commit-prompt: conventional  # conventional commits format

# File handling
auto-lint: true
lint-cmd: npm run lint
test-cmd: npm test

# Git settings
attribute-author: true
attribute-committer: true
dirty-commits: false

# Context
map-tokens: 1024
map-refresh: auto
subtree-only: false

# Add files to chat context
aider src/auth/*.ts tests/auth/*.ts

# Ask questions
aider --message "Explain how the auth flow works"

# Make changes
aider --message "Add rate limiting to the login endpoint"

# Review and fix
aider --message "Review this code for security issues and fix them"

# Generate tests
aider --message "Add comprehensive tests for the User model"

#!/bin/bash
# automated-review.sh

# Run aider in non-interactive mode for CI
aider --yes --message "
Review the changes in this PR for:
1. Security vulnerabilities
2. Performance issues
3. Code style violations

Fix any issues found.
" --model claude-3-5-sonnet

# Check if aider made changes
if [ -n "$(git status --porcelain)" ]; then
    echo "Aider found and fixed issues"
    git push
fi

Plan Mode (Read-Only):
├── Explore codebase
├── Analyze architecture
├── Create implementation strategy
└── No file modifications allowed

Act Mode (Execute):
├── Implement planned changes
├── Run commands
├── Create/modify files
└── Human approval for each action

# Configure different models for each mode
# Plan: Use cheaper/faster model for exploration
# Act: Use more capable model for implementation

# In Cline settings:
Plan Model: deepseek-chat (cost-effective)
Act Model: claude-sonnet-4 (high quality)

// Cline can:
// 1. Launch a headless browser
// 2. Navigate to your local dev server
// 3. Click, type, scroll
// 4. Capture screenshots
// 5. Read console logs
// 6. Fix runtime errors it discovers

// Example task:
"Test the login flow and fix any errors you find"

// Cline will:
// - Start dev server
// - Open browser to localhost:3000
// - Try to log in
// - Capture any errors
// - Fix the code
// - Verify the fix works

{
  "mcpServers": {
    "database": {
      "command": "node",
      "args": ["./mcp-servers/database.js"],
      "tools": [
        {
          "name": "query_database",
          "description": "Execute read-only SQL queries",
          "inputSchema": {
            "type": "object",
            "properties": {
              "query": { "type": "string" }
            }
          }
        }
      ]
    }
  }
}

// .vscode/settings.json
{
  "cline.apiProvider": "anthropic",
  "cline.apiKey": "${env:ANTHROPIC_API_KEY}",
  "cline.model": "claude-sonnet-4",

  "cline.planMode": {
    "enabled": true,
    "model": "deepseek-chat"
  },

  "cline.autoApprove": {
    "readFiles": true,
    "listFiles": true,
    "writeFiles": false,
    "executeCommands": false
  },

  "cline.contextWindow": 128000,
  "cline.maxTokens": 8192
}

Modes:
├── Code Mode
│   └── Implementation focused, writes code
├── Architect Mode
│   └── Planning focused, designs solutions
├── Ask Mode
│   └── Q&A focused, explains code
├── Debug Mode
│   └── Bug-finding focused, traces issues
└── Custom Modes
    └── User-defined personas

// Configure different models per mode
const modeConfig = {
  architect: {
    model: "o3",  // Best for planning
    systemPrompt: "You are a senior software architect..."
  },
  code: {
    model: "claude-sonnet-4",  // Best for implementation
    systemPrompt: "You are an expert programmer..."
  },
  debug: {
    model: "gpt-4o",  // Good at finding issues
    systemPrompt: "You are a debugging expert..."
  }
};

Boomerang Task Flow:

1. User: "Add user authentication"
   ↓
2. Architect Mode: Plans the implementation
   - Designs auth flow
   - Identifies files to create/modify
   - Creates task breakdown
   ↓
3. Code Mode: Implements each task
   - Creates auth middleware
   - Adds login/logout routes
   - Updates database schema
   ↓
4. Debug Mode: Verifies implementation
   - Runs tests
   - Checks for security issues
   - Validates edge cases
   ↓
5. Returns to User: Complete with summary

# Roo Code indexes your codebase
# - Function definitions
# - Class hierarchies
# - Import relationships
# - Test coverage mapping

# Query the index
"What functions call the validateUser method?"
"Show me all API endpoints that don't have tests"
"Find all places where we handle authentication errors"

// .roo/config.json
{
  "modes": {
    "architect": {
      "model": "anthropic/claude-sonnet-4",
      "temperature": 0.3
    },
    "code": {
      "model": "anthropic/claude-sonnet-4",
      "temperature": 0.2
    },
    "debug": {
      "model": "openai/gpt-4o",
      "temperature": 0.1
    }
  },
  "boomerang": {
    "enabled": true,
    "autoTransition": true
  },
  "indexing": {
    "enabled": true,
    "excludePaths": ["node_modules", "dist", ".git"]
  }
}

Orchestrator Flow:

User: "Build a REST API for a todo app"

Orchestrator:
├── 1. Architect Agent
│   └── Designs API structure, endpoints, database schema
├── 2. Code Agent
│   └── Implements routes, controllers, models
├── 3. Test Agent
│   └── Writes unit and integration tests
├── 4. Documentation Agent
│   └── Generates API docs and README
└── 5. Review Agent
    └── Checks for issues, suggests improvements

// Memory Bank stores:
// - Project architecture decisions
// - Coding conventions used
// - Previous task context
// - User preferences

// Example: Memory Bank remembers your patterns
Session 1: "Use Prisma for database"
Session 2: "Add a new model"
// Kilo automatically uses Prisma, not raw SQL

// Memory Bank file structure
.kilo/
├── memory/
│   ├── architecture.md    # Design decisions
│   ├── conventions.md     # Code style
│   ├── context.md         # Ongoing work
│   └── preferences.md     # User preferences

# Start on mobile (Kilo mobile app)
"Plan a caching system for the API"

# Continue on desktop (VS Code)
"Implement the caching plan"

# Finish on laptop (Cursor)
"Add tests for the cache"

# All context is preserved across devices

// kilo.config.json
{
  "orchestrator": {
    "enabled": true,
    "agents": ["architect", "code", "test", "docs", "review"]
  },
  "memoryBank": {
    "enabled": true,
    "syncToCloud": true
  },
  "models": {
    "default": "claude-sonnet-4",
    "planning": "gemini-3-pro",
    "coding": "claude-sonnet-4",
    "review": "gpt-4o"
  },
  "credits": {
    "warnAt": 5.00,
    "hardLimit": null
  }
}

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Pull Qwen Coder
ollama pull qwen2.5-coder:32b

# Run interactively
ollama run qwen2.5-coder:32b

# Or use with other tools

# Use Qwen Coder with Aider
aider --model ollama/qwen2.5-coder:32b

# Or via OpenRouter
aider --model openrouter/qwen/qwen-2.5-coder-32b-instruct

// Configure in VS Code settings
{
  "cline.apiProvider": "ollama",
  "cline.ollamaBaseUrl": "http://localhost:11434",
  "cline.model": "qwen2.5-coder:32b"
}

from openai import OpenAI

# Via OpenRouter
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="your-openrouter-key"
)

response = client.chat.completions.create(
    model="qwen/qwen-2.5-coder-32b-instruct",
    messages=[
        {
            "role": "system",
            "content": "You are an expert programmer."
        },
        {
            "role": "user",
            "content": "Write a Python function to validate email addresses"
        }
    ]
)

print(response.choices[0].message.content)

START
  │
  ├─ Do you need GitHub integration (PRs, issues)?
  │    └─ YES → GitHub Copilot
  │
  ├─ Do you work in terminal primarily?
  │    └─ YES → Claude Code or Gemini CLI
  │
  ├─ Do you need session memory across days?
  │    └─ YES → Windsurf
  │
  ├─ Do you do complex multi-file refactoring?
  │    └─ YES → Cursor or Claude Code
  │
  ├─ Are you budget-constrained?
  │    └─ YES → Gemini CLI (free) or Copilot ($10)
  │
  └─ DEFAULT → Cursor (best all-around)

# Recommended multi-tool setup
daily_development:
  primary: Cursor
  reason: "Fast autocomplete, Composer for features"

code_review:
  primary: Claude Code
  reason: "Deep codebase understanding for reviews"

pull_requests:
  primary: GitHub Copilot
  reason: "Native PR creation and GitHub integration"

exploration:
  primary: Gemini CLI
  reason: "Free, multimodal for architecture diagrams"

// 1. Use multi-cursor with AI
// Select multiple similar patterns, trigger AI to transform all

// 2. Chain Composer commands
/*
Composer:
1. Create a new API endpoint for /products
2. Add validation using Zod
3. Write integration tests
4. Update OpenAPI spec
*/

// 3. Use @codebase for project-wide context
// "@codebase What's the pattern for error handling here?"

# 1. Use workspace agents
gh copilot workspace "Add dark mode to the entire app"

# 2. Inline chat with /commands
# Select code, then:
# /explain - Understand code
# /fix - Fix bugs
# /simplify - Reduce complexity
# /optimize - Improve performance

# 3. Use Copilot in commits
git commit # Copilot suggests message based on diff

# 1. Use --depth for analysis depth
claude-code ask --depth deep "Analyze security vulnerabilities"

# 2. Chain commands with pipes
claude-code explain src/auth.ts | claude-code task "Add the missing error handling"

# 3. Use templates for common tasks
claude-code task --template api-endpoint "Create /users/search"

import * as vscode from 'vscode';

export function activate(context: vscode.ExtensionContext) {
  // Register custom AI command
  const disposable = vscode.commands.registerCommand(
    'myExtension.aiRefactor',
    async () => {
      const editor = vscode.window.activeTextEditor;
      if (!editor) return;

      const selection = editor.document.getText(editor.selection);

      // Call your preferred AI API
      const response = await callAI({
        prompt: `Refactor this code for better readability:\n\n${selection}`,
        model: 'claude-sonnet-4'
      });

      // Replace selection with AI response
      editor.edit(editBuilder => {
        editBuilder.replace(editor.selection, response.code);
      });
    }
  );

  context.subscriptions.push(disposable);
}

async function callAI(params: { prompt: string; model: string }) {
  // Implement API call to Claude, OpenAI, etc.
  const response = await fetch('https://api.anthropic.com/v1/messages', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': process.env.ANTHROPIC_API_KEY!,
      'anthropic-version': '2024-01-01'
    },
    body: JSON.stringify({
      model: params.model,
      max_tokens: 4096,
      messages: [{ role: 'user', content: params.prompt }]
    })
  });

  return response.json();
}

#!/usr/bin/env python3
"""
Custom AI coding assistant CLI that combines multiple providers.
"""

import click
import os
from anthropic import Anthropic
from openai import OpenAI

anthropic = Anthropic()
openai = OpenAI()

@click.group()
def cli():
    """Multi-provider AI coding assistant."""
    pass

@cli.command()
@click.argument('file')
@click.option('--provider', '-p', default='claude', help='AI provider')
def explain(file: str, provider: str):
    """Explain a code file."""
    with open(file, 'r') as f:
        code = f.read()

    prompt = f"Explain this code in detail:\n\n```\n{code}\n```"

    if provider == 'claude':
        response = anthropic.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4096,
            messages=[{"role": "user", "content": prompt}]
        )
        click.echo(response.content[0].text)
    elif provider == 'openai':
        response = openai.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}]
        )
        click.echo(response.choices[0].message.content)

@cli.command()
@click.argument('instruction')
@click.argument('files', nargs=-1)
@click.option('--dry-run', is_flag=True, help='Show changes without applying')
def edit(instruction: str, files: tuple, dry_run: bool):
    """Edit files based on instruction."""
    for file in files:
        with open(file, 'r') as f:
            original = f.read()

        prompt = f"""Edit this code according to the instruction.

Instruction: {instruction}

Code:

Return only the modified code, no explanations."""

        response = anthropic.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=8192,
            messages=[{"role": "user", "content": prompt}]
        )

        new_code = response.content[0].text

        if dry_run:
            click.echo(f"=== Changes for {file} ===")
            # Show diff
            import difflib
            diff = difflib.unified_diff(
                original.splitlines(keepends=True),
                new_code.splitlines(keepends=True),
                fromfile=f'{file} (original)',
                tofile=f'{file} (modified)'
            )
            click.echo(''.join(diff))
        else:
            with open(file, 'w') as f:
                f.write(new_code)
            click.echo(f"Updated {file}")

@cli.command()
@click.argument('description')
@click.option('--output', '-o', default='.', help='Output directory')
def generate(description: str, output: str):
    """Generate code from description."""
    prompt = f"""Generate production-ready code for:

{description}

Include:
- TypeScript types
- Error handling
- JSDoc comments
- Unit tests

Format response as:
=== filename.ts ===
<code>
=== filename.test.ts ===
<code>
"""

    response = anthropic.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=8192,
        messages=[{"role": "user", "content": prompt}]
    )

    content = response.content[0].text

    # Parse and create files
    import re
    files = re.split(r'=== (.+?) ===', content)

    for i in range(1, len(files), 2):
        filename = files[i].strip()
        code = files[i + 1].strip()

        filepath = os.path.join(output, filename)
        os.makedirs(os.path.dirname(filepath) or '.', exist_ok=True)

        with open(filepath, 'w') as f:
            f.write(code)
        click.echo(f"Created {filepath}")

if __name__ == '__main__':
    cli()