想象你走进一家裁缝店,手里拎着一件不太合身的外套。你不想买新的,而是想让老师傅把它改成合体的模样。你指着袖口说“这里太紧了”,又指着下摆说“这里放长两厘米”。老师傅点点头,拿起针线直接动手改——而不是只在你耳边讲一套改衣理论。改完之后,他让你对着镜子试穿,每一处改动都指给你看,满意就留下,不满意当场返工。 这就是 Cursor 里的 Chat+Edit 模式。它就像这位“随叫随到的裁缝师傅”:你用自然语言描述想改什么(Chat),AI 直接在你的代码文件里动手修改(Edit),每处改动都生成清晰的“修改前后对比”(diff),等你审查确认后才真正落地。相比只给建议的纯聊天模式,Chat+Edit 把“说”和“改”连成一条流水线;相比全自动的 Agent 模式,它又把“每一步由我把关”的掌控感留给用户。 接下来,我们就围着这张裁缝工作台,把这套工作流拆开揉碎,看看它到底怎么用、好在哪、又该怎么避坑。

岗位关联

对 AI 从业者来说,掌握 Chat+Edit 模式等于把 AI 助手从“只会提建议的顾问”升级为“能动手改稿的结对程序员”,是提升日常开发效率与代码交付质量的必修课。

目录
  1. 可视化演示
  2. 一、模式初识:聊着聊着,代码就被改了
  3. 二、四步工作流:像改衣一样有条不紊
  4. 三、上下文感知:老师傅的眼力
  5. 四、多文件协作:改的是一套西装
  6. 五、Diff审查:试穿这件“改动外套”
  7. 六、Agent模式对比:全自动机器人 vs 手把手师傅
  8. 七、实战技巧:像熟客一样使唤 AI
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示Cursor Chat+Edit工作流程、三层技术架构与多文件协作编辑,交互切换查看各模式核心指标。

本节配有交互动效(进入视口后自动加载,约 3KB)。

Chat+Edit工作流程 用户对话描述需求AI理解意图并生成代码编辑 实时diff审查确认后应用到代码编辑器 Chat→Reason→Edit→Diff 对话式交互与实时编辑深度融合的编程范式

一、模式初识:聊着聊着,代码就被改了

裁缝店里有两类师傅:一类只动嘴,让你把“肩线收一厘米”记回家自己改;另一类边讲边拿起针线,直接在衣服上下剪子,改完还递到你面前让你检查。前者像 Cursor 的纯 Chat 模式——只给你一段建议代码;后者就是 Chat+Edit 模式——直接在编辑器里把代码改好。同样是“请人改衣服”,体验和对结果的掌控感完全不同。

Chat+Edit 是 Cursor 的核心交互方式之一:你在聊天窗口用自然语言描述修改意图,AI 结合选中的代码与项目上下文,直接生成可应用的修改(diff)。它把“理解需求、生成方案、应用改动、审查确认”压缩进同一条交互链路,省去了从建议里复制代码再手动粘贴的搬运环节。

从操作上看,你既可以在侧边 Chat 窗口选中代码对话,也可以用 Cmd+I 触发内联输入框(Inline Chat),光标所在的位置就是“裁缝的工作台”。AI 返回的不是样板代码,而是带着增删标记的具体改动,你可以一键接受、拒绝或继续追问。适用场景覆盖 bug 修复、逻辑调整、代码重构,凡是“想清楚要什么改动”的需求,都适合交给它。

所以 Chat+Edit 的精髓不在“AI 会写代码”,而在“AI 动手改、你负责把关”。就像那位值得信赖的老师傅,手艺固然重要,但“改完一定让你一件件试穿”的踏实感,才是你愿意把衣服交给他的真正理由。

Chat+Edit=需求描述+可审查直接修改\text{Chat} + \text{Edit} = \text{需求描述} + \text{可审查直接修改}
这个公式说的是:Chat 负责“说清楚要什么”,Edit 负责“直接改好给你看”。两者相加,等于一次完整的改衣服务——你描述、师傅动手、效果立现。
  1. Chat(需求描述)你用自然语言写下想改什么,相当于向裁缝交代“哪里要改、改成什么样”。
    Chat\text{Chat}
  2. Edit(可审查直接修改)AI 直接在源码上生成带增删标记的改动,相当于师傅拿起针线下剪子。
    Edit\text{Edit}
  3. 合力落地(可审查闭环)对话驱动修改,修改以 diff 呈现并等待你确认,等于“改完必须试穿”。
    Chat+Edit⇒可审查改动\text{Chat} + \text{Edit} \Rightarrow \text{可审查改动}

