我的征尘是星辰大海。。。

The dirt and dust from my pilgrimage forms oceans of stars...

-------当记忆的篇章变得零碎，当追忆的图片变得模糊，我们只能求助于数字存储的永恒的回忆

作者:黄教授

手机视频列表

IDE副驾驶范式的终结与CLI代理的必然

视频

音频

原始脚本

IDE 副驾驶范式的终结与 CLI 代理的必然未来。
微软 CEO 纳德拉的公开信揭示了 AI 落地企业研发的核心矛盾。
企业投入双重成本，固定不变的人力薪资，持续新增的模型 token 算力成本，却没能换取对等的产能增长。
行业普遍的尴尬现状，根源并非模型能力不足。
而是工具范式错配。
当前主流的 cursor vs code copilot t r a e 等 i d e 类 a i 工具全部延续人类监督、分布确认。
可视化校验的副驾驶协作逻辑。
这套模式适配传统人工编码，却完全不适配 AI 自主工程的核心需求。
很多人存在认知误区。
只要关闭 IDE 人工确认弹窗，开启全自动模式， IDE 就能实现和 CLI 一致的自主生产力。
事实上，表层交互可以模拟。
但沙盒隔离、轻量运行、多 Agent 并发、无界面自制四大底层刚需，是 IDE 架构永远无法突破的天花板。
AI 编程的终极方向。
从来不是人盯着 AI 写代码，而是沙盒全权托管， AI 全程自治，人类仅验收结果。
基于此，重型 IDE 范式已注定过时。
轻量独立 CLI 代理是唯一符合未来趋势的技术路线。
一、 IDE 副驾驶范式的核心商业悖论，双重投入。
产能停滞，传统 IDEI 协作模式存在无法破解的企业经营死循环。
对企业而言，人力成本是刚性固定支出，员工薪资、编制、工时不会因 AI 提速而降低。
AI 将数小时编码工作压缩至数十分钟后，员工节省的时间几乎不会转化为新增产能，大多消耗在文档优化、碎片化修整等低价值事物中。
核心业务交付量近乎停滞。
与此同时，企业需要持续承担模型调用、 API 订阅的算力成本，最终形成人力、算力双向付费。
产能原地踏步的悖论。
造成这一现象的根本瓶颈不是模型推理速度，而是 IDE 的人机交互机制锁死了生产力。
IDE 的设计逻辑强制拆分工程流程。
AI 每完成一段修改，必须暂停等待人工审阅 diff 确认变更。
整条流水线的速度上限被人类阅读陌生代码的低效认知速度锁死。
AI 强大的连续自主执行能力被完全浪费，大量 token 消耗在重复会话重建、上下文重载中，算力利用率极低。
更关键的是这种人工兜底的模式完全违背 AI 工程的高效逻辑。
人工逐行校验的成本极高，阅读 AI 生成的碎片化代码耗时往往远超自主编写。
所谓人机协同，最终变成了 AI 被人的低效绑架。
这也是当下企业 AI 投入无法落地产能增量的核心原因。
二、致命硬伤，重型 IDE 架构，天生无法适配沙盒自治体系， AI 自主工程的唯一安全高效落地方式。
是沙盒隔离运行。
未来所有 AI 自动化任务、批量工程迭代、多轮调试修复、嵌入式持续作业，都必须跑在资源受限。
环境纯净，完全隔离的沙盒环境中。
沙盒的核心特性是轻量、无界面、低资源占用，可一键重置，环境纯净封闭。
而 VS Code  Cursor tray 等所有 IDE 产品，基于 Electron 重型图形架构，自带海量冗余能力，完全不满足沙盒运行的底层要求。
存在三大致命缺陷。
第一，资源臃肿，无法适配沙盒轻量化约束。
IDE 集成图形渲染、文件监听。
语法校验、海量插件生态、界面交互等冗余功能，进程庞大，内存占用极高。
沙盒的设计初衷是隔离资源，限制权限。
保证环境纯净稳定。
中型 IDE 的海量后台进程、冗余服务、插件冲突，会直接破坏沙盒的隔离性与稳定性，完全不具备托管自动化任务的基础条件。
第二，强依赖图形界面，无法实现无界面自治。
沙盒自动化场景、服务器后台、嵌入式边缘设备，普遍无桌面、无图形渲染环境。
IDE 的核心运行逻辑绑定图形窗口，进程生命周期完全依赖界面存活，关闭窗口即销毁所有任务，清空上下文。
根本无法支撑七乘二十四小时离线自制、后台持续迭代的工程需求。
第三，调度权倒置，不支持纯机器驱动的自动化流程。
IDE 的核心主控是编辑器宿主，AI 插件仅为附属子程序。
所有文件操作、终端调用、任务调度必须经过 IDE 内核审批排队。
沙盒自治的核心是 AI 全权主导，机器自主闭环。
IDE 的人工优先、界面优先、宿主优先的调度逻辑与纯自动化流程完全相悖。
微软在2026年5~6月紧急推出轻量化 Copilot 专用编辑器，阉割大量 IDE 功能，简化界面布局。
该产品依旧基于 Electron 图形架构。
只是缓解了卡顿崩溃问题，没有摆脱重型架构的底层枷锁，依旧无法适配沙盒隔离。
恰恰反向证明完整 IDE 已是 AI 自治时代的沉重负资产。
三、未来必然是多 Agent 并发，IDE 架构完全无力承载 AI 工程的下一阶段核心形态，是多 Agent 分工协作、并发自治。
而非单一对话交互。
复杂工程会拆解为规划 Agent 编码 Agent 测试 Agent 记忆管理 Agent 调试 Agent 多进程并行执行，各司其职，闭环迭代。
这是规模化提效的唯一路径。
这套未来形态直接宣判 IDE 范式的终结。
第一， IDE 单进程、单线程模型，不支持多隔离 Agent 并发，复杂任务极易阻塞、超时，上下文断裂。
第二。
多 Agent 自动化任务，完全不需要可视化界面。
多 Agent 协作是纯机器与机器的调度闭环， IDE 引以为傲的可视化编辑。
交互式审核能力在自制场景中不仅无用，反而是占用资源、阻碍流程、破坏闭环的累赘。
未来的 AI 工程客户端本质是轻量远程调度终端。
只需完成 API 转发、任务调度、记忆维护、沙盒联动四大核心功能。
IDE 庞大的编辑器内核、图形交互系统、海量插件兼容体系。
全部属于无效冗余设计。
四、 CLI 自制代理，唯一适配沙盒与多 Agent 未来的终极形态，独立 CLI AI 代理。
Cloud Code  Open Code 等的所有优势，都精准匹配 AI 工程的未来底层逻辑，是 IDE 无法企及的。
其一。
纯净态轻量架构，完美适配沙盒环境。
沙盒运行部署是一个难题，CLI 编译成独立单二进制文件，能做到零依赖，拷贝即部署。
其二，AI 全权主导任务调度，实现纯机器闭环。
CLI 以 AI 运行时为唯一核心，自主完成任务拆解。
多文件修改、编译调试、报错迭代、记忆更新，无 IDE 宿主调度干预。
其三，独立进程生命周期，支持长期自治迭代。
CLI 进程与界面完全解耦，可后台离线运行。
重启后依托独立持久化记忆引擎，完整保留项目架构、编码规范、历史调试记录。
无需重复沟通兜底，大幅降低无效 token 消耗。
其次，原生支持多 agent 并发协作， cli 独立进程模型。
支持多隔离 Agent 并行运行、分工调度，适配未来复杂工程的拆解式、并发式、自动化迭代需求，是规模化 AI 工程落地的唯一载体。
五，范式终局， IDE 为辅， CLI 为核。
从短期市场来看， IDE 工具仍有存在价值。
对于新手开发者碎片化、轻量编码、单行补全、及时调试， IDE 的可视化交互更贴合大众使用习惯，适合轻量化辅助场景。
但从长期产业眼镜来看，副驾驶 IDE 范式已走到技术天花板。
它的重型架构无法适配沙盒隔离，图形依赖无法实现无界面自治，宿主调度无法支撑多 Agent 并发。
所有核心短板都是架构性、永久性的，无法通过功能迭代、模式开关修复。
AI 编程的未来，不再是人监督 AI 干活。
而是人类定义顶层目标，沙盒承载自治流程，多 agent 完成全链路工程交付，人类仅最终验收成果。
这套终局逻辑直接决定了工具迭代方向。
笨重、依附界面、无法自制的 IDE 必然持续边缘化。
轻量、独立、可沙盒托管。
支持多 Agent 并发的 CLI 自制代理是 AI 工程工具不可逆转的演进主线。

