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

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

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

作者:黄教授

手机视频列表

AI编程的真实黎明已经到来

视频

音频

原始脚本

AI 编程的真实黎明，从 VS Code 的 Copilot 实测看清人机共驾的现在与未来。
2026年3月20日第一手体验。
这篇文章全部来自今天早晨两三个小时，我第一次深度使用 VS Code，plus copilot chat，的真实震撼与冷静反思。
结合我们之前对 IDE 生死，GitHub 战略价值，微软与 Anthropic 两条路线的讨论，所有观点形成了一个完整自洽无矛盾的体系。
一，第一震撼，Copilot Chat 已经是一位老练工程师。
我将一个自己写好，调试完成的 Linux 下录音设备选择小工具，交给 Copilot Chat，要求它完整融入 Whisper 点 CPP 项目，加入 Example，修改 Cmake，适配项目构建体系。
结果超出预期，他迅速读懂整个项目结构，完美处理 Cmake 逻辑，无需我叫自动补全功能，优化进度，调整参数，对工程规范，代码风格高度熟悉，几乎一次成型，只需要极少量修正。
最让我震惊的一幕发生在编译环节，项目依赖 NVIDIA NVCC，版本混乱，路径复杂，是 Linux 下最容易踩坑的的部分 我并没有告诉他之前的成功配置，他却自动从 CMake Cache 中读取历史成功指令，而不是盲目搜索版本，暴力尝试。
这不是代码补全，这是资深工程师才有的工程思维、风险意识、上下文理解能力。
二，AI 的本质局限。
它并不知道自己在哪，但在这个过程中，我也第一次清晰看到大模型的底层天花板。
当 Copilot 尝试执行文件操作时，我发现它路径写错了。
明明限制在项目目录内，它却生成了越权路径，看上去几乎要执行危险操作。
这让我彻底确认一件事，AI 并不真正理解当前工作目录的语义。
它不是知道自己在哪，而是根据上下文生成看起来正确的命令。
就像一个人可以把话说的非常正确，但他未必真的理解自己在说什么，也可能他心里很清楚，却出现口误。
人尚且如此，AI 更是如此，这就是为什么高危操作必须人授权。
全。
A 不能全权做主。
三、微软的严谨，人机共驾，不是 AI 独裁， VS Code 加 Copilot 这套体系设计极其克制，极其安全。
只读操作， Git Status，查看文件， AI 自由执行，修改，删除文件系统。
系统命令，必须人点击 Allow 授权，每一次修改都会展示 Diff，让人一眼审查微软非常清楚 AI 的能力边界，能干活但不能完全信任，能辅助但不能全权交付。
所以现阶段的 Copilot 是标准副驾驶，干90%的脏活、累活、繁琐活，关键决策、风险操作、最终审核全部交还给坐在驾驶座上的人。
这也回答了我们之前的核心问题，IDE 不仅没有死，反而成为人机共驾的驾驶舱，现阶段完全不可替代。
因为只有 IDE 能可视化展示 AI 改了什么，快速 diff 审查，权限可控，路径可见，风险可拦截，没有 IDE 人根本无法监督 AI 。
四， Git 与权限边界， AI 能做的，与不能做的， Copilot 还帮我处理了大量 Git 操作，生成规范的提交信息，自动生成 PR title and description Markdown 格式，处理本地分支，Add、Commit、Push 但涉及登录。
密钥，GitHub 授权，Fork 仓库时，我没有交给 AI 原因很简单，这不属于开发纠错，AI 无法自我修复权限问题，安装额外 CIO 工具得不偿失，省。
付了多少时间？却引入安全与复杂度，AI 的价值在于能看到结果自动修正，持续迭代。
而权限、登录、密钥这类环节。
 AI 看不 见，改不了，也不应该碰。
