DeepSeek Coding in Practice: Cursor, VS Code & GitHub Copilot Integration Guide

AI-assisted programming has evolved from an "experimental" phase into an everyday productivity tool. With its open-source nature, low cost, and high performance, DeepSeek is becoming the preferred coding assistant for an increasing number of developers. This guide walks you through integrating DeepSeek into Cursor IDE and VS Code from scratch, along with a comprehensive comparison against GitHub Copilot.

1. DeepSeek Coder Model Family Overview

DeepSeek offers several specialized models for code generation:

DeepSeek Coder V2 is built on the MoE architecture and specifically trained on 6 trillion tokens of code corpora, covering GitHub public repositories, Stack Overflow, and technical documentation. It excels at FIM (Fill-in-the-Middle) completion tasks, making it particularly suitable for inline IDE completion scenarios.

DeepSeek V3 is the most capable model overall. It inherits the code generation strengths of the Coder series while integrating natural language understanding, allowing it to interpret vague requirements and convert them into high-quality code.

2. DeepSeek V3 Programming Benchmark Results

DeepSeek V3 has achieved impressive results across multiple programming benchmarks:

Key takeaways:

• SWE-bench Verified 49.2%: Real-world GitHub issue resolution. DeepSeek V3 approaches Claude 3.5 Sonnet and significantly outperforms GPT-4o
• HumanEval 90.2%: Function-level code generation, on par with GPT-4o
• LiveCodeBench 40.5%: Competition-level programming problems with live updates — DeepSeek V3 ranks first among open-source models
• Codeforces 1730: Equivalent to human Expert-level competitive programming

Achieving GPT-4o-level programming capability at 1/30th the price — that's DeepSeek's core value proposition.

3. Integrating DeepSeek with Cursor IDE

Cursor is an AI-first IDE built on VS Code that natively supports custom model integration. Here's the complete setup guide.

3.1 Obtain a DeepSeek API Key

# Register at the DeepSeek Open Platform
# URL: https://platform.deepseek.com

# Or use a third-party provider like Atlas Cloud
# URL: https://www.atlascloud.ai/collections/deepseek

After registration, go to the console, create a new API Key, and store it securely. DeepSeek offers free credits for new users to test the service.

3.2 Configure DeepSeek in Cursor

Method 1: Via Cursor Settings UI

1. Open Cursor, press Cmd + , (macOS) or Ctrl + , (Windows/Linux) to open Settings
2. Search for Models and navigate to the model configuration page
3. Click + Add Model and fill in:

{
  "model": "deepseek-chat",
  "apiKey": "sk-your-api-key",
  "baseUrl": "https://api.deepseek.com/v1"
}

Method 2: Edit the Cursor Configuration File

Create or edit .cursor/settings.json in your project root:

{
  "models": {
    "deepseek-v3": {
      "provider": "openai-compatible",
      "model": "deepseek-chat",
      "apiBase": "https://api.deepseek.com/v1",
      "apiKey": "sk-your-api-key",
      "contextLength": 65536,
      "temperature": 0.0
    },
    "deepseek-coder": {
      "provider": "openai-compatible",
      "model": "deepseek-coder",
      "apiBase": "https://api.deepseek.com/v1",
      "apiKey": "sk-your-api-key",
      "contextLength": 65536,
      "temperature": 0.0
    },
    "deepseek-reasoner": {
      "provider": "openai-compatible",
      "model": "deepseek-reasoner",
      "apiBase": "https://api.deepseek.com/v1",
      "apiKey": "sk-your-api-key",
      "contextLength": 65536,
      "temperature": 0.0
    }
  }
}

3.3 Choosing the Best Model

In Cursor's chat panel, use the model selector to switch:

• Daily code completion: Choose deepseek-chat (DeepSeek V3) — fast and cost-effective
• Complex debugging / architecture design: Choose deepseek-reasoner (DeepSeek R1) — deep reasoning capabilities
• Inline completion (Tab completion): Choose deepseek-coder — optimized for FIM

3.4 Using DeepSeek in Cursor

In Cursor, you can use DeepSeek in the following ways:

# Select code and press Cmd+K, then type instructions for DeepSeek to refactor
# Example: Refactor the synchronous code below to an async version

