如何高效地使用 Cursor 来编写代码

Posted on Tue 21 October 2025 in Journal

Abstract 如何高效地使用 Cursor 来编写代码
Authors Walter Fan
 Category    learning note  
Status v1.0
Updated 2025-10-21
License CC-BY-NC-ND 4.0

一、初识 Cursor：不只是个编辑器

说实话，第一次用 Cursor 的时候，我以为它就是个套了个 AI 壳的 VSCode。结果用了一周后，我发现自己回不去了。

这感觉就像当年从记事本升级到 IDE，从手动档换到自动档，从算盘升级到计算器——技术的进步让你意识到，原来写代码还能这么爽。

Cursor 本质上是一个深度集成了 AI 能力的代码编辑器。它基于 VSCode 构建，所以 VSCode 的插件、快捷键、配置都能无缝迁移。但它的核心价值在于：AI 不再是个外挂工具，而是编程流程的原生伙伴。

Cursor 编辑器界面，展示代码补全和 AI 对话窗口

1.1 Cursor 的核心能力

Tab 自动补全（Copilot++）

这是最基础也最常用的功能。你写一行代码，按 Tab，AI 就把后面的补上了。但 Cursor 的补全比普通 Copilot 更智能，因为它能读懂你整个项目的上下文。

举个例子，我在写一个 Redis 连接池，刚定义完配置结构体：

type RedisConfig struct {
    Host     string
    Port     int
    Password string
    DB       int
    PoolSize int
}

然后我开始写初始化函数：

func NewRedisClient(cfg RedisConfig) (*redis.Client, error) {
    // 按下 Tab，Cursor 自动补全了整个函数体
    client := redis.NewClient(&redis.Options{
        Addr:     fmt.Sprintf("%s:%d", cfg.Host, cfg.Port),
        Password: cfg.Password,
        DB:       cfg.DB,
        PoolSize: cfg.PoolSize,
    })

    _, err := client.Ping(context.Background()).Result()
    if err != nil {
        return nil, fmt.Errorf("failed to connect to redis: %w", err)
    }

    return client, nil
}

这种"心有灵犀"的感觉，真的会上瘾。

Cmd+K 行内编辑（最爱功能）

这是我用得最多的功能。选中一段代码，按 Cmd+K（Mac）或 Ctrl+K（Windows），输入你的需求，AI 就地修改代码。

比如我有个函数写得太长了，想拆分：

# 选中这个臃肿的函数，按 Cmd+K
def process_user_data(user_id):
    # 100 行代码...
    pass

# 输入 prompt："把这个函数按职责拆分成多个小函数"
# AI 自动重构成：
def fetch_user_from_db(user_id):
    # ...

def validate_user_data(user):
    # ...

def transform_user_data(user):
    # ...

def process_user_data(user_id):
    user = fetch_user_from_db(user_id)
    validate_user_data(user)
    return transform_user_data(user)

这比手动重构省事太多了。

Cmd+L AI 对话（结对编程伙伴）

这个功能打开一个 AI 聊天面板，你可以问它任何问题。关键是，它能看到你当前打开的文件，甚至能主动帮你修改代码。

实际场景：我在写一个分布式锁的实现，卡在续期逻辑上了。

我：这个锁的续期逻辑有问题，在高并发场景下可能会失效，帮我看看

Cursor：我看到了问题。你的续期是在锁即将过期时才触发，
但如果业务逻辑执行时间不确定，可能来不及续期。
建议改用后台 goroutine 定时续期。我来帮你改。

然后它直接在代码里插入了一个优化版本。这种体验就像有个资深程序员坐在旁边，随时可以讨论。

结对编程

二、让 Cursor 更懂你的项目：文档驱动开发

AI 再聪明，也需要"投喂"足够的上下文。这就像你带一个新人，如果项目文档完善，他上手就快；如果文档一团糟，神仙也帮不了你。

2.1 设计文档：告诉 AI 你要做什么

我现在开始一个新项目或模块时，第一件事不是写代码，而是写设计文档。放在项目根目录的 docs/design/ 里。

示例设计文档结构：

# User Service 设计文档