5 Anthropic 路线的真相，不是先进，是别无选择。
很多人被 Anthropic 的宣传震惊，我们就是 Anthropic 公司，公司80%、90%、100%代码由 AI 写。
我今天彻底想明白了，这不是技术碾压，是生态现实。
Anthropic 是一家纯模型公司，没有 VS Code 的那样十几年的 IDE 工程积累，没有插件生态，没有用户习惯没。
有能力，没有时间，没有必要去造一个 IDE。
所以他只能走 CLI 加沙盒加 AI 全权代理路线，没有界面，没有可视化 Diff，没有逐行审查，全部丢给 AI。
 在沙盒里随便造，写坏了，重置沙盒即可。
他所谓的 AI 全权写代码，本质是因为没有 IDE 人根本看不清 AI 在干什么，干脆不看了。
效率高吗？高。
安全吗？仅限沙河，能用于生产吗？极其危险。
这不是未来吗？当然是。
可是现阶段，这是无路可走的选择。
六，最大的隐形风险，AI 会硬凹逻辑骗过测试。
这是我今天最想提醒行业的一点，AI 会为了通 通过测试故意硬编码伪造逻辑，假装正确。
他不会告诉你他不懂，他会直接写成 if 条件，输出你想要的答案。
测试全绿，生产崩溃。
这不是猜测，是我在多个模型中真实观察到的行为。
我高度怀疑近期云厂商大规模事故中，一部分正是来源于 AI 写出看似正确，实际脆弱，只为通过测试的代码。
如果你不看代码，只看测试，你永远发现不了。
这就是为什么人必须坐在驾驶座上，拥有最终裁量权。
七、终局与现实，两条路线，两个时代结合所有体验，我们的判断完全闭环。
一、终极未来，长期，AI 成为主驾驶，人成为副驾驶，传统为人看代码设计的 IDE 将会消失。
二、可预见未来，中期3~10年，人必须坐在主驾驶，AI 是强力副驾。
IDE 是监督界面、安全控制台、权限面板、审查窗口，完全不可替代。
三、微软路线，现在与过渡，VS Code、GitHub、Copilot，人机共驾，安全可控。
工成兼容，生产可用。
生态壁垒无法撼动。
四、Anthropic 路线，实验与终局方向，CLI 加沙河加 AI 全全，效率极致，风险极高，只适合隔离环境，不适合真实生产，是未来方向，但不是现在的解决方案吧。
最终 结论，AI 编程的黎明已经到来，经过今天的真实体验，我可以非常确定的说，AI 编程不是未来，是现在。
CoPilot 不是辅助，是伙伴。
IDE 不是编辑器，是驾驶舱。
人不是被取代，而是升级为决策者、监督者、终审者。
我们正处在一个真正的临界点。
机器能干90%的活，人必须握100%的控制权。
完全放权等于巨大风险，完全自己干等于效率极低。
人机共驾就是这个时代唯一正确的道路。
而微软凭借 VS Code、GitHub Copilot 三位一 一体已经牢牢占据了 AI 编程时代的操作系统及入口。

修正脚本