修正脚本

IDE 副驾驶范式的终结与 CLI 代理的必然未来。
微软 CEO 纳德拉的公开信揭示了 AI 落地企业研发的核心矛盾。
企业投入双重成本，固定不变的人力薪资，持续新增的模型 token 算力成本，却没能换取对等的产能增长。
行业普遍的尴尬现状，根源并非模型能力不足。
而是工具范式错配。
当前主流的 cursor vs code copilot t r a e 等 i d e 类 a i 工具全部延续人类监督、分步确认、可视化校验的副驾驶协作逻辑。
这套模式适配传统人工编码，却完全不适配 AI 自主工程的核心需求。
很多人存在认知误区。
只要关闭 IDE 人工确认弹窗，开启全自动模式， IDE 就能实现和 CLI 一致的自主生产力。
事实上，表层交互可以模拟。
但沙盒隔离、轻量运行、多 Agent 并发、无界面自治四大底层刚需，是 IDE 架构永远无法突破的天花板。
AI 编程的终极方向。
从来不是人盯着 AI 写代码，而是沙盒全权托管， AI 全程自治，人类仅验收结果。
基于此，重型 IDE 范式已注定过时。
轻量独立 CLI 代理是唯一符合未来趋势的技术路线。
一、 IDE 副驾驶范式的核心商业悖论，双重投入。
产能停滞，传统 IDE 协作模式存在无法破解的企业经营死循环。
对企业而言，人力成本是刚性固定支出，员工薪资、编制、工时不会因 AI 提速而降低。
AI 将数小时编码工作压缩至数十分钟后，员工节省的时间几乎不会转化为新增产能，大多消耗在文档优化、碎片化修整等低价值事务中。
核心业务交付量近乎停滞。
与此同时，企业需要持续承担模型调用、 API 订阅的算力成本，最终形成人力、算力双向付费。
产能原地踏步的悖论。
造成这一现象的根本瓶颈不是模型推理速度，而是 IDE 的人机交互机制锁死了生产力。
IDE 的设计逻辑强制拆分工程流程。
AI 每完成一段修改，必须暂停等待人工审阅 diff 确认变更。
整条流水线的速度上限被人类阅读陌生代码的低效认知速度锁死。
AI 强大的连续自主执行能力被完全浪费，大量 token 消耗在重复会话重建、上下文重载中，算力利用率极低。
更关键的是这种人工兜底的模式完全违背 AI 工程的高效逻辑。
人工逐行校验的成本极高，阅读 AI 生成的碎片化代码耗时往往远超自主编写。
所谓人机协同，最终变成了 AI 被人的低效绑架。
这也是当下企业 AI 投入无法落地产能增量的核心原因。
二、致命硬伤，重型 IDE 架构，天生无法适配沙盒自治体系， AI 自主工程的唯一安全高效落地方式。
是沙盒隔离运行。
未来所有 AI 自动化任务、批量工程迭代、多轮调试修复、嵌入式持续作业，都必须跑在资源受限、环境纯净、完全隔离的沙盒环境中。
沙盒的核心特性是轻量、无界面、低资源占用，可一键重置，环境纯净封闭。
而 VS Code  Cursor Trae 等所有 IDE 产品，基于 Electron 重型图形架构，自带海量冗余能力，完全不满足沙盒运行的底层要求。
存在三大致命缺陷。
第一，资源臃肿，无法适配沙盒轻量化约束。
IDE 集成图形渲染、文件监听、语法校验、海量插件生态、界面交互等冗余功能，进程庞大，内存占用极高。
沙盒的设计初衷是隔离资源，限制权限。
保证环境纯净稳定。
中型 IDE 的海量后台进程、冗余服务、插件冲突，会直接破坏沙盒的隔离性与稳定性，完全不具备托管自动化任务的基础条件。
第二，强依赖图形界面，无法实现无界面自治。
沙盒自动化场景、服务器后台、嵌入式边缘设备，普遍无桌面、无图形渲染环境。
IDE 的核心运行逻辑绑定图形窗口，进程生命周期完全依赖界面存活，关闭窗口即销毁所有任务，清空上下文。
根本无法支撑七乘二十四小时离线自治、后台持续迭代的工程需求。
第三，调度权倒置，不支持纯机器驱动的自动化流程。
IDE 的核心主控是编辑器宿主，AI 插件仅为附属子程序。
所有文件操作、终端调用、任务调度必须经过 IDE 内核审批排队。
沙盒自治的核心是 AI 全权主导，机器自主闭环。
IDE 的人工优先、界面优先、宿主优先的调度逻辑与纯自动化流程完全相悖。
微软在2026年5~6月紧急推出轻量化 Copilot 专用编辑器，阉割大量 IDE 功能，简化界面布局。
该产品依旧基于 Electron 图形架构。
只是缓解了卡顿崩溃问题，没有摆脱重型架构的底层枷锁，依旧无法适配沙盒隔离。
恰恰反向证明完整 IDE 已是 AI 自治时代的沉重负资产。
三、未来必然是多 Agent 并发，IDE 架构完全无力承载 AI 工程的下一阶段核心形态，是多 Agent 分工协作、并发自治。
而非单一对话交互。
复杂工程会拆解为规划 Agent、编码 Agent、测试 Agent、记忆管理 Agent、调试 Agent 多进程并行执行，各司其职，闭环迭代。
这是规模化提效的唯一路径。
这套未来形态直接宣判 IDE 范式的终结。
第一， IDE 单进程、单线程模型，不支持多隔离 Agent 并发，复杂任务极易阻塞、超时，上下文断裂。
第二，多 Agent 自动化任务，完全不需要可视化界面。
多 Agent 协作是纯机器与机器的调度闭环， IDE 引以为傲的可视化编辑、交互式审核能力在自治场景中不仅无用，反而是占用资源、阻碍流程、破坏闭环的累赘。
未来的 AI 工程客户端本质是轻量远程调度终端。
只需完成 API 转发、任务调度、记忆维护、沙盒联动四大核心功能。
IDE 庞大的编辑器内核、图形交互系统、海量插件兼容体系。
全部属于无效冗余设计。
四、 CLI 自治代理，唯一适配沙盒与多 Agent 未来的终极形态，独立 CLI AI 代理。
Cloud Code  Open Code 等的所有优势，都精准匹配 AI 工程的未来底层逻辑，是 IDE 无法企及的。
其一。
纯净态轻量架构，完美适配沙盒环境。
沙盒运行部署是一个难题，CLI 编译成独立单二进制文件，能做到零依赖，拷贝即部署。
其二，AI 全权主导任务调度，实现纯机器闭环。
CLI 以 AI 运行时为唯一核心，自主完成任务拆解。
多文件修改、编译调试、报错迭代、记忆更新，无 IDE 宿主调度干预。
其三，独立进程生命周期，支持长期自治迭代。
CLI 进程与界面完全解耦，可后台离线运行。
重启后依托独立持久化记忆引擎，完整保留项目架构、编码规范、历史调试记录。
无需重复沟通兜底，大幅降低无效 token 消耗。
其次，原生支持多 agent 并发协作， cli 独立进程模型。
支持多隔离 Agent 并行运行、分工调度，适配未来复杂工程的拆解式、并发式、自动化迭代需求，是规模化 AI 工程落地的唯一载体。
五、范式终局， IDE 为辅， CLI 为核。
从短期市场来看， IDE 工具仍有存在价值。
对于新手开发者碎片化、轻量编码、单行补全、及时调试， IDE 的可视化交互更贴合大众使用习惯，适合轻量化辅助场景。
但从长期产业演进来看，副驾驶 IDE 范式已走到技术天花板。
它的重型架构无法适配沙盒隔离，图形依赖无法实现无界面自治，宿主调度无法支撑多 Agent 并发。
所有核心短板都是架构性、永久性的，无法通过功能迭代、模式开关修复。
AI 编程的未来，不再是人监督 AI 干活。
而是人类定义顶层目标，沙盒承载自治流程，多 agent 完成全链路工程交付，人类仅最终验收成果。
这套终局逻辑直接决定了工具迭代方向。
笨重、依附界面、无法自治的 IDE 必然持续边缘化。
轻量、独立、可沙盒托管、支持多 Agent 并发的 CLI 自治代理是 AI 工程工具不可逆转的演进主线。