## 1. 背景
现有的用户服务性能不足，需要重构为微服务架构

## 2. 目标
- 支持 10 万 QPS
- 可水平扩展
- 数据最终一致性

## 3. 架构设计
### 3.1 整体架构
[放一张架构图]

### 3.2 核心模块
- UserRepository: 数据访问层，支持 MySQL 和 Redis
- UserService: 业务逻辑层
- UserAPI: HTTP API 层

## 4. 接口定义
### 4.1 创建用户
POST /api/v1/users
Request: { "name": "xxx", "email": "xxx" }
Response: { "id": "xxx", "created_at": "xxx" }

## 5. 数据模型
...

## 6. 技术选型
- 语言: Go 1.21
- 框架: Gin
- 数据库: MySQL 8.0 + Redis 7.0
- 消息队列: Kafka

有了这个文档，我就可以跟 Cursor 说：

我：按照 docs/design/user-service.md 的设计，帮我实现 UserRepository 接口

Cursor 会读取设计文档，然后生成符合设计的代码。这比你口头描述需求准确多了。

2.2 编码规范：统一代码风格

在项目根目录放一个 .cursorrules 文件，定义你的编码规范。Cursor 会自动遵守这些规则。

我的 .cursorrules 示例：

# 项目编码规范

## 代码风格
- 使用 Go 官方风格指南
- 函数名使用驼峰命名
- 接口名以 -er 结尾（如 Reader, Writer）
- 常量全大写，用下划线分隔（如 MAX_RETRY_COUNT）

## 错误处理
- 必须处理所有 error，不允许忽略
- 错误信息使用 fmt.Errorf 包装，携带上下文
- 自定义错误使用 errors.New 或实现 error 接口

## 注释规范
- 导出的函数必须有注释，以函数名开头
- 复杂逻辑必须有行内注释
- TODO/FIXME/HACK 必须标注原因和负责人

## 测试规范
- 每个公开函数都要有单元测试
- 测试函数名格式：TestFunctionName_Scenario_ExpectedResult
- 使用 testify 库做断言
- 表驱动测试（Table-Driven Tests）优先

## 依赖管理
- 禁止引入未经评审的第三方库
- 使用 go mod 管理依赖
- 定期更新依赖，修复安全漏洞

## Git 提交
- 提交信息格式：<type>: <subject>
- type: feat/fix/docs/refactor/test/chore
- 一次提交只做一件事

有了这个规范，Cursor 生成的代码风格就很统一了。团队协作时尤其有用。

代码规范文档

2.3 上下文注释：给 AI 留"面包屑"

代码注释不只是给人看的，也是给 AI 看的。我现在写代码会有意识地加一些"导航注释"。

不好的注释：

// 获取用户
func GetUser(id string) (*User, error) {
    // ...
}

好的注释：

// GetUser 根据用户 ID 从数据库获取用户信息
// 查询顺序：1. 先查 Redis 缓存 2. 缓存未命中再查 MySQL 3. 写回缓存
// 缓存过期时间：5 分钟
// 错误场景：用户不存在返回 ErrUserNotFound，数据库错误返回原始 error
func GetUser(id string) (*User, error) {
    // ...
}

这样 Cursor 在补全相关代码时，就知道你的设计意图了。

三、测试驱动开发：让 AI 帮你写测试

TDD（Test-Driven Development）和 BDD（Behavior-Driven Development）在 Cursor 里特别好用，因为 AI 擅长写测试。

3.1 TDD 工作流

我现在的开发流程是：

1. 先写测试

// user_service_test.go
func TestUserService_CreateUser_Success(t *testing.T) {
    // Given: 准备测试数据
    service := NewUserService(mockDB, mockCache)
    req := &CreateUserRequest{
        Name:  "张三",
        Email: "zhangsan@example.com",
    }

    // When: 执行被测试的方法
    user, err := service.CreateUser(context.Background(), req)

    // Then: 验证结果
    assert.NoError(t, err)
    assert.NotEmpty(t, user.ID)
    assert.Equal(t, "张三", user.Name)
    assert.Equal(t, "zhangsan@example.com", user.Email)
}