二、四步工作流:像改衣一样有条不紊

有经验的裁缝改衣服,从来不是抓起剪刀就剪。他会先量体——确认这件衣服哪里不合身;再听你讲需求——什么场合穿、喜欢宽松还是修身;然后才下剪;最后必定让你试穿。走完这四步,一件改动才算真正交付。Chat+Edit 的工作流,恰好就是这四步的翻版。

落到 Cursor 里,四步对应四件事:第一步“量体”,用鼠标选中要改的代码区域;第二步“听需求”,在 Chat 框用一句话说清目标;第三步“下剪”,AI 生成带 diff 的修改;第四步“试穿”,你逐块审查后决定接受、拒绝还是继续提意见。

实操细节上,Cmd+I 打开内联输入框后,可以像聊天一样连续追问;每次 AI 返回的修改都附带 diff,你可以接受全部,也可以要求“只改这个函数,别动别的”。迭代循环“改→看→再改”是常态,直到你点头为止。小步快改的原则贯穿始终:一次只改一个函数或模块,审查负担小、出错概率低。

所以别把 Chat+Edit 当成“一键魔改”的魔法。先量体再下剪、先试穿再交付,这四步走得越稳,AI 产出的代码就越贴合你的预期,返工也越少。好裁缝的工序不可乱,好工程师的习惯也一样。

Select→Describe→Modify→Review\text{Select} \to \text{Describe} \to \text{Modify} \to \text{Review}
四步对应改衣的四个动作:量体、听需求、下剪、试穿。顺序不能乱——跳过“量体”直接改,AI 就不知道改哪里、按什么风格改。
  1. Select(选中)框定修改范围,相当于量体定位,告诉 AI“要动的是这块料子”。
    Select\text{Select}
  2. Describe(描述)说明期望行为与约束条件,相当于向裁缝交代用途和偏好。
    Describe\text{Describe}
  3. Modify(修改)AI 基于上下文生成带 diff 的改动,相当于师傅落剪。
    Modify\text{Modify}
  4. Review(审查)逐块确认取舍后落地,相当于试穿后点头才算完工。
    Review\text{Review}

三、上下文感知:老师傅的眼力

“袖子改短一些”这句话,新手裁缝只盯着袖口,老师傅却会同时看肩宽、袖笼和衣长——牵一发而动全身。AI 编程助手也一样,它能不能改对地方、改对风格,取决于它“看到”了多少上下文。

Chat+Edit 的上下文感知能力,决定了修改的精准度。Cursor 会整合多个来源的信息:你选中的代码范围、当前打开的文件、用 @ 显式引用的其他文件、以及整个项目的基本结构。这些信息共同构成 AI 的“改衣视野”。

在技术层面,选中代码拥有最高优先级——AI 会优先精读这段逻辑;当前文件让它掌握命名习惯、缩进风格和注释语言,从而自动套用该语言惯用的写法;@ 引用把相关模块直接拉入视野;项目目录和技术栈信息则告诉它“这类改动在这类项目里通常怎么做”。上下文越丰富,修改越“贴身”。

这也解释了为什么“同一个 AI,有人用出神、有人用出鬼”。AI 的眼力是可以喂养的:精确选中代码、用 @ 拖入关键文件,就像给老师傅递上样衣和面料——他看到得越多,改得越合身。

