// Cursor's model selection system
interface ModelConfig {
  provider: 'openai' | 'anthropic' | 'google' | 'local';
  model: string;
  contextWindow: number;
  capabilities: ('completion' | 'chat' | 'refactor' | 'debug')[];
}
const cursorModels: Record = {
  'gpt-4-turbo': {
    provider: 'openai',
    model: 'gpt-4-turbo-2024-04-09',
    contextWindow: 128000,
    capabilities: ['completion', 'chat', 'refactor', 'debug'],
  },
  'claude-3.5-sonnet': {
    provider: 'anthropic',
    model: 'claude-3-5-sonnet-20241022',
    contextWindow: 200000,
    capabilities: ['completion', 'chat', 'refactor', 'debug'],
  },
  'gemini-2.0-flash': {
    provider: 'google',
    model: 'gemini-2.0-flash-exp',
    contextWindow: 1000000,
    capabilities: ['completion', 'chat', 'debug'],
  },
};
// Automatic model selection based on task
function selectOptimalModel(
  task: 'completion' | 'chat' | 'refactor' | 'debug',
  codebaseSize: number,
  priority: 'speed' | 'quality'
): ModelConfig {
  if (task === 'completion' && priority === 'speed') {
    return cursorModels['gemini-2.0-flash'];
  }
  if (task === 'refactor' || task === 'debug') {
    return cursorModels['claude-3.5-sonnet'];
  }
  return cursorModels['gpt-4-turbo'];
}

// Example: Cursor predicts entire function implementations
// Type this comment:
// Create a function to process user authentication with JWT
// Cursor suggests:
async function authenticateUser(
  email: string,
  password: string
): Promise<{ token: string; user: User } | null> {
  // Validate credentials
  const user = await db.user.findUnique({
    where: { email },
    select: { id: true, email: true, passwordHash: true, role: true }
  });
  if (!user) return null;
  const isValid = await bcrypt.compare(password, user.passwordHash);
  if (!isValid) return null;
  // Generate JWT token
  const token = jwt.sign(
    { userId: user.id, email: user.email, role: user.role },
    process.env.JWT_SECRET!,
    { expiresIn: '7d' }
  );
  return {
    token,
    user: { id: user.id, email: user.email, role: user.role }
  };
}
// Cursor understands:
// 1. Your database schema (Prisma)
// 2. Your auth patterns (JWT)
// 3. Security best practices (bcrypt)
// 4. Your code style preferences

// User prompt: "Add user avatar upload with S3 integration"
// Cursor generates across multiple files:
// 1. lib/s3.ts
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
const s3Client = new S3Client({
  region: process.env.AWS_REGION!,
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
  },
});
export async function uploadToS3(
  file: Buffer,
  fileName: string,
  contentType: string
): Promise {
  const key = avatars/${Date.now()}-${fileName};
  await s3Client.send(
    new PutObjectCommand({
      Bucket: process.env.S3_BUCKET!,
      Key: key,
      Body: file,
      ContentType: contentType,
    })
  );
  return https://${process.env.S3_BUCKET}.s3.${process.env.AWS_REGION}.amazonaws.com/${key};
}
// 2. app/api/upload-avatar/route.ts
import { uploadToS3 } from "@/lib/s3";
import { auth } from "@/lib/auth";
export async function POST(req: Request) {
  const session = await auth.getSession(req);
  if (!session) {
    return Response.json({ error: "Unauthorized" }, { status: 401 });
  }
  const formData = await req.formData();
  const file = formData.get("avatar") as File;
  if (!file) {
    return Response.json({ error: "No file provided" }, { status: 400 });
  }
  const buffer = Buffer.from(await file.arrayBuffer());
  const url = await uploadToS3(buffer, file.name, file.type);
  await db.user.update({
    where: { id: session.user.id },
    data: { avatarUrl: url },
  });
  return Response.json({ url });
}
// 3. components/AvatarUpload.tsx
'use client';
import { useState } from 'react';
export function AvatarUpload() {
  const [uploading, setUploading] = useState(false);
  const [avatarUrl, setAvatarUrl] = useState();
  const handleUpload = async (e: React.ChangeEvent) => {
    const file = e.target.files?.[0];
    if (!file) return;
    setUploading(true);
    const formData = new FormData();
    formData.append('avatar', file);
    const res = await fetch('/api/upload-avatar', {
      method: 'POST',
      body: formData,
    });
    const data = await res.json();
    setAvatarUrl(data.url);
    setUploading(false);
  };
  return (
    

      
      {avatarUrl && }
    
  );
}