2. 让 Cursor 生成实现

选中测试代码，按 Cmd+L，输入：

根据这个测试用例，帮我实现 CreateUser 方法

Cursor 会分析测试逻辑，生成符合测试预期的代码：

func (s *UserService) CreateUser(ctx context.Context, req *CreateUserRequest) (*User, error) {
    // 1. 参数校验
    if req.Name == "" || req.Email == "" {
        return nil, errors.New("name and email are required")
    }

    // 2. 检查邮箱是否已存在
    exists, err := s.db.CheckEmailExists(ctx, req.Email)
    if err != nil {
        return nil, fmt.Errorf("failed to check email: %w", err)
    }
    if exists {
        return nil, ErrEmailAlreadyExists
    }

    // 3. 创建用户
    user := &User{
        ID:        uuid.New().String(),
        Name:      req.Name,
        Email:     req.Email,
        CreatedAt: time.Now(),
    }

    if err := s.db.SaveUser(ctx, user); err != nil {
        return nil, fmt.Errorf("failed to save user: %w", err)
    }

    // 4. 写入缓存
    s.cache.SetUser(ctx, user)

    return user, nil
}

3. 运行测试，调整代码

go test -v ./...

如果测试失败，把错误信息贴给 Cursor，让它修复。

3.2 BDD 风格测试

BDD 更注重业务场景描述。我用 Gherkin 语法写场景，然后让 Cursor 生成测试代码。

场景描述（features/user_registration.feature）：

Feature: 用户注册
  作为一个新用户
  我想要注册一个账号
  以便使用系统功能

  Scenario: 成功注册
    Given 用户不存在
    When 用户提交注册信息 "张三" 和 "zhangsan@example.com"
    Then 应该创建用户成功
    And 用户应该收到欢迎邮件

  Scenario: 邮箱已被注册
    Given 邮箱 "zhangsan@example.com" 已被注册
    When 用户尝试用该邮箱注册
    Then 应该返回 "邮箱已被使用" 错误

然后跟 Cursor 说：

根据 features/user_registration.feature，用 Go 和 testify 实现 BDD 测试

Cursor 会生成类似这样的代码：

func TestUserRegistration(t *testing.T) {
    t.Run("成功注册", func(t *testing.T) {
        // Given: 用户不存在
        service := setupTestService()
        email := "zhangsan@example.com"

        // When: 用户提交注册信息
        user, err := service.Register(&RegisterRequest{
            Name:  "张三",
            Email: email,
        })

        // Then: 应该创建用户成功
        assert.NoError(t, err)
        assert.NotNil(t, user)

        // And: 用户应该收到欢迎邮件
        assert.True(t, mockEmailService.WasSent(email, "欢迎"))
    })

    t.Run("邮箱已被注册", func(t *testing.T) {
        // Given: 邮箱已被注册
        service := setupTestService()
        existingEmail := "zhangsan@example.com"
        service.Register(&RegisterRequest{
            Name:  "张三",
            Email: existingEmail,
        })

        // When: 用户尝试用该邮箱注册
        _, err := service.Register(&RegisterRequest{
            Name:  "李四",
            Email: existingEmail,
        })

        // Then: 应该返回错误
        assert.Error(t, err)
        assert.Contains(t, err.Error(), "邮箱已被使用")
    })
}

3.3 表驱动测试（Table-Driven Tests）

Go 里常用的测试模式，Cursor 也很擅长：

帮我写一个表驱动测试，覆盖 ValidateEmail 函数的各种场景

func TestValidateEmail(t *testing.T) {
    tests := []struct {
        name    string
        email   string
        wantErr bool
        errMsg  string
    }{
        {
            name:    "有效邮箱",
            email:   "test@example.com",
            wantErr: false,
        },
        {
            name:    "缺少@符号",
            email:   "testexample.com",
            wantErr: true,
            errMsg:  "invalid email format",
        },
        {
            name:    "缺少域名",
            email:   "test@",
            wantErr: true,
            errMsg:  "invalid email format",
        },
        {
            name:    "空字符串",
            email:   "",
            wantErr: true,
            errMsg:  "email is required",
        },
        {
            name:    "包含非法字符",
            email:   "test@exam ple.com",
            wantErr: true,
            errMsg:  "invalid email format",
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            err := ValidateEmail(tt.email)
            if tt.wantErr {
                assert.Error(t, err)
                assert.Contains(t, err.Error(), tt.errMsg)
            } else {
                assert.NoError(t, err)
            }
        })
    }
}