Context=Selection∪CurFile∪Refs∪Project\text{Context} = \text{Selection} \cup \text{CurFile} \cup \text{Refs} \cup \text{Project}
上下文就是 AI 的“眼力”,由四路信息合并而成。看得越多,改得越准——这也是为什么同样一条指令,有人得到“完美修改”,有人得到“牛头不对马嘴”。
  1. Selection(选中代码)优先级最高的上下文,相当于裁缝直接量你身上那件衣服。
    Selection↦最高权重\text{Selection} \mapsto \text{最高权重}
  2. CurFile(当前文件)提供代码风格与既有逻辑的基准线。
    CurFile↦代码风格\text{CurFile} \mapsto \text{代码风格}
  3. Refs(@ 引用)显式把相关文件请进视野,相当于递上样衣和参考图。
    Refs→@上下文\text{Refs} \xrightarrow{@} \text{上下文}
  4. Project(项目信息)技术栈与目录结构等工程惯例,相当于师傅对品牌版型的经验。
    Project↦工程惯例\text{Project} \mapsto \text{工程惯例}

四、多文件协作:改的是一套西装

改一套西装,如果只顾着改裤子、不管上衣比例,整套穿出去依然不协调。真正的老师傅讲究“上下联动”:裤子改短,上衣下摆的配比也要跟着调整。Chat+Edit 的多文件协作,做的正是这种“整套衣服”级别的改动。

很多需求天然跨文件:改了函数签名,所有调用点都要跟着改;换了接口字段,前端请求、后端模型、测试用例都要同步。Chat+Edit 能同时生成跨文件的修改,把所有改动统一放进 diff 视图,由你一遍审查完。

典型场景包括:把散落在各处的重复逻辑抽取成公共模块,涉及十几个文件的导入与调用;接口结构重设计,实现、调用方与测试一条链全部更新;全局重构工具函数,保证所有使用处行为一致。因为改动集中展示,你很难漏掉某个“忘了改”的角落。

就像西装讲究上下装协调,项目级改动讲究全局一致。Chat+Edit 把整套西装摊在审查台上,让你像照全身镜一样看清每个部位的改动,再决定要不要整套带走。改得动、看得清,这才是多文件协作该有的样子。

ΔProject=∑i=1nΔfi\Delta\text{Project} = \displaystyle\sum_{i=1}^{n} \Delta f_i
一次需求引发的项目总改动量,等于每个受影响文件改动量之和。Chat+Edit 的价值,是让这个“和”变得透明——每个文件改了什么,摊开在你面前。
  1. 受影响文件集一次改动波及 n 个文件,像一套西装要动上衣、裤子和里衬。
    {f1,f2,…,fn}\left\{ f_1, f_2, \ldots, f_n \right\}
  2. 单文件改动量每个文件新增与删除的行数总和。
    Δfi\Delta f_i
  3. 项目总改动聚合全部文件改动汇总到统一 diff 视图,保证“整套衣服”协调一致。
    ΔProject=∑i=1nΔfi\Delta\text{Project} = \displaystyle\sum_{i=1}^{n} \Delta f_i

五、Diff审查:试穿这件“改动外套”

裁缝改完衣服,不会把衣服塞给你就走。他会让你站到镜子前,一处一处指给你看:这里收腰了、那里放长了,你点头,才算完工。Chat+Edit 的 diff 审查,就是这面让你“照着镜子把关”的镜子。

diff 是“修改前后对比”的视图:绿色标记新增行,红色标记删除行。AI 生成修改后,改动会以 diff 形式呈现,你可以像检查针脚一样,逐个改动块(hunk)查看,判断改动是否符合预期。

在 Cursor 的审查界面里,每个改动块都能单独接受或拒绝;你既可以全盘接受,也可以只挑满意的部分,其余手动微调。万一改坏了,回滚机制可以一键回到改动前的版本。审查时重点盯三件事:逻辑是否真的满足需求、边界条件是否处理、风格是否与周边代码一致。

有经验的用户从不当“甩手掌柜”,diff 审查永远是保留环节。正如老师傅改完必让你试穿,你也在逐块审查中真正理解了“这里为什么这么改”,代码质量与个人功力都在这一遍遍照镜子中涨起来。