// Error in production:
// TypeError: Cannot read property 'map' of undefined at UsersList.tsx:15
// Cursor analyzes the error:
function UsersList() {
  const users = useQuery(api.users.list);
  return (
    

      {/* Line 15 - Error here */}
      {users.map(user => )}
    
  );
}

// Cursor identifies the issue and suggests:
// "The useQuery hook returns undefined during loading. Add loading state:"
function UsersList() {
  const users = useQuery(api.users.list);
  // Cursor's suggested fix
  if (users === undefined) {
    return ;
  }
  if (users.length === 0) {
    return ;
  }
  return (
    

      {users.map(user => )}
    
  );
}

// Cursor also explains:
// "The Convex useQuery hook returns undefined while loading.
//  Always check for undefined before using the data to prevent runtime errors."

// In chat: "@auth.ts How does password hashing work?"
// Cursor responds with context:
"In @auth.ts, password hashing uses bcrypt with 10 salt rounds:
1. During registration (lines 45-52):During registration (lines 45-52):
   
- User password is hashed using bcrypt.hash()
   - Salt rounds are set to 10 for security
   - Hashed password stored in database
2. During login (lines 78-85):During login (lines 78-85):
   
- Stored hash retrieved from database
   - bcrypt.compare() validates input against hash
   - Returns boolean for authentication
The bcrypt algorithm is intentionally slow to prevent
brute-force attacks. Consider increasing salt rounds to
12 for enhanced security."
// User: "Update to use argon2 instead"
// Cursor modifies @auth.ts:
import * as argon2 from 'argon2';
// Registration
const passwordHash = await argon2.hash(password, {
  type: argon2.argon2id,
  memoryCost: 65536,
  timeCost: 3,
  parallelism: 4,
});
// Login
const isValid = await argon2.verify(user.passwordHash, password);

// .cursorrules file for privacy configuration
{
  "privacy": {
    "mode": "strict",
    "disableCodeIndexing": true,
    "localModels": {
      "enabled": true,
      "models": ["codellama:7b", "deepseek-coder:6.7b"]
    },
    "excludePaths": [
      ".env",
      "*.key",
      "credentials/*",
      "secrets.json"
    ],
    "redactPatterns": [
      "API_KEY=.*",
      "PASSWORD=.*",
      "SECRET=.*"
    ]
  },
  "aiProviders": {
    "default": "local",
    "fallback": "anthropic-eu" // EU-hosted Claude
  }
}
// Local model usage
// Cursor automatically uses local models when available:
// - Code completion: CodeLlama
// - Chat: DeepSeek Coder
// - External API calls: None