这种测试覆盖面广，维护成本低，特别适合用 AI 生成。

四、小步快跑：增量式开发

用 Cursor 写代码，最忌讳的就是一口气让它生成一大坨代码。那样既不可控，也不好调试。

4.1 分解任务

我会把一个大功能拆成小任务，每次只让 Cursor 做一件事。

坏例子（一步到位）：

帮我实现一个完整的用户服务，包括注册、登录、修改资料、
删除账号、找回密码等功能，要支持 JWT 认证、Redis 缓存、
MySQL 持久化、Kafka 消息发送、分布式事务

这种需求太模糊了，Cursor 生成的代码质量肯定不高。

好例子（小步迭代）：

第一步：帮我定义 User 结构体和 UserRepository 接口

第二步：实现 UserRepository 的 MySQL 版本，只需要 Create 和 GetByID 方法

第三步：给 UserRepository 加一层 Redis 缓存装饰器

第四步：实现 UserService，只包含注册功能

第五步：加上参数校验和错误处理

...

每一步都能独立测试，出问题也容易定位。

4.2 频繁提交

我现在写代码的节奏是：写一点 → 测试 → 提交 → 写一点 → 测试 → 提交。

git commit -m "feat: add User struct and Repository interface"
git commit -m "feat: implement MySQL UserRepository"
git commit -m "feat: add Redis caching layer"
git commit -m "feat: implement user registration"

这样做的好处： - 回滚方便：改坏了可以立刻回退 - Review 友好：每个 commit 只改一点点，容易 review - 记录清晰：Git 历史就是你的开发日志

Git 提交历史，整齐的提交记录

4.3 及时 Review 代码

AI 生成的代码不能照单全收，必须自己过一遍。我的 checklist：

  • [ ] 逻辑是否正确？
  • [ ] 边界情况考虑了吗？
  • [ ] 错误处理完善吗？
  • [ ] 性能有问题吗？
  • [ ] 安全隐患排查了吗？
  • [ ] 命名规范吗？
  • [ ] 注释清楚吗？

发现问题就立刻让 Cursor 改：

这个函数没有处理 context 超时，加上超时处理

// 修改前
func (r *UserRepository) GetByID(ctx context.Context, id string) (*User, error) {
    var user User
    err := r.db.QueryRow("SELECT * FROM users WHERE id = ?", id).Scan(&user)
    return &user, err
}

// 修改后
func (r *UserRepository) GetByID(ctx context.Context, id string) (*User, error) {
    var user User

    // 带超时的查询
    query := "SELECT * FROM users WHERE id = ?"
    err := r.db.QueryRowContext(ctx, query, id).Scan(&user)

    if err != nil {
        if errors.Is(err, context.DeadlineExceeded) {
            return nil, fmt.Errorf("query timeout: %w", err)
        }
        return nil, err
    }

    return &user, nil
}

五、写好 Prompt：跟 AI 沟通的艺术

用 Cursor 写代码，本质上是在跟 AI 沟通。Prompt 写得好不好，直接决定了代码质量。

5.1 清晰具体

坏 Prompt：

优化一下这个函数

AI 不知道你想优化什么：性能？可读性？还是内存占用？

好 Prompt：

这个函数在处理大文件时内存占用过高，改成流式处理，
每次只读 4KB，避免一次性加载整个文件到内存

5.2 提供上下文

坏 Prompt：

帮我写一个排序函数

好 Prompt：

这是一个电商系统，需要对商品列表排序。
- 支持按价格、销量、评分、上架时间排序
- 支持升序和降序
- 数据量可能有几十万条，性能要求高
- 使用 Go 语言，返回类型是 []Product