Accept=∏i=1mI(diffi ok)\text{Accept} = \displaystyle\prod_{i=1}^{m} \mathbb{I}(\text{diff}_i \text{ ok})
最终采纳的标准是:所有改动块都通过审查,连乘结果才为 1。任一改动块不过关,就可以单独拒绝它,而不是把整个方案推倒重来。
  1. 改动块序列一次修改被拆成 m 个可独立审查的改动块,如领口、腰身、下摆各占一块。
    diff1,diff2,…,diffm\text{diff}_1, \text{diff}_2, \ldots, \text{diff}_m
  2. 单块判定每块按“逻辑、边界、风格”三问判断是否合格,合格记 1,不合格记 0。
    I(diffi ok)∈{0,1}\mathbb{I}(\text{diff}_i \text{ ok}) \in \{0, 1\}
  3. 整体采纳每一块都合格,乘积为 1,才整体落地;否则逐块拒绝或手动微调。
    Accept=∏i=1mI(diffi ok)\text{Accept} = \displaystyle\prod_{i=1}^{m} \mathbb{I}(\text{diff}_i \text{ ok})

六、Agent模式对比:全自动机器人 vs 手把手师傅

裁缝行当也有了“全自动改衣机器人”:你丢一句“改合身”,它自动量体、裁剪、缝纫,全程不用你插手;而 Chat+Edit 的老师傅每一步都跟你确认。遇到不同档次的活,聪明的客户会选不同的人。

Agent 与 Chat+Edit 的核心差异,就是“谁在掌控每一步”。Agent 接收目标后自动规划、逐文件修改、自行检查,像机器人一样一气呵成;Chat+Edit 则把控制权交回给你——每处改动都生成 diff,等你点头才落地。

差异带来不同的适用场景:Agent 适合目标明确、风险低的大批量任务,比如批量替换日志框架,省时但对结果要有兜底;Chat+Edit 适合核心算法调整、公共接口重构这类“影响面大、后果难预料”的改动,每一步都能及时纠偏。经验法则:改动越关键,越要把控在手里。

全自动机器人适合流水线,手把手师傅适合高定西装。理解了“控制力度”这道选择题,你就能在任务之间灵活切换——该放手时放心交给 Agent,该把关时老老实实用 Chat+Edit。这是老裁缝的智慧,也是 AI 时代工程师的素养。

Control=HumanChecksTotalSteps\text{Control} = \displaystyle\frac{\text{HumanChecks}}{\text{TotalSteps}}
控制力度 = 你参与的决策点占总步骤的比例。Agent 模式分母大、分子小,几乎全自动;Chat+Edit 模式几乎每一步都有你的确认,控制力拉满。
  1. HumanChecks(人工决策点)需要你审查、确认、纠偏的环节个数,相当于试穿次数。
    HumanChecks\text{HumanChecks}
  2. TotalSteps(总任务步数)完成整个改动需要的全部步骤数,相当于裁剪缝纫的总工序。
    TotalSteps\text{TotalSteps}
  3. 控制力度比值比值越接近 1,你的掌控感越强,付出的注意力成本也越高。
    Control=HumanChecksTotalSteps\text{Control} = \displaystyle\frac{\text{HumanChecks}}{\text{TotalSteps}}

七、实战技巧:像熟客一样使唤 AI

常去裁缝店的熟客,从不说一句“改好看点”就完事。他们会带参考图、说清穿着的场合、描述面料的毛病,还会先在小处试探师傅的手艺。用 Chat+Edit 的老手,沟通方式同样是这门“把话说清楚”的艺术。

实战技巧的底层逻辑,无非两点:提高上下文质量,降低迭代成本。说得越具体,AI 改得越准;改得越小步,审查越轻松。同样的工具,不同人手里效果天差地别,差的往往就是这些习惯。

几条立竿见影的做法:其一,描述需求用“背景+目标+约束”三要素,例如“该函数在结算流程被多处调用,希望支持折扣参数,但现有调用方不能改”;其二,一次对话只改一处,小步快改;其三,善用 Cmd+I 内联输入、Cmd+Z 回滚,搭配选中代码与 @ 引用喂养上下文;其四,改完必跑测试,让测试结果成为下一轮迭代的输入。

熟客和师傅配合默契,靠的不是玄学,而是把话说清楚、把活拆小步。把这些技巧内化成肌肉记忆,Chat+Edit 这位“AI 裁缝”就会真正成为你的得力搭档,而不是一个偶尔灵光的玩具。