// Prompt: "Implement real-time notifications system with WebSocket"
// 1. WebSocket server (lib/websocket.ts)
import { WebSocketServer } from 'ws';
const wss = new WebSocketServer({ port: 8080 });
const clients = new Map>();
export function broadcastToUser(userId: string, message: any) {
  const userClients = clients.get(userId);
  if (!userClients) return;
  userClients.forEach(client => {
    if (client.readyState === WebSocket.OPEN) {
      client.send(JSON.stringify(message));
    }
  });
}
wss.on('connection', (ws, req) => {
  const userId = new URL(req.url!, 'ws://localhost').searchParams.get('userId');
  if (!userId) {
    ws.close();
    return;
  }
  if (!clients.has(userId)) {
    clients.set(userId, new Set());
  }
  clients.get(userId)!.add(ws);
  ws.on('close', () => {
    clients.get(userId)?.delete(ws);
  });
});
// 2. Notification service (lib/notifications.ts)
import { broadcastToUser } from './websocket';
export async function sendNotification(
  userId: string,
  notification: {
    type: 'message' | 'mention' | 'system';
    title: string;
    body: string;
  }
) {
  // Save to database
  await db.notification.create({
    data: {
      userId,
      ...notification,
      createdAt: new Date(),
    },
  });
  // Broadcast real-time
  broadcastToUser(userId, notification);
}
// 3. React hook (hooks/useNotifications.ts)
import { useEffect, useState } from 'react';
export function useNotifications(userId: string) {
  const [notifications, setNotifications] = useState([]);
  const [ws, setWs] = useState(null);
  useEffect(() => {
    const websocket = new WebSocket(
      ws://localhost:8080?userId=${userId}
    );
    websocket.onmessage = (event) => {
      const notification = JSON.parse(event.data);
      setNotifications(prev => [notification, ...prev]);
    };
    setWs(websocket);
    return () => {
      websocket.close();
    };
  }, [userId]);
  return { notifications, ws };
}
// Cursor generated a complete real-time notification system
// across 3 files with proper WebSocket handling, database
// persistence, and React integration

// Original code with performance issues:
function ProductList({ categoryId }: { categoryId: string }) {
  const [products, setProducts] = useState([]);
  useEffect(() => {
    // Problem: Fetches on every render
    fetch(/api/products?category=${categoryId})
      .then(res => res.json())
      .then(data => setProducts(data));
  }, [categoryId]);
  return (
    

      {products.map(product => (
        

           {/* No optimization */}
          
{product.name}
          
${product.price}
          {/* Heavy computation on every render */}
          
Discount: {calculateDiscount(product)}
        
      ))}
    
  );
}

// Cursor refactoring: "Optimize this component for performance"
// Refactored version:
import { useQuery } from '@tanstack/react-query';
import Image from 'next/image';
import { useMemo } from 'react';
function ProductList({ categoryId }: { categoryId: string }) {
  // ✅ Proper data fetching with caching
  const { data: products = [], isLoading } = useQuery({
    queryKey: ['products', categoryId],
    queryFn: () =>
      fetch(/api/products?category=${categoryId}).then(res => res.json()),
    staleTime: 5 * 60 * 1000, // Cache for 5 minutes
  });
  // ✅ Memoized discount calculations
  const productsWithDiscounts = useMemo(
    () => products.map(product => ({
      ...product,
      discount: calculateDiscount(product)
    })),
    [products]
  );
  if (isLoading) return ;
  return (
    

      {productsWithDiscounts.map(product => (
        
      ))}
    
  );
}

// ✅ Memoized card component
const ProductCard = memo(({ product }: { product: ProductWithDiscount }) => (
  

    {/* ✅ Optimized image loading */}
    
    
{product.name}
    
${product.price}
    
Discount: {product.discount}%
  
));