import requests

def fetch_user_data(user_id):
    """获取用户数据（同步版本）"""
    response = requests.get(f"https://api.example.com/users/{user_id}")
    return response.json()

# DeepSeek automatically generates:
import aiohttp
import asyncio

async def fetch_user_data(user_id):
    """获取用户数据（异步版本，由 DeepSeek 生成）"""
    async with aiohttp.ClientSession() as session:
        async with session.get(f"https://api.example.com/users/{user_id}") as response:
            return await response.json()

4. VS Code + Continue Plugin Integration

Continue is an open-source AI coding assistant plugin that supports any OpenAI-compatible API.

4.1 Install Continue

1. Open VS Code
2. Go to the Extensions Marketplace (Cmd+Shift+X)
3. Search for Continue and install
4. After installation, the Continue icon appears in the sidebar

4.2 Configure DeepSeek as Backend

Open the Continue configuration file (located at ~/.continue/config.json) and edit:

{
  "models": [
    {
      "title": "DeepSeek V3",
      "provider": "openai",
      "model": "deepseek-chat",
      "apiBase": "https://api.deepseek.com/v1",
      "apiKey": "sk-your-api-key",
      "contextLength": 65536,
      "completionOptions": {
        "temperature": 0.0,
        "maxTokens": 4096
      }
    },
    {
      "title": "DeepSeek R1 (Reasoning)",
      "provider": "openai",
      "model": "deepseek-reasoner",
      "apiBase": "https://api.deepseek.com/v1",
      "apiKey": "sk-your-api-key",
      "contextLength": 65536,
      "completionOptions": {
        "temperature": 0.0,
        "maxTokens": 8192
      }
    }
  ],
  "tabAutocompleteModel": {
    "title": "DeepSeek Coder FIM",
    "provider": "openai",
    "model": "deepseek-coder",
    "apiBase": "https://api.deepseek.com/v1",
    "apiKey": "sk-your-api-key"
  },
  "allowAnonymousTelemetry": false
}

4.3 Continue Core Features

After configuration, use the following shortcuts:

// Example: Select the following code in Continue, press Cmd+I,
// and type "add error handling and retry logic"

async function callAPI(url: string): Promise<any> {
  // 原始代码
  const response = await fetch(url);
  return response.json();
}