PromptQuality≈Context+Goal+Boundary\text{PromptQuality} \approx \text{Context} + \text{Goal} + \text{Boundary}
一条高质量修改指令约等于:说清背景(在哪改)+ 目标(改成什么样)+ 约束(什么不能动)。三者齐备,AI 修改的一次通过率会显著提升。
  1. Context(背景)说明改动所在位置与调用关系,让 AI 知道“这是哪块料子”。
    Context\text{Context}
  2. Goal(目标)明确期望的最终行为,让 AI 知道“要改成什么款式”。
    Goal\text{Goal}
  3. Boundary(约束)划定不可触碰的边界,让 AI 知道“哪些地方不能动针线”。
    Boundary\text{Boundary}
  4. 提示质量近似三者信息越完备,AI 的理解越准,来回拉扯的次数越少。
    Quality≈信息完备度\text{Quality} \approx \text{信息完备度}

AI 应用场景

场景一:修线上 bug 的“急诊室”

阶段:问题定位与自动修复

解决的问题:线上报错时,传统流程要人肉读堆栈、顺着调用链找根因、手动改代码、再补测试,半小时打底。Chat+Edit 把“定位→修改→验证”压成一条对话链路:选中可疑函数,把报错信息贴进 Chat,AI 结合上下文直接产出修复 diff,像老师傅一眼看出“这个针脚缝歪了”。

具体案例:某电商系统结算接口偶发金额少算,堆栈指向 add_tax 函数。工程师选中该函数,在 Chat 里描述“税费计算多乘了一次”,AI 生成 price * (1 + rate) 的修改;diff 审查通过后应用,单元测试立刻跑通,全程不到五分钟。

场景二:接口改版的“多文件手术”

阶段:多文件协作与一致性修改

解决的问题:后端把 user_id 改名 userId,前端十几个文件都要跟着改,人肉逐个搜索替换容易漏,等编译报错才后悔。Chat+Edit 可以一次生成跨文件修改,所有 diff 集中呈现统一审查,就像整套西装一起量、一起改、一起试。

具体案例:某前端项目 8 个文件涉及接口字段调用。开发者选中接口定义文件,用 @ 引用 8 个调用文件,说明“字段改名,所有调用点同步更新”。AI 生成覆盖 8 个文件的 diff,开发者在审查面板逐一确认,一次提交搞定。

场景三:小步重构的“技术债清理”

阶段:代码重构与质量内建

解决的问题:维护多年的老项目里,重复代码成堆,重构又怕影响面太大。Chat+Edit 的小步快改降低了重构的心理门槛,每步改动都可见、可回滚,像拆一件旧衣服,先拆线、再重裁、每步都检查针脚。

具体案例:开发者发现三处几乎相同的日期格式化逻辑,用 Chat+Edit 把公共部分抽取成 format_date 工具函数,分三次小步完成:先建函数、再替换调用点、最后删重复代码,每步跑一遍测试再继续。

Python 演示

python62 行
import difflib BEFORE = """def add_tax(price, rate):    return price * rate""" AFTER = """def add_tax(price, rate):    return price * (1 + rate)"""  def make_diff(old, new):    # 生成标准 unified diff    old_lines = old.splitlines(keepends=True)    new_lines = new.splitlines(keepends=True)    return "".join(difflib.unified_diff(old_lines, new_lines, "before.py", "after.py"))  def split_hunks(diff_text):    # 按 @@ 标记把 diff 拆成多个改动块, 模拟逐块审查    hunks = []    current = []    for line in diff_text.splitlines():        if current and line.startswith("@@"):            hunks.append(current)            current = []        current.append(line)    if current:        hunks.append(current)    return hunks  def main():    print("=== Chat+Edit workflow simulation ===")    print("[1] User: fix tax calc, should be price*(1+rate)")    print("[2] AI suggestion:")    print(AFTER, end="")    diff = make_diff(BEFORE, AFTER)    print("[3] Generated diff:")    print(diff)    hunks = split_hunks(diff)    print("[4] Review %d hunk(s) one by one" % len(hunks))    accepted = 0    for i, hunk in enumerate(hunks, 1):        print("---- hunk %d ----" % i)        print("\n".join(hunk))        choice = input("Accept this hunk? (y/n): ").strip().lower()        if choice == "y":            accepted += 1        else:            print("Rejected, not applied")    if accepted == len(hunks):        print("[5] All accepted, applying changes!")        namespace = {}        exec(AFTER, namespace)        print("    verify: add_tax(100, 0.2) =", namespace["add_tax"](100, 0.2))    else:        print("[5] Some hunks rejected, keep the original code")  if __name__ == "__main__":    main()
目的:用 Python 模拟一次完整的 Chat+Edit 工作流——描述需求、AI 生成修改、生成 diff、逐块审查、接受后应用并验证,让你在命令行里体验“改衣试穿”的完整闭环。
  1. old_lines = old.splitlines(keepends=True)保留换行符拆分,diff 才不会丢空行
  2. return "".join(difflib.unified_diff(old_lines, new_lines, "before.py", "after.py"))用标准库 difflib 生成统一格式 diff
  3. if current and line.startswith("@@"):@@ 是每个改动块的起始标记,据此把 diff 拆成多个 hunk
  4. choice = input("Accept this hunk? (y/n): ").strip().lower()模拟人肉逐块审查,像试穿时对每个针脚表态
  5. if accepted == len(hunks):全部改动块通过才应用,对应“整体采纳”的连乘判定
  6. exec(AFTER, namespace)动态执行修改后的源码,验证修复结果是否正确