英文翻译

The End of the IDE Copilot Paradigm and the Inevitable Future of CLI Agents.  
Microsoft CEO Nadella's open letter reveals the core contradiction in AI's implementation within enterprise R&D.  
Enterprises bear dual costs: fixed human salaries and continuously increasing model token compute costs, yet fail to achieve proportional productivity growth.  
The root cause of this widespread industry embarrassment is not insufficient model capability.  
But a paradigm mismatch in tools.  
Current mainstream IDE-based AI tools like Cursor, VS Code Copilot, and Trae all follow the copilot collaboration logic of human supervision, step-by-step confirmation, and visual verification.  
This model suits traditional manual coding but is completely incompatible with the core needs of autonomous AI engineering.  
Many people hold a misconception:  
Simply disabling IDE manual confirmation pop-ups and enabling full automation mode will make the IDE achieve the same autonomous productivity as a CLI.  
In reality, superficial interaction can be simulated.  
But the four fundamental requirements—sandbox isolation, lightweight execution, multi-agent concurrency, and headless autonomy—are ceilings that IDE architecture can never break through.  
The ultimate direction of AI programming:  
It has never been humans watching AI write code, but full sandbox delegation, full AI autonomy, with humans only verifying results.  
Based on this, the heavy IDE paradigm is already obsolete.  
Lightweight, standalone CLI agents are the only technical path that aligns with future trends.