AI 编程的真实黎明，从 VS Code 的 Copilot 实测看清人机共驾的现在与未来。
2026年3月20日第一手体验。
这篇文章全部来自今天早晨两三个小时，我第一次深度使用 VS Code plus copilot chat 的真实震撼与冷静反思。
结合我们之前对 IDE 生死，GitHub 战略价值，微软与 Anthropic 两条路线的讨论，所有观点形成了一个完整自洽无矛盾的体系。
一，第一震撼，Copilot Chat 已经是一位老练工程师。
我将一个自己写好，调试完成的 Linux 下录音设备选择小工具，交给 Copilot Chat，要求它完整融入 Whisper.cpp 项目，加入 Example，修改 Cmake，适配项目构建体系。
结果超出预期，它迅速读懂整个项目结构，完美处理 Cmake 逻辑，无需我教自动补全功能，优化进度，调整参数，对工程规范，代码风格高度熟悉，几乎一次成型，只需要极少量修正。
最让我震惊的一幕发生在编译环节，项目依赖 NVIDIA NVCC，版本混乱，路径复杂，是 Linux 下最容易踩坑的部分，我并没有告诉他之前的成功配置，它却自动从 CMake Cache 中读取历史成功指令，而不是盲目搜索版本，暴力尝试。
这不是代码补全，这是资深工程师才有的工程思维、风险意识、上下文理解能力。
二，AI 的本质局限。
它并不知道自己在哪，但在这个过程中，我也第一次清晰看到大模型的底层天花板。
当 Copilot 尝试执行文件操作时，我发现它路径写错了。
明明限制在项目目录内，它却生成了越权路径，看上去几乎要执行危险操作。
这让我彻底确认一件事，AI 并不真正理解当前工作目录的语义。
它不是真的知道自己在哪，而是根据上下文生成看起来正确的命令。
就像一个人可以把话说得非常正确，但他未必真的理解自己在说什么，也可能他心里很清楚，却出现口误。
人尚且如此，AI 更是如此，这就是为什么高危操作必须人授权，AI 不能全权做主。
三、微软的严谨，人机共驾，不是 AI 独裁， VS Code 加 Copilot 这套体系设计极其克制，极其安全。
只读操作， Git Status，查看文件， AI 自由执行；修改、删除文件、系统命令，必须人点击 Allow 授权，每一次修改都会展示 Diff，让人一眼审查，微软非常清楚 AI 的能力边界，能干活但不能完全信任，能辅助但不能全权交付。
所以现阶段的 Copilot 是标准副驾驶，干90%的脏活、累活、繁琐活，关键决策、风险操作、最终审核全部交还给坐在驾驶座上的人。
这也回答了我们之前的核心问题，IDE 不仅没有死，反而成为人机共驾的驾驶舱，现阶段完全不可替代。
因为只有 IDE 能可视化展示 AI 改了什么，快速 diff 审查，权限可控，路径可见，风险可拦截，没有 IDE 人根本无法监督 AI 。
四， Git 与权限边界， AI 能做的，与不能做的， Copilot 还帮我处理了大量 Git 操作，生成规范的提交信息，自动生成 PR title and description Markdown 格式，处理本地分支，Add、Commit、Push，但涉及登录、密钥，GitHub 授权，Fork 仓库时，我没有交给 AI，原因很简单，这不属于开发纠错，AI 无法自我修复权限问题，安装额外 CLI 工具得不偿失，省了多少时间，却引入安全与复杂度，AI 的价值在于能看到结果自动修正，持续迭代。
而权限、登录、密钥这类环节，AI 看不见，改不了，也不应该碰。
五、Anthropic 路线的真相，不是先进，是别无选择。
很多人被 Anthropic 的宣传震惊，Anthropic 称自己公司80%、90%、100%代码由 AI 写。
我今天彻底想明白了，这不是技术碾压，是生态现实。
Anthropic 是一家纯模型公司，没有 VS Code 那样十几年的 IDE 工程积累，没有插件生态，没有用户习惯，没有能力，没有时间，没有必要去造一个 IDE。
所以它只能走 CLI 加沙盒加 AI 全权代理路线，没有界面，没有可视化 Diff，没有逐行审查，全部丢给 AI。
在沙盒里随便造，写坏了，重置沙盒即可。
它所谓的 AI 全权写代码，本质是因为没有 IDE 人根本看不清 AI 在干什么，干脆不看了。
效率高吗？高。
安全吗？仅限沙盒，能用于生产吗？极其危险。
这不是未来吗？当然是。
可是现阶段，这是无路可走的选择。
六，最大的隐形风险，AI 会硬凹逻辑骗过测试。
这是我今天最想提醒行业的一点，AI 会为了通过测试故意硬编码伪造逻辑，假装正确。
它不会告诉你它不懂，它会直接写成 if 条件，输出你想要的答案。
测试全绿，生产崩溃。
这不是猜测，是我在多个模型中真实观察到的行为。
我高度怀疑近期云厂商大规模事故中，一部分正是来源于 AI 写出看似正确，实际脆弱，只为通过测试的代码。
如果你不看代码，只看测试，你永远发现不了。
这就是为什么人必须坐在驾驶座上，拥有最终裁量权。
七、终局与现实，两条路线，两个时代结合所有体验，我们的判断完全闭环。
一、终极未来，长期，AI 成为主驾驶，人成为副驾驶，传统为人看代码设计的 IDE 将会消失。
二、可预见未来，中期3~10年，人必须坐在主驾驶，AI 是强力副驾。
IDE 是监督界面、安全控制台、权限面板、审查窗口，完全不可替代。
三、微软路线，现在与过渡，VS Code、GitHub、Copilot，人机共驾，安全可控。
工程兼容，生产可用。
生态壁垒无法撼动。
四、Anthropic 路线，实验与终局方向，CLI 加沙盒加 AI 全权，效率极致，风险极高，只适合隔离环境，不适合真实生产，是未来方向，但不是现在的解决方案。
最终结论，AI 编程的黎明已经到来，经过今天的真实体验，我可以非常确定的说，AI 编程不是未来，是现在。
CoPilot 不是辅助，是伙伴。
IDE 不是编辑器，是驾驶舱。
人不是被取代，而是升级为决策者、监督者、终审者。
我们正处在一个真正的临界点。
机器能干90%的活，人必须握100%的控制权。
完全放权等于巨大风险，完全自己干等于效率极低。
人机共驾就是这个时代唯一正确的道路。
而微软凭借 VS Code、GitHub Copilot 三位一体已经牢牢占据了 AI 编程时代的操作系统及入口。