常见误区

误区Chat+Edit 不就是选中代码再按 Tab 吗?跟代码补全没有本质区别,自己手打可能还更快。

正解自动补全是“输入法联想”,只会顺着光标补下一两个词;Chat+Edit 是“裁缝改衣”,基于你对整段逻辑的描述,直接生成函数级、模块级的完整修改方案,并附带可审查的 diff。两者处理的粒度完全不同,Chat+Edit 背后是“理解需求→生成方案→落地修改”的完整链路。

为何常见:两者都在编辑器里“蹦出代码”,表面形态相似,新手很容易把“生成代码”和“补全代码”混为一谈。

误区AI 生成修改我就直接 Accept,反正错了它还能再改,看 diff 太浪费时间。

正解不看 diff 等于不试穿就付钱。AI 可能改对了主体却漏了边界条件,或引入与周边风格不一致的写法。逐块审查正是 Chat+Edit 工作流的核心环节,省掉它等于把风险全部吞下,等上线出问题时再花十倍时间返工。

为何常见:AI 整体表现惊艳,容易让人放松警惕;加上审查 diff 需要额外注意力,人的偷懒动机很强。

误区Agent 能自动跑完整项任务,Chat+Edit 还得一步一点接受,太慢,应该全面改用 Agent。

正解两者适用场景不同。Agent 适合目标明确、风险低的大批量任务;涉及核心逻辑、影响面广的改动,Chat+Edit 的逐步审查恰恰是“慢就是快”——每一步纠偏的成本,远低于全自动跑偏后的整片返工。关键改动首选 Chat+Edit,是经验法则而非保守。

为何常见:人对“全自动完成”有天然迷恋,容易忽视高风险任务中“失控”的代价。

误区我把整个项目都 `@` 给 AI,它掌握的信息最全,肯定改得最准。

正解上下文是“眼力”也是“噪音”。塞入无关文件会稀释 AI 对关键信息的注意力,甚至让它采纳错误的惯例。精准选择与本次需求相关的文件,像给老师傅递上刚好的面料和样衣,而不是把整间仓库都搬过去。

为何常见:直觉上“信息越多决策越准”,但大模型对相关性的敏感度更高,冗余信息反而干扰判断。

面试题

Q1. Chat+Edit 模式最核心的特点是?

单选题 · easy

  • A.只给建议不直接改代码
  • B.对话并生成可审查修改← 正确答案
  • C.全自动执行多步任务
  • D.仅用作代码自动补全

答案:B。Chat+Edit 的核心是“对话驱动修改”:AI 理解需求后直接生成可审查的代码改动。选项 A 是纯 Chat 模式,C 是 Agent 模式,D 是自动补全,都不符合。

Q2. 在 Cursor 中触发内联 Chat+Edit 的快捷键是?

单选题 · easy

  • A.Cmd+I 打开内联对话← 正确答案
  • B.Cmd+Z 撤销全部修改
  • C.Cmd+S 保存当前文件
  • D.Cmd+F 搜索匹配代码

答案:A。Cmd+I(Mac)/ Ctrl+I(Windows)是 Cursor 打开内联输入框的快捷键,光标所在位置就是“裁缝的工作台”。其余选项分别对应撤销、保存、搜索。