// Original function:
export async function processOrder(orderId: string) {
  const order = await db.order.findUnique({ where: { id: orderId } });
  if (!order) throw new Error('Order not found');
  if (order.status !== 'pending') {
    throw new Error('Order already processed');
  }
  const payment = await stripe.charges.create({
    amount: order.total,
    currency: 'usd',
    source: order.paymentToken,
  });
  await db.order.update({
    where: { id: orderId },
    data: { status: 'processing', paymentId: payment.id },
  });
  return { success: true, paymentId: payment.id };
}
// Cursor: "Generate comprehensive tests for this function"
// Generated tests:
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { processOrder } from './processOrder';
import { db } from '@/lib/db';
import Stripe from 'stripe';
vi.mock('@/lib/db');
vi.mock('stripe');
describe('processOrder', () => {
  const mockOrder = {
    id: 'order-123',
    status: 'pending',
    total: 5000,
    paymentToken: 'tok_visa',
  };
  beforeEach(() => {
    vi.clearAllMocks();
  });
  it('should process a valid order successfully', async () => {
    vi.mocked(db.order.findUnique).mockResolvedValue(mockOrder);
    vi.mocked(stripe.charges.create).mockResolvedValue({
      id: 'ch_123',
    } as any);
    const result = await processOrder('order-123');
    expect(result).toEqual({ success: true, paymentId: 'ch_123' });
    expect(db.order.update).toHaveBeenCalledWith({
      where: { id: 'order-123' },
      data: { status: 'processing', paymentId: 'ch_123' },
    });
  });
  it('should throw error if order not found', async () => {
    vi.mocked(db.order.findUnique).mockResolvedValue(null);
    await expect(processOrder('invalid-id')).rejects.toThrow(
      'Order not found'
    );
  });
  it('should throw error if order already processed', async () => {
    vi.mocked(db.order.findUnique).mockResolvedValue({
      ...mockOrder,
      status: 'completed',
    });
    await expect(processOrder('order-123')).rejects.toThrow(
      'Order already processed'
    );
  });
  it('should handle payment failure', async () => {
    vi.mocked(db.order.findUnique).mockResolvedValue(mockOrder);
    vi.mocked(stripe.charges.create).mockRejectedValue(
      new Error('Payment declined')
    );
    await expect(processOrder('order-123')).rejects.toThrow(
      'Payment declined'
    );
  });
  it('should validate order total before payment', async () => {
    const invalidOrder = { ...mockOrder, total: -100 };
    vi.mocked(db.order.findUnique).mockResolvedValue(invalidOrder);
    await expect(processOrder('order-123')).rejects.toThrow();
  });
});

// Accepting AI suggestion without verification
// Cursor suggests:
async function deleteUser(userId: string) {
  await db.user.delete({ where: { id: userId } });
  return { success: true };
}

// Issues:
// - No authorization check
// - No cascade deletion of related data
// - No audit logging

// Properly reviewed implementation
async function deleteUser(userId: string, requesterId: string) {
  // ✅ Authorization check
  const requester = await db.user.findUnique({
    where: { id: requesterId }
  });

  if (!requester?.isAdmin && requesterId !== userId) {
    throw new Error('Unauthorized');
  }
  // ✅ Cascade deletion
  await db.$transaction([
    db.post.deleteMany({ where: { authorId: userId } }),
    db.comment.deleteMany({ where: { userId } }),
    db.user.delete({ where: { id: userId } }),
  ]);
  // ✅ Audit logging
  await db.auditLog.create({
    data: {
      action: 'USER_DELETE',
      performedBy: requesterId,
      targetId: userId,
      timestamp: new Date(),
    },
  });
  return { success: true };
}

// Sharing sensitive code with cloud AI
// .env file contents visible to AI
DATABASE_URL="postgresql://admin:secretpass@prod.db.com/app"
STRIPE_SECRET_KEY="sk_live_51H..."
AWS_SECRET_ACCESS_KEY="wJalr..."

// Cursor sends this context to OpenAI for completion

// Configure privacy mode in .cursorrules
{
  "privacy": {
    "excludePaths": [".env", "*.key", "credentials/*"],
    "redactPatterns": ["PASSWORD=.*", "SECRET.*=.*", ".*_KEY=.*"],
    "useLocalModels": true
  }
}

// Use environment variable references
const config = {
  database: process.env.DATABASE_URL,
  stripe: process.env.STRIPE_SECRET_KEY,
  aws: {
    secretKey: process.env.AWS_SECRET_ACCESS_KEY,
  },
};

// Generic AI response without context
// Prompt: "Create a user service"

// AI suggests generic implementation
class UserService {
  async getUser(id: number) {
    return await database.query('SELECT * FROM users WHERE id = ?', [id]);
  }
}

// Properly contextualized with @-mentions
// Prompt: "Create user service using @lib/db.ts patterns and @types/user.ts"