请实现 SortProducts 函数

5.3 举例说明

有时候用例子比文字描述更清楚：

我需要一个时间格式化函数，把 time.Time 转成指定格式的字符串。

例如：
输入: 2025-10-21 14:30:45
输出格式 "YYYY-MM-DD HH:mm:ss" → "2025-10-21 14:30:45"
输出格式 "YYYY年MM月DD日" → "2025年10月21日"
输出格式 "MM/DD/YYYY" → "10/21/2025"

请用 Go 实现，支持常见的格式占位符

5.4 指定约束条件

实现一个 LRU 缓存，要求：
- 容量可配置
- 线程安全
- O(1) 的读写性能
- 不使用第三方库，只用标准库
- 要有完整的单元测试

5.5 迭代优化

第一次生成的代码不满意，别着急重写，而是逐步优化：

第一轮：这个缓存的性能还不够，把锁粒度细化，用分段锁

第二轮：锁竞争还是明显，改成无锁实现，用 sync/atomic

第三轮：内存占用太大了，加上定期清理过期数据的机制

AI 对话

六、提供充足的上下文：让 AI 看得更全

Cursor 的智能程度，很大程度上取决于它能"看到"多少信息。

6.1 @ 符号引用文件

在 AI 对话框里，用 @ 可以引用文件：

@user_service.go 这个文件的错误处理不统一，
参考 @error_handler.go 的规范改一下

Cursor 会同时读取这两个文件，然后做统一的修改。

6.2 Codebase Indexing（代码库索引）

Cursor 会自动索引你的整个代码库。当你问问题时，它会自动检索相关代码。

我：我们的日志系统是怎么实现的？

Cursor：根据代码库分析，你们使用的是 zap 日志库，
配置在 pkg/logger/logger.go 中，支持日志分级、
文件切割和 JSON 格式输出。需要我帮你看看哪个部分吗？

6.3 使用 .cursorignore

有些文件不需要让 AI 看到，比如 node_modules、vendor、.git。在 .cursorignore 里排除它们：

node_modules/
vendor/
*.log
.git/
dist/
coverage/

这样可以提高索引速度，也避免 AI 被无关代码干扰。

6.4 工作区设置

在 .vscode/settings.json（Cursor 兼容）里配置一些项目特定的规则：

{
  "cursor.ai.model": "gpt-4",
  "cursor.ai.maxTokens": 4000,
  "cursor.ai.temperature": 0.3,
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "source.organizeImports": true
  }
}

七、MCP 和工具：扩展 Cursor 的能力

MCP (Model Context Protocol) 是 Anthropic（Claude 的开发公司）推出的协议，让 AI 能调用外部工具和数据源。

7.1 常用 MCP 工具

文件系统工具

{
  "mcp": {
    "filesystem": {
      "enabled": true,
      "allowedPaths": ["/Users/yourname/workspace"]
    }
  }
}

AI 可以直接读写文件，批量重构时特别有用：

把 src/ 目录下所有 .js 文件的 console.log 改成用我们的 logger

Cursor 会自动遍历所有文件，逐个修改。

数据库工具

配置数据库连接后，AI 可以帮你写 SQL、分析数据：

连接到我的 PostgreSQL 数据库，分析 users 表的数据分布，
找出最活跃的用户群体

API 工具

AI 可以调用外部 API：

调用 GitHub API，列出我最近创建的 5 个 issue

工具集成示意图，多个工具围绕 AI 核心

7.2 自定义工具

你可以写自己的 MCP 工具。比如我写了个代码质量检查工具：

# mcp_code_quality.py
from mcp.server import Server, Tool

server = Server("code-quality-checker")

@server.tool()
def check_cyclomatic_complexity(file_path: str) -> dict:
    """检查代码复杂度"""
    # 用 radon 或其他工具分析代码
    complexity = analyze_complexity(file_path)
    return {
        "file": file_path,
        "complexity": complexity,
        "issues": find_complex_functions(complexity)
    }

@server.tool()
def check_test_coverage(package: str) -> dict:
    """检查测试覆盖率"""
    coverage = run_coverage(package)
    return {
        "package": package,
        "coverage_percent": coverage.percent,
        "uncovered_lines": coverage.missing_lines
    }