Q3. Chat+Edit 工作流的正确顺序是?

单选题 · mid

  • A.描述→选择→修改→审查
  • B.选择→描述→修改→审查← 正确答案
  • C.审查→描述→选择→修改
  • D.修改→审查→描述→选择

答案:B。正确顺序是“量体(选中代码)→ 听需求(描述)→ 下剪(修改)→ 试穿(审查)”,对应改衣四步。先选中再描述,AI 才知道改哪里、按什么需求改。

Q4. 关于上下文感知,优先级最高的是?

单选题 · mid

  • A.你选中的代码范围← 正确答案
  • B.项目的配置文件
  • C.无关的历史对话
  • D.全仓库的所有文件

答案:A。选中代码是 AI 的“第一眼”,拥有最高优先级,相当于裁缝直接量你身上那件衣服。项目配置、历史对话和仓库信息都属于外围上下文,辅助理解但不能替代选中代码。

Q5. 下列关于 diff 审查的做法,正确的有?

多选题 · mid

  • A.每个改动块可单独接受← 正确答案
  • B.也可单独拒绝某个改动块← 正确答案
  • C.审查时可手动微调结果← 正确答案
  • D.必须全盘接受不可拆分

答案:ABC。diff 审查允许逐块接受、逐块拒绝,甚至手动微调,就像试穿时可以“这处留、那处拆”。D 的说法错误,Chat+Edit 的 diff 天然支持按 hunk 拆分决策。

Q6. 一次改动共 10 个步骤,Chat+Edit 每步都要人工确认,Agent 全程只确认 2 次。哪个说法正确?

单选题 · extreme

  • A.两者控制力度完全相同
  • B.Agent 控制力度高于 Chat+Edit
  • C.Chat+Edit 控制力度高于 Agent← 正确答案
  • D.控制力度与决策点无关

答案:C。控制力度 = 人工决策点 ÷ 总步骤数。Chat+Edit 为 10/10 = 1,Agent 为 2/10 = 0.2,前者掌控感远高于后者。这也解释了为什么核心改动要选 Chat+Edit。

Q7. 核心算法重构场景下,Chat+Edit 优于 Agent 的原因是?

单选题 · hard

  • A.执行速度比 Agent 更快
  • B.每步审查可及时纠偏← 正确答案
  • C.无需任何人工干预
  • D.自动修改所有测试文件

答案:B。核心算法改动影响面大、后果难预料,Chat+Edit 的逐块审查让人能在每一步及时纠偏,避免全自动跑偏后的大面积返工。速度、免干预都不是它的优势,其价值在“可控”。

Q8. 多文件协作的核心价值是?

单选题 · easy

  • A.跨文件改动一次集中呈现← 正确答案
  • B.只能修改当前打开的文件
  • C.自动删除所有重复代码
  • D.修改后自动提交到远程

答案:A。多文件协作把一次需求涉及的所有文件改动统一放进 diff 视图,像整套西装的全身镜,让你一次看清所有改动、不容易漏改。其余选项均不是多文件协作的定义。

Q9. 提高 Chat+Edit 提示词质量的要素包括?

多选题 · mid

  • A.说清改动发生的背景← 正确答案
  • B.明确期望的行为目标← 正确答案
  • C.划定不能改动的约束← 正确答案
  • D.故意把需求说得模糊

答案:ABC。提示质量 ≈ 背景 + 目标 + 约束。说清背景让 AI 知道在哪改,明确目标让它知道改成什么样,划定约束让它知道什么不能碰。模糊需求只会换来需要反复返工的模糊结果。

Q10. 关于 Agent 与 Chat+Edit 的选择策略,正确的有?

多选题 · hard

  • A.大批量低风险任务适合 Agent← 正确答案
  • B.核心逻辑改动适合 Chat+Edit← 正确答案
  • C.Agent 全程无需人工审查
  • D.高风险任务应加强人工把关← 正确答案

答案:ABD。Agent 适合大批量、低风险任务,省时且可兜底;核心逻辑与高风险任务应选 Chat+Edit 并加强人工把关。C 错误——Agent 并非无需人工审查,任何自动改动都应有兜底验证。