// DeepSeek generates the optimized version:
async function callAPI(url: string, maxRetries: number = 3): Promise<any> {
  // 重试逻辑，支持指数退避
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP 错误: ${response.status}`);
      }
      return await response.json();
    } catch (error) {
      // 最后一次重试仍然失败则抛出异常
      if (attempt === maxRetries - 1) {
        throw new Error(`请求失败，已重试 ${maxRetries} 次: ${error}`);
      }
      // 指数退避等待
      const delay = Math.pow(2, attempt) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

5. VS Code + Cline Plugin Integration

Cline (formerly Claude Dev) is an autonomous coding agent plugin capable of executing terminal commands, reading/writing files, and browsing the web.

5.1 Installation and Configuration

1. Search for Cline in the VS Code Extensions Marketplace and install
2. Click the Cline icon in the sidebar and go to settings
3. Select OpenAI Compatible from the API Provider dropdown
4. Enter configuration:

Base URL: https://api.deepseek.com/v1
API Key:  sk-your-api-key
Model ID: deepseek-chat

5.2 Cline's Unique Advantages

Unlike Continue, Cline acts more like an autonomous AI engineer:

# Cline can automatically execute the following workflow:
# 1. Read project structure
# 2. Understand code logic
# 3. Write new code or modify existing code
# 4. Run tests for verification
# 5. Fix failing test code
# 6. Submit a PR

# Example conversation:
# User: "Add user authentication to this Express app using JWT"
# Cline + DeepSeek will automatically:
#   - Install jsonwebtoken and bcrypt dependencies
#   - Create auth middleware
#   - Add /login and /register routes
#   - Write unit tests
#   - Update README

5.3 Cost Control with Cline

Cline's agent mode generates many API calls. Configure the following to control costs:

{
  "cline.apiProvider": "openai-compatible",
  "cline.openaiCompatible.baseUrl": "https://api.deepseek.com/v1",
  "cline.openaiCompatible.modelId": "deepseek-chat",
  "cline.maxTokensPerRequest": 4096,
  "cline.maxIterations": 10,
  "cline.alwaysAllowReadOnly": true
}

Using DeepSeek V3 as the Cline backend, a single complex task (~20 API calls) costs approximately $0.02–$0.05, compared to $0.50–$1.50 with Claude 3.5 Sonnet.

6. Comparison with GitHub Copilot

6.1 Performance Comparison

6.2 Cost Comparison

Key Difference: DeepSeek API pricing is $0.27/M input tokens and $1.10/M output tokens (V3 model). With an average of 500 completions per day, the monthly cost is approximately $2-5 — just 1/3 to 1/5 of Copilot.

6.3 Feature Comparison

7. Real-World Programming Scenarios

7.1 Code Completion

# Scenario: Writing a database operation class
# Just write the class name and partial comments, and DeepSeek completes the full implementation

class UserRepository:
    """用户数据仓库，封装常用 CRUD 操作"""

    def __init__(self, db_connection):
        """初始化数据库连接"""
        self.db = db_connection

    # 根据ID查找用户
    async def find_by_id(self, user_id: int) -> dict | None:
        """根据用户 ID 查询用户信息，返回字典或 None"""
        query = "SELECT * FROM users WHERE id = %s"
        result = await self.db.fetch_one(query, (user_id,))
        return dict(result) if result else None

    # 创建新用户
    async def create(self, username: str, email: str) -> int:
        """创建新用户并返回自增 ID"""
        query = "INSERT INTO users (username, email) VALUES (%s, %s)"
        return await self.db.execute(query, (username, email))

    # 分页查询用户列表
    async def find_all(self, page: int = 1, size: int = 20) -> list[dict]:
        """分页查询用户列表"""
        offset = (page - 1) * size
        query = "SELECT * FROM users ORDER BY id DESC LIMIT %s OFFSET %s"
        results = await self.db.fetch_all(query, (size, offset))
        return [dict(row) for row in results]

7.2 Bug Fixing

// Scenario: Select buggy code and use Cmd+K to have DeepSeek fix it

// Original code (memory leak and race condition)
class EventEmitter {
  constructor() {
    this.listeners = {};
  }

  on(event, callback) {
    // Bug: 没有检查重复注册
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    this.listeners[event].push(callback);
  }

  emit(event, data) {
    // Bug: 遍历时如果回调中调用了 off，会导致索引错乱
    this.listeners[event]?.forEach(cb => cb(data));
  }

  off(event, callback) {
    // Bug: 使用 indexOf 对比函数可能失败
    const idx = this.listeners[event]?.indexOf(callback);
    if (idx > -1) this.listeners[event].splice(idx, -1);
  }
}

// DeepSeek 修复后的版本：
class EventEmitter {
  constructor() {
    this.listeners = new Map();
  }

  on(event, callback) {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    // 使用 Set 自动去重，避免重复注册
    this.listeners.get(event).add(callback);
    // 返回取消注册函数，方便调用方管理
    return () => this.off(event, callback);
  }

  emit(event, data) {
    // 创建副本遍历，避免回调中修改集合导致的竞态问题
    const callbacks = this.listeners.get(event);
    if (callbacks) {
      [...callbacks].forEach(cb => cb(data));
    }
  }

  off(event, callback) {
    // Set.delete 直接通过引用删除，不依赖索引
    this.listeners.get(event)?.delete(callback);
  }
}

7.3 Code Review

# In Continue's chat panel, select code and enter the following prompt:
# "Please review this code, identify security vulnerabilities, performance issues, and style problems"

# DeepSeek review output example:

# Security Issues:
# 1. SQL Injection Risk: Line 15 uses f-string SQL concatenation, should use parameterized queries
# 2. Plain-text Password Storage: Line 23 stores passwords directly, should use bcrypt hashing
# 3. Missing Input Validation: email parameter lacks format validation

# Performance Issues:
# 1. N+1 Query on Line 30: Querying related data in a loop, should use JOIN or batch query
# 2. Missing Database Index: username field is frequently queried but not indexed

# Code Style:
# 1. Function too long (85 lines), recommend splitting into smaller functions
# 2. Missing type annotations
# 3. Exception handling too broad (except Exception), should catch specific exceptions

7.4 Code Refactoring

// Scenario: Refactoring a monolithic function into the Strategy Pattern

// Original code
func CalculateDiscount(orderType string, amount float64) float64 {
    // 重构前：大量 if-else，难以扩展
    if orderType == "vip" {
        return amount * 0.8
    } else if orderType == "svip" {
        return amount * 0.7
    } else if orderType == "employee" {
        return amount * 0.5
    } else if orderType == "wholesale" {
        if amount > 10000 {
            return amount * 0.6
        }
        return amount * 0.75
    }
    return amount
}

// DeepSeek refactored version: Strategy Pattern
type DiscountStrategy interface {
    // 计算折扣后的金额
    Calculate(amount float64) float64
}

// VIP 折扣策略
type VIPDiscount struct{}
func (v VIPDiscount) Calculate(amount float64) float64 { return amount * 0.8 }

// SVIP 折扣策略
type SVIPDiscount struct{}
func (s SVIPDiscount) Calculate(amount float64) float64 { return amount * 0.7 }

// 员工折扣策略
type EmployeeDiscount struct{}
func (e EmployeeDiscount) Calculate(amount float64) float64 { return amount * 0.5 }

// 批发折扣策略（带阶梯定价）
type WholesaleDiscount struct{}
func (w WholesaleDiscount) Calculate(amount float64) float64 {
    if amount > 10000 {
        return amount * 0.6
    }
    return amount * 0.75
}

// 默认无折扣
type NoDiscount struct{}
func (n NoDiscount) Calculate(amount float64) float64 { return amount }

// 折扣策略注册表
var discountStrategies = map[string]DiscountStrategy{
    "vip":       VIPDiscount{},
    "svip":      SVIPDiscount{},
    "employee":  EmployeeDiscount{},
    "wholesale": WholesaleDiscount{},
}

// 重构后的计算函数，支持轻松扩展新的折扣类型
func CalculateDiscount(orderType string, amount float64) float64 {
    strategy, ok := discountStrategies[orderType]
    if !ok {
        strategy = NoDiscount{}
    }
    return strategy.Calculate(amount)
}

8. DeepSeek API in CI/CD Pipelines

Beyond IDE usage, the DeepSeek API can be integrated into CI/CD workflows for automated code review and quality checks.

8.1 GitHub Actions Integration

# .github/workflows/deepseek-review.yml
name: DeepSeek Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Get diff of changed files
        id: diff
        run: |
          # 获取 PR 的 diff 内容
          DIFF=$(git diff origin/${{ github.base_ref }}...HEAD)
          echo "diff<<EOF" >> $GITHUB_OUTPUT
          echo "$DIFF" >> $GITHUB_OUTPUT
          echo "EOF" >> $GITHUB_OUTPUT

      - name: DeepSeek Code Review
        env:
          DEEPSEEK_API_KEY: ${{ secrets.DEEPSEEK_API_KEY }}
        run: |
          # 调用 DeepSeek API 进行代码审查
          curl -s https://api.deepseek.com/v1/chat/completions \
            -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
            -H "Content-Type: application/json" \
            -d '{
              "model": "deepseek-chat",
              "messages": [
                {
                  "role": "system",
                  "content": "You are a senior code reviewer. Review the following code changes, identify potential bugs, security issues, performance problems, and code style issues."
                },
                {
                  "role": "user",
                  "content": "Please review the following diff:\n${{ steps.diff.outputs.diff }}"
                }
              ],
              "temperature": 0.1,
              "max_tokens": 2048
            }' | jq -r '.choices[0].message.content' > review.md

      - name: Post review comment on PR
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review.md', 'utf8');
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: `## DeepSeek AI Code Review\n\n${review}`
            });