I. The Core Business Paradox of the IDE Copilot Paradigm: Dual Investment, Stagnant Productivity.  
The traditional IDE collaborative model creates an unsolvable vicious cycle for enterprise operations.  
For enterprises, labor costs are rigid fixed expenses: employee salaries, headcount, and working hours do not decrease due to AI acceleration.  
When AI compresses hours of coding work into tens of minutes, the time saved by employees is almost never converted into new productivity, mostly consumed in low-value tasks like documentation optimization and fragmented adjustments.  
Core business delivery stagnates.  
Meanwhile, enterprises must continuously bear compute costs for model calls and API subscriptions, ultimately resulting in dual payments for both labor and compute.  
The paradox of productivity stagnation.  
The fundamental bottleneck behind this phenomenon is not model inference speed, but the human-computer interaction mechanism of IDEs locking down productivity.  
IDE design logic forces the engineering process to be broken down.  
Every time AI completes a modification, it must pause for human review of the diff and confirmation of changes.  
The speed limit of the entire pipeline is locked by the slow cognitive speed of humans reading unfamiliar code.  
AI's powerful continuous autonomous execution capability is completely wasted, with large amounts of tokens consumed in repeated session reconstruction and context reloading, leading to extremely low compute utilization.  
More critically, this human-fallback model completely violates the efficient logic of AI engineering.  
The cost of human line-by-line verification is extremely high; reading fragmented AI-generated code often takes longer than writing it manually.  
The so-called human-machine collaboration ultimately becomes AI being shackled by human inefficiency.  
This is the core reason why enterprise AI investment fails to translate into productivity gains.