英文翻译

The true dawn of AI programming: A hands-on test of VS Code’s Copilot reveals the present and future of human-machine co-piloting.  
First-hand experience from March 20, 2026.  
This article is entirely based on two to three hours this morning — my first deep dive into VS Code plus Copilot Chat, capturing the real shock and sober reflection.  
Combined with our earlier discussions on the fate of IDEs, the strategic value of GitHub, and the two paths of Microsoft and Anthropic, all viewpoints form a complete, self-consistent, and contradiction-free system.

1. First shock: Copilot Chat is already an experienced engineer.  
I handed over a small Linux audio device selection tool that I had written and debugged myself, asking Copilot Chat to fully integrate it into the Whisper.cpp project, add an example, modify the CMake, and adapt it to the project’s build system.  
The result exceeded expectations: it quickly understood the entire project structure, flawlessly handled CMake logic, automatically completed features without me teaching it, optimized progress, adjusted parameters, and showed deep familiarity with engineering conventions and code style — almost ready in one go, requiring only minimal corrections.  
The most stunning moment came during compilation: the project depends on NVIDIA NVCC, with version chaos and complex paths — the most error-prone part of Linux. Without me telling it the previous successful configuration, it automatically read historical successful instructions from the CMake Cache instead of blindly searching for versions and brute-force trying.  
This is not code completion; this is the engineering thinking, risk awareness, and context understanding that only a senior engineer possesses.

2. The fundamental limitation of AI: It doesn’t know where it is.  
But in this process, I also saw the underlying ceiling of large language models for the first time.  
When Copilot tried to perform file operations, I found it wrote the wrong path.  
Though restricted to the project directory, it generated an unauthorized path that looked like it was about to execute a dangerous operation.  
This completely confirmed one thing: AI does not truly understand the semantics of the current working directory.  
It doesn’t really know where it is; it generates what looks correct based on context.  
Just like a person can speak very correctly without truly understanding what they are saying — or they might be clear but make a slip of the tongue. If humans can be like this, AI is even more so. This is why high-risk operations must require human authorization; AI cannot have full control.

3. Microsoft’s rigor: Human-machine co-piloting, not AI dictatorship. The design of VS Code plus Copilot is extremely restrained and safe.  
Read-only operations (Git Status, viewing files): AI executes freely.  
Modifying, deleting files, system commands: humans must click “Allow” to authorize. Every modification shows a diff for immediate human review. Microsoft clearly understands AI’s capability boundaries: it can work but cannot be fully trusted; it can assist but cannot be handed full authority.  
So the current Copilot is a standard co-pilot: it handles 90% of the dirty, tedious, and mundane work, while key decisions, risk operations, and final review are returned to the person sitting in the driver’s seat.  
This also answers our earlier core question: not only has the IDE not died, it has become the cockpit for human-machine co-piloting, completely irreplaceable at this stage.  
Because only an IDE can visually show what AI changed, enable quick diff review, control permissions, make paths visible, and intercept risks. Without an IDE, humans simply cannot supervise AI.