server.run()

然后在 Cursor 里配置这个工具：

{
  "mcp": {
    "servers": {
      "code-quality": {
        "command": "python",
        "args": ["mcp_code_quality.py"]
      }
    }
  }
}

之后就可以让 AI 调用你的工具了：

检查 user_service.go 的圈复杂度，如果超过 10 就重构

7.3 与其他工具集成

Source Tree / Beyond Compare

这两个是我多年的老伙伴，现在依然在用：

  • Source Tree：Git 可视化管理工具，清晰展示代码变更历史和分支结构
  • Beyond Compare：代码对比和合并，处理复杂的 merge conflict 很好用

虽然 Cursor 集成了 AI 能力，但人工审阅 AI 生成的代码仍然不可或缺。特别是关键业务逻辑、安全相关代码、性能敏感模块，必须仔细审查。我通常的工作流是：

  1. 在 Cursor 里让 AI 写代码和重构
  2. 用 Source Tree 查看所有改动，逐个 diff 审阅
  3. 用 Beyond Compare 深度对比关键文件，确保改动符合预期
  4. 人工测试验证，确认无误后再提交

AI 可以提高效率，但不能替代人的判断。每一行关键代码都值得你花时间去理解和验证

多工具协作

八、实战案例：用 Cursor 完成一个真实项目

说了这么多理论，来个实战案例。我最近用 Cursor 重构了一个 Redis 客户端库，从零到发布只用了 3 天。

8.1 项目启动

第一步：写设计文档

# Redis Client 设计文档

## 目标
- 支持 Redis Cluster 和 Sentinel
- 自动故障转移
- 连接池管理
- Pipeline 和 Transaction 支持
- 完善的错误处理和重试机制

## 架构
- Client: 对外接口层
- Connector: 连接管理层
- Command: 命令封装层
- Serializer: 序列化层

第二步：让 Cursor 生成项目骨架

根据 docs/design.md，用 Go 创建项目结构，
包括目录、主要接口定义、go.mod 文件

Cursor 生成了：

redis-client/
├── go.mod
├── cmd/
│   └── example/
│       └── main.go
├── pkg/
│   ├── client/
│   │   ├── client.go
│   │   └── client_test.go
│   ├── connector/
│   │   ├── pool.go
│   │   └── pool_test.go
│   ├── command/
│   │   ├── command.go
│   │   └── string_commands.go
│   └── serializer/
│       └── serializer.go
├── docs/
│   └── design.md
└── README.md

8.2 迭代开发

第三步：实现核心接口

实现 pkg/client/client.go 的 Client 接口，
包括 Get、Set、Del 三个基础命令

第四步：写测试

为刚才实现的方法写单元测试和集成测试

第五步：加功能

加上 Pipeline 支持，允许批量执行命令

每一步都是独立的，测试通过了再继续下一步。

8.3 代码审查

开发完后，我让 Cursor 帮我做代码审查：

作为一个资深 Go 开发者，审查 pkg/client/ 下的所有代码，
从性能、安全、可维护性角度提出改进建议

Cursor 给出了一堆建议：

  • 连接池的锁粒度可以优化
  • 错误处理可以更细化
  • 某些地方可以用 sync.Pool 减少内存分配
  • 单元测试覆盖率还不够

然后我逐条优化。

8.4 文档生成

最后让 Cursor 帮我写文档：

根据代码生成 README.md，包括：
- 快速开始
- API 文档
- 使用示例
- 最佳实践
- FAQ

几分钟后，一份完整的文档就好了。

九、一些经验和坑

9.1 不要过度依赖

AI 是辅助工具，不是替代品。核心逻辑、架构设计、技术选型，这些还是要自己把关。

有一次我让 Cursor 优化一个算法，它给出的方案表面看起来很"高级"，实际上在我的场景下性能还不如原版。后来我自己分析了数据特征，手写了一个针对性的算法，性能提升了 10 倍。

9.2 注意安全