II. Fatal Flaw: Heavy IDE Architecture Is Inherently Incapable of Adapting to Sandbox Autonomy.  
The only safe and efficient way to implement autonomous AI engineering is sandboxed operation.  
In the future, all AI automation tasks, batch engineering iterations, multi-round debugging and fixes, and embedded continuous operations must run in sandbox environments that are resource-constrained, clean, and fully isolated.  
The core characteristics of a sandbox are lightweight, headless, low resource consumption, one-click reset, and a clean and closed environment.  
All IDE products such as VS Code, Cursor, and Trae are based on Electron's heavy graphical architecture, which comes with massive redundancy and completely fails to meet the basic requirements of sandbox operation.  
There are three fatal defects:  
First, resource bloat: unable to adapt to sandbox lightweight constraints.  
IDEs integrate graphical rendering, file watching, syntax checking, massive plugin ecosystems, and interface interactions, resulting in large processes and high memory usage.  
Sandboxes are designed to isolate resources and restrict permissions, ensuring environmental purity and stability.  
The numerous background processes, redundant services, and plugin conflicts of medium-sized IDEs directly undermine sandbox isolation and stability, lacking the basic conditions for hosting automated tasks.  
Second, heavy dependence on graphical interfaces: unable to achieve headless autonomy.  
Sandbox automation scenarios, server backends, and embedded edge devices typically have no desktop or graphical rendering environment.  
The core operation logic of IDEs is tied to graphical windows; the lifecycle of processes depends entirely on the interface's existence. Closing the window destroys all tasks and clears context.  
This cannot support 24/7 offline autonomy or continuous background iteration engineering requirements.  
Third, inverted scheduling authority: does not support machine-driven automation workflows.  
The core controller of an IDE is the editor host, with AI plugins serving only as subordinate subroutines.  
All file operations, terminal calls, and task scheduling must go through the IDE kernel for approval and queuing.  
The core of sandbox autonomy is full AI authority and machine self-closure.  
The scheduling logic of IDEs—human-first, interface-first, host-first—completely contradicts pure automation workflows.  
Microsoft urgently launched a lightweight Copilot-specific editor around May-June 2026, removing many IDE features and simplifying the interface layout.  
This product is still based on the Electron graphical architecture.  
It only alleviates lag and crashes but does not shed the underlying shackles of the heavy architecture, remaining unable to adapt to sandbox isolation.  
This paradoxically proves that the full IDE has become a heavy burden in the era of AI autonomy.