// AI suggests implementation matching your codebase:
import { db } from '@/lib/db';
import { UserWithProfile } from '@/types/user';
export class UserService {
  async getUserWithProfile(id: string): Promise {
    // Uses your Prisma client patterns
    return await db.user.findUnique({
      where: { id },
      include: {
        profile: true,
        posts: {
          where: { published: true },
          orderBy: { createdAt: 'desc' },
          take: 10,
        },
      },
    });
  }
  // Matches your error handling patterns
  async updateUser(id: string, data: Partial) {
    try {
      return await db.user.update({
        where: { id },
        data,
      });
    } catch (error) {
      throw new DatabaseError('Failed to update user', { cause: error });
    }
  }
}

// Slow workflow: Mouse-based AI interaction
1. Click chat iconClick chat icon
2. Type questionType question
3. Wait for responseWait for response
4. Copy code manuallyCopy code manually
5. Paste into filePaste into file
6. Format codeFormat code

// Optimized keyboard workflow
Cmd+K          → Quick AI command
Cmd+Shift+K    → AI chat
Cmd+L          → Apply AI suggestion
Cmd+Shift+L    → Reject AI suggestion
Cmd+I          → Inline AI edit
Tab            → Accept completion
Esc            → Dismiss completion

// Custom keybindings in settings.json
{
  "cursor.keybindings": {
    "quickFix": "Cmd+.",
    "explainCode": "Cmd+Shift+E",
    "generateTests": "Cmd+Shift+T",
    "refactorSelection": "Cmd+Shift+R"
  }
}

// .cursorrules - Project-specific AI instructions
{
  "rules": [
    "Use TypeScript strict mode for all files",
    "Prefer React Server Components over Client Components",
    "Use Prisma for database operations with proper error handling",
    "Follow Airbnb style guide for code formatting",
    "Include JSDoc comments for all public functions",
    "Use Zod for runtime validation",
    "Implement proper loading and error states in React components"
  ],
  "codeStyle": {
    "quotes": "single",
    "semicolons": true,
    "trailingComma": "all",
    "arrowParens": "always"
  },
  "frameworks": {
    "primary": "Next.js 14 with App Router",
    "ui": "shadcn/ui + Tailwind CSS",
    "orm": "Prisma",
    "validation": "Zod"
  },
  "testing": {
    "framework": "Vitest",
    "coverage": "minimum 80%",
    "patterns": "Write tests for all business logic"
  }
}

// Composer excels at coordinated changes across files
// Prompt: "Add authentication to all API routes"
// Cursor modifies:
// 1. middleware.ts
export { default } from "next-auth/middleware";
export const config = {
  matcher: ["/api/:path*", "/dashboard/:path*"],
};
// 2. Each API route
import { auth } from "@/lib/auth";
export async function GET(req: Request) {
  const session = await auth.getSession(req);
  if (!session) {
    return Response.json({ error: "Unauthorized" }, { status: 401 });
  }
  // ... existing logic
}
// 3. lib/auth.ts
// Adds centralized auth configuration
// 4. types/next-auth.d.ts
// Adds TypeScript types for session

// Original code
function calculateShipping(items, destination) {
  const weight = items.reduce((sum, item) => sum + item.weight, 0);
  const distance = getDistance(origin, destination);
  return weight * 0.05 + distance * 0.1;
}
// Cursor: "Add comprehensive documentation"
/**
 * Calculates shipping cost based on package weight and delivery distance
 *
 * @param items - Array of items to be shipped
 * @param items[].weight - Weight of individual item in pounds
 * @param destination - Delivery destination address
 * @param destination.zipCode - Destination ZIP code
 * @param destination.country - Destination country code (ISO 3166-1 alpha-2)
 *
 * @returns Total shipping cost in USD
 *
 * @example
 * const cost = calculateShipping(
 *   [{ weight: 5 }, { weight: 3 }],
 *   { zipCode: '90210', country: 'US' }
 * );
 * console.log(cost); // 12.50
 *
 * @remarks
 * Cost calculation:
 * - Base rate: $0.05 per pound
 * - Distance rate: $0.10 per mile
 * - International orders include customs processing fee
 *
 * @throws {Error} If destination country is not supported
 */