别让 AI 看到敏感信息。密码、密钥、Token 这些，要么用环境变量，要么放在 .cursorignore 里。

# .env 文件
DATABASE_URL=postgres://user:password@localhost/db
REDIS_URL=redis://:password@localhost:6379

# .cursorignore
.env
secrets/
*.key
*.pem

9.3 版本控制很重要

AI 有时会"画蛇添足"，改坏代码。所以频繁提交 Git 很重要，改坏了立刻回滚。

git commit -m "refactor: optimize connection pool"
# 发现改坏了
git reset --hard HEAD^

9.4 团队协作要对齐

如果团队都在用 Cursor，最好统一配置和规范。在项目根目录放：

  • .cursorrules：编码规范
  • docs/coding-standards.md：详细的开发指南
  • docs/architecture.md：系统架构文档

这样大家生成的代码风格才一致。

团队协作，多个人在看同一块屏幕讨论

十、进阶技巧

10.1 自定义 Snippets

把常用的代码片段做成模板：

// .vscode/go.json
{
  "Go HTTP Handler": {
    "prefix": "httphandler",
    "body": [
      "func ${1:Handler}(w http.ResponseWriter, r *http.Request) {",
      "\tif r.Method != http.Method${2:Get} {",
      "\t\thttp.Error(w, \"Method not allowed\", http.StatusMethodNotAllowed)",
      "\t\treturn",
      "\t}",
      "\t",
      "\t// TODO: implement handler logic",
      "\t",
      "\tw.Header().Set(\"Content-Type\", \"application/json\")",
      "\tjson.NewEncoder(w).Encode(map[string]interface{}{",
      "\t\t\"status\": \"ok\",",
      "\t})",
      "}"
    ]
  }
}

输入 httphandler，按 Tab，整个 HTTP 处理函数就出来了。

10.2 使用 AI 做代码重构

大规模重构时，Cursor 特别好用：

把整个项目的错误处理从 panic 改成返回 error，
遵循 Go 的错误处理最佳实践

AI 会扫描所有文件，逐个修改。你只需要最后审查一遍。

10.3 生成样板代码

Web 开发中有大量重复的样板代码，让 AI 生成能节省很多时间：

为 User 模型生成完整的 CRUD API，包括：
- HTTP handlers
- Service layer
- Repository layer  
- 参数校验
- 错误处理
- 单元测试

几分钟就能生成几千行代码，虽然还需要调整，但比从零开始快多了。

10.4 学习新技术

遇到新技术，可以让 Cursor 当老师：

我不熟悉 gRPC，帮我创建一个简单的 gRPC 服务示例，
包括 .proto 文件定义、服务端实现、客户端调用，
并加上详细注释解释每个部分的作用

边看代码边学，效率很高。

学习场景，笔记本电脑屏幕上显示代码和文档

十一、结语

用了 Cursor 半年多，我的编程效率至少提升了 20% 甚至更多。但更重要的是，它改变了我的工作方式：

  • 从手写代码到设计代码：我现在花更多时间在架构设计和方案评审上，具体实现交给 AI
  • 从搜索答案到直接提问：以前遇到问题要去 Google、Stack Overflow 翻半天，现在直接问 Cursor
  • 从单打独斗到结对编程：AI 就像个永不疲倦的搭档，随时可以讨论

但是，工具终究是工具。真正重要的是：

  • 扎实的基础知识：不懂原理，AI 生成的代码你也看不懂
  • 良好的设计能力：AI 能实现你的想法，但想法本身要靠你
  • 持续的学习热情：技术日新月异，工具也在快速进化

Cursor 不是银弹，但它确实是一把利器。用好它，能让你在编程这条路上走得更快、更远。

最后送大家一句话：工具会变，思维不变。无论用什么编辑器、什么 AI，写好代码的核心原则——清晰的逻辑、优雅的设计、健壮的测试——这些永远不会过时。

现在就打开 Cursor，开始你的高效编程之旅吧！三个月后，你会感谢现在的自己。

本作品采用知识共享署名-非商业性使用-禁止演绎 4.0 国际许可协议进行许可。

journal blog

Previous Post Next Post

You might enjoy