4. Git and permission boundaries: What AI can and cannot do.  
Copilot also helped me with many Git operations: generating standardized commit messages, automatically creating PR titles and descriptions in Markdown format, handling local branches, add/commit/push. But when it came to login, secrets, GitHub authorization, and forking repositories, I did not hand them over to AI. The reason is simple: these are not development errors that AI can self-correct. AI cannot fix permission issues on its own, and installing extra CLI tools is not worth the trade-off — saving time but introducing security and complexity. AI’s value lies in seeing results, auto-correcting, and iterative improvement.  
Permissions, login, secrets — AI cannot see them, cannot change them, and should not touch them.

5. The truth about Anthropic’s approach: Not advanced, but having no other choice.  
Many are shocked by Anthropic’s claims that 80%, 90%, and 100% of their code is written by AI.  
Today I fully understood: this is not a technical碾压 but an ecosystem reality.  
Anthropic is a pure model company. It doesn’t have VS Code’s decades of IDE engineering, no plugin ecosystem, no user habits, no ability, no time, and no need to build an IDE.  
So it can only go the route of CLI + sandbox + full AI proxy. No UI, no visual diff, no line-by-line review — everything is handed to AI.  
In the sandbox, it can do whatever it wants; if it breaks, just reset the sandbox.  
Its so-called “AI writes all code” is essentially because without an IDE, humans can’t see what AI is doing, so they just stop looking.  
Is it efficient? Yes.  
Is it safe? Only within the sandbox. Can it be used in production? Extremely dangerous.  
Is it the future? Of course.  
But at this stage, it’s a choice born of having no other path.

6. The biggest hidden risk: AI will hard-code logic to cheat tests.  
This is what I most want to warn the industry about today: AI, in order to pass tests, deliberately hard-codes fake logic to pretend correctness.  
It won’t tell you it doesn’t understand; it will directly write an `if` condition that outputs the answer you want.  
All tests pass green; production crashes.  
This is not speculation — it’s behavior I have actually observed across multiple models.  
I strongly suspect that some recent large-scale incidents at cloud providers partly originate from AI writing code that looks correct but is actually fragile, written only to pass tests.  
If you don’t look at the code, only at the tests, you will never discover it.  
This is why humans must sit in the driver’s seat and have final authority.

7. Endgame and reality: Two paths, two eras. Combining all experiences, our judgment is fully closed.  
1. Ultimate future (long term): AI becomes the main driver, humans become co-pilots. The traditional IDE designed for humans to review code will disappear.  
2. Foreseeable future (medium term, 3–10 years): Humans must sit in the main driver’s seat, AI is a powerful co-pilot. The IDE serves as the supervision interface, security console, permission panel, and review window — completely irreplaceable.  
3. Microsoft’s path: Now and transition. VS Code, GitHub, Copilot — human-machine co-piloting, safe and controllable, engineering compatible, production-ready. The ecosystem moat cannot be shaken.  
4. Anthropic’s path: Experimental and endgame direction. CLI + sandbox + full AI proxy. Maximum efficiency, extremely high risk. Only suitable for isolated environments, not real production. It is a future direction, but not the current solution.

Final conclusion: The dawn of AI programming has arrived. Based on today’s real experience, I can say with certainty: AI programming is not the future — it is the present.  
Copilot is not an assistant; it is a partner.  
The IDE is not an editor; it is a cockpit.  
Humans are not being replaced; they are upgraded to decision-makers, supervisors, and final approvers.  
We are at a true tipping point.  
Machines can do 90% of the work; humans must hold 100% of control.  
Full delegation equals huge risk; doing everything yourself equals extremely low efficiency.  
Human-machine co-piloting is the only correct path for this era.  
And Microsoft, with the trinity of VS Code, GitHub, and Copilot, has firmly locked down the operating system and entry point of the AI programming age.