function calculateShipping(
  items: Array<{ weight: number }>,
  destination: { zipCode: string; country: string }
): number {
  const weight = items.reduce((sum, item) => sum + item.weight, 0);
  const distance = getDistance(origin, destination);
  return weight * 0.05 + distance * 0.1;
}

// .cursor/commands.json - Custom AI commands
{
  "commands": [
    {
      "name": "Add API Endpoint",
      "description": "Create Next.js API route with auth",
      "prompt": "Create a new API endpoint in app/api/{input}/route.ts with authentication, input validation using Zod, proper error handling, and TypeScript types"
    },
    {
      "name": "Generate Component",
      "description": "Create React component with tests",
      "prompt": "Create a React component in components/{input}.tsx following our shadcn/ui patterns, include PropTypes, add Storybook story, and generate Vitest tests"
    },
    {
      "name": "Database Migration",
      "description": "Create Prisma migration",
      "prompt": "Create Prisma migration for {input}, update schema.prisma, generate migration files, and update TypeScript types"
    }
  ]
}
// Usage: Cmd+Shift+P → "Add API Endpoint" → Enter "users"
// Cursor generates complete API route with all patterns

One-click migration from VS Code
Cursor automatically imports:
- Extensions
- Keybindings
- Settings
- Theme
- Snippets
Manual migration if needed:
cp ~/Library/Application\ Support/Code/User/settings.json    ~/Library/Application\ Support/Cursor/User/settings.json
Migrate extensions
code --list-extensions | xargs -L 1 cursor --install-extension

// .cursor/team.json - Shared team configuration
{
  "aiProvider": "anthropic", // Consistent model across team
  "sharedRules": true,
  "privacyMode": "strict",
  "extensions": {
    "required": [
      "dbaeumer.vscode-eslint",
      "esbenp.prettier-vscode",
      "prisma.prisma",
      "bradlc.vscode-tailwindcss"
    ]
  },
  "workspaceSettings": {
    "editor.formatOnSave": true,
    "editor.codeActionsOnSave": {
      "source.fixAll.eslint": true
    }
  }
}

.github/workflows/ai-review.yml
name: AI Code Review
on:
  pull_request:
    types: [opened, synchronize]
jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: AI Code Review
        uses: cursor-ai/review-action@v1
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          openai-api-key: ${{ secrets.OPENAI_API_KEY }}
          review-level: strict
          auto-comment: true
      - name: Check Code Quality
        run: |
          npm run lint
          npm run type-check
          npm run test

Download Cursor
Visit https://cursor.sh and download for your platform
Or install via CLI
curl -fsSL https://cursor.sh/install.sh | sh
For macOS via Homebrew
brew install --cask cursor
Launch Cursor
cursor .

// .cursor/settings.json
{
  "cursor.ai.provider": "anthropic",
  "cursor.ai.model": "claude-3-5-sonnet-20241022",
  "cursor.ai.contextWindow": 200000,
  "cursor.privacy.mode": "balanced",
  "cursor.completion.enabled": true,
  "cursor.chat.enabled": true,
  "cursor.composer.enabled": true,
  "cursor.linter.aiSuggestions": true,
  "cursor.telemetry": false
}

// Step 1: Open Cursor and load your project
// cursor /path/to/your/project
// Step 2: Try AI completion
// Start typing and Tab to accept suggestions
function calculateTotal(items: CartItem[]) {
  // Type: "sum up prices and apply tax"
  // Tab to accept Cursor's suggestion
}
// Step 3: Use Cmd+K for AI commands
// Cmd+K → "Optimize this function for performance"
// Step 4: Open Composer (Cmd+Shift+K)
// "Add user authentication with email/password and Google OAuth"
// Step 5: Use @-mentions for context
// "Update @lib/db.ts to use connection pooling"

Code Generation Speed:     3x faster
Debugging Time:           60% reduction
Code Review Time:         30% reduction
Documentation Writing:    5x faster
Test Coverage:           40% increase
Developer Satisfaction:   80% approval

Companies Using Cursor:   30,000+
Daily Active Developers:  500,000+
Code Completions/Day:     50 million+
AI Chat Interactions:     10 million+