8.2 Pre-commit Hook

#!/bin/bash
# .git/hooks/pre-commit
# 在提交前使用 DeepSeek 检查代码质量

# 获取暂存区的变更
STAGED_DIFF=$(git diff --cached)

if [ -z "$STAGED_DIFF" ]; then
  exit 0
fi

echo "Running DeepSeek code quality check..."

# 调用 DeepSeek API 检查代码
REVIEW=$(curl -s https://api.deepseek.com/v1/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"deepseek-chat\",
    \"messages\": [{
      \"role\": \"user\",
      \"content\": \"Check the following code changes for obvious bugs or security issues. Reply only PASS or describe the specific issue:\n$STAGED_DIFF\"
    }],
    \"temperature\": 0.0,
    \"max_tokens\": 512
  }" | jq -r '.choices[0].message.content')

if echo "$REVIEW" | grep -qi "PASS"; then
  echo "DeepSeek code check passed"
  exit 0
else
  echo "DeepSeek found the following issues:"
  echo "$REVIEW"
  echo ""
  echo "Use git commit --no-verify to skip this check"
  exit 1
fi

9. Cost Comparison: DeepSeek vs Copilot vs Claude

Based on a 5-person development team with an average of 500 code completions + 50 chat interactions per person per day:

Cost Savings Calculation:

# Assumptions per person per day:
# - 500 Tab completions, ~200 input tokens + 100 output tokens each
# - 50 conversations, ~2000 input tokens + 500 output tokens each

# DeepSeek V3 pricing:
# Input: $0.27/M tokens (cache hit $0.07/M)
# Output: $1.10/M tokens

# Per person daily cost:
# Tab completions: 500 x (200 x $0.07/M + 100 x $1.10/M) = $0.062
# Conversations: 50 x (2000 x $0.27/M + 500 x $1.10/M) = $0.0545
# Total: $0.12/day/person

# 5-person team monthly: $0.12 x 5 x 22 = $13.2

Conclusion: DeepSeek API costs approximately 1/7th of GitHub Copilot and 1/8th of Claude Pro.

10. Best Practices and Prompt Tips

10.1 Code Generation Prompt Templates

# Effective Prompt Templates

## Template 1: Feature Implementation
Please implement [feature description] in [language].
Requirements:
- Use [framework/library]
- Include comprehensive error handling
- Add Chinese comments
- Write corresponding unit tests

## Template 2: Code Optimization
Please optimize the following code:
[paste code]
Optimization goals:
- Reduce time complexity to O(n)
- Minimize memory allocations
- Improve readability

## Template 3: Bug Fixing
The following code has an issue: [describe the symptom]
Error message: [paste error log]
Code: [paste code]
Please analyze the root cause and provide a fix.

10.2 System Prompt Best Practices

Set a custom System Prompt in Continue or Cursor:

You are a senior full-stack engineer proficient in TypeScript, Python, and Go.
Follow these principles:
1. Prioritize readability and maintainability
2. All functions must have JSDoc/docstring comments (in Chinese)
3. Prefer functional programming paradigms
4. Use custom error types for error handling, not generic Exceptions
5. Single Responsibility Principle: each function does one thing
6. Include comments explaining key design decisions in returned code

10.3 Common Tips

1. Leverage 128K context: Send entire files or multiple related files together — DeepSeek can better understand project structure
2. Use @ file references: In Cursor and Continue, use @filename to reference project files as context
3. Set Temperature to 0: For code generation tasks, set temperature to 0 for stable, reproducible output
4. Generate step by step: Break complex features into small steps for the AI, rather than generating large amounts of code at once
5. Provide examples: Give the AI an existing code example (like a similar function in your project) and it will automatically mimic the style

Conclusion

DeepSeek offers developers a high-value AI programming solution:

• Performance: SWE-bench 49.2%, HumanEval 90.2% — on par with GPT-4o
• Cost: Just 1/7th of GitHub Copilot, 1/8th of Claude Pro
• Flexibility: Integrates with Cursor, VS Code (Continue/Cline), and more
• Control: Open-source model supports private deployment with full data sovereignty
• 128K Context: Handles large project files with ease

Whether you're an independent developer or a team lead, DeepSeek is worth adding to your AI coding toolkit. We recommend starting with the DeepSeek V3 + Cursor combination, then gradually exploring CI/CD integration and local deployment.

Get Started Now: Visit the DeepSeek Open Platform to get an API Key, or connect quickly via Atlas Cloud.