III. The Future Is Inevitably Multi-Agent Concurrency; IDE Architecture Is Completely Incapable of Supporting the Next Stage of AI Engineering.  
The core form of the next stage is multi-agent division of labor and concurrent autonomy, not single-dialogue interaction.  
Complex engineering tasks will be decomposed into planning agents, coding agents, testing agents, memory management agents, and debugging agents, running in parallel, each with its own role, forming a closed-loop iteration.  
This is the only path to large-scale efficiency gains.  
This future form directly pronounces the end of the IDE paradigm.  
First, the single-process, single-thread model of IDEs does not support multi-isolated agent concurrency; complex tasks are prone to blocking, timeouts, and context fragmentation.  
Second, multi-agent automation tasks require no visual interface.  
Multi-agent collaboration is a pure machine-to-machine scheduling loop. The visual editing and interactive review capabilities that IDEs pride themselves on are not only useless in autonomous scenarios but are burdens that consume resources, hinder processes, and break the closed loop.  
The future AI engineering client is essentially a lightweight remote scheduling terminal.  
It only needs to perform four core functions: API forwarding, task scheduling, memory maintenance, and sandbox linkage.  
The massive editor kernel, graphical interaction system, and vast plugin compatibility system of IDEs are all redundant designs.

IV. CLI Autonomous Agent: The Only Ultimate Form That Adapts to Sandbox and Multi-Agent Future.  
Standalone CLI AI agents (such as Cloud Code, Open Code) have all their advantages perfectly aligned with the future underlying logic of AI engineering, which IDEs cannot match.  
First, pure lightweight architecture, perfectly adapting to sandbox environments.  
Deploying in a sandbox is a challenge. CLI compiled into a standalone single binary file achieves zero dependencies, copy-and-deploy.  
Second, AI fully controls task scheduling, achieving a pure machine closed loop.  
With the AI runtime as the sole core, CLI autonomously completes task decomposition, including multi-file modification, compilation debugging, error iteration, and memory updates, without IDE host scheduling intervention.  
Third, independent process lifecycle, supporting long-term autonomous iteration.  
CLI processes are fully decoupled from the interface and can run offline in the background. After restart, it relies on an independent persistent memory engine to completely retain project architecture, coding standards, and historical debugging records.  
No repeated communication overhead, significantly reducing invalid token consumption.  
Fourth, native support for multi-agent concurrent collaboration. The CLI independent process model supports parallel operation and division scheduling of multiple isolated agents, adapting to the decomposed, concurrent, and automated iteration needs of future complex engineering. It is the only carrier for large-scale AI engineering implementation.

V. Paradigm Endgame: IDE as Supplement, CLI as Core.  
From a short-term market perspective, IDE tools still have value.  
For novice developers, fragmented and lightweight coding, single-line completion, and real-time debugging—the visual interaction of IDEs suits general usage habits and is suitable for lightweight auxiliary scenarios.  
But from a long-term industry evolution perspective, the copilot IDE paradigm has reached its technical ceiling.  
Its heavy architecture cannot adapt to sandbox isolation; its graphical dependency cannot achieve headless autonomy; its host scheduling cannot support multi-agent concurrency.  
All core shortcomings are architectural and permanent, impossible to fix through feature iterations or mode switches.  
The future of AI programming is no longer humans supervising AI doing work.  
Rather, humans define top-level goals, sandboxes host autonomous workflows, and multi-agents complete full-chain engineering delivery, with humans only reviewing the final results.  
This endgame logic directly determines the direction of tool evolution.  
Bulky, interface-dependent, non-autonomous IDEs will inevitably continue to be marginalized.  
Lightweight, independent, sandbox-hostable, multi-agent-concurrent CLI autonomous agents are the irreversible evolutionary mainline of AI engineering tools.