我的征尘是星辰大海。。。
The dirt and dust from my pilgrimage forms oceans of stars...
-------当记忆的篇章变得零碎，当追忆的图片变得模糊，我们只能求助于数字存储的永恒的回忆
作者:黄教授
手机视频列表
从十几年前嘲笑英语程序员到今天活成了当年最看不起的样子
视频
音频
原始脚本
从十几年前嘲笑英语程序员，到今天我活成了当初我最鄙视的样子。 十几年前我还在写代码，年轻气盛，信奉一句程序员圈子里的老话。 Read the fucking code 代码本身就是逻辑，代码就是文档，代码就是最好的注释。 看不懂代码才需要靠注释活着。 那时我暗地里嘲笑过一位同事，给他起了个外号， English Programmer 英语程序员。 我并不清楚他工作的全部细节，但我始终认为。 他看不懂代码真正的逻辑结构与意图，只能依赖注释里的自然语言理解功能。 注释说什么，他信什么。 代码是否藏坑，是否误导。 是否与注释不符，他无力分辨，更不敢深究。 在当年老派程序员的观念里，这种人根本不配修改这段代码，不配坐在这个岗位上。 只会读人话，不会读代码，算什么程序员？我那时坚信自己永远不会变成这样。 十几年后，我不仅变成了他，还比他更彻底、更摆烂。 更远离真正的代码。 一、注释泛滥的真相。 不是规范，是摸鱼，是刷工作量，是对抗监控。 很多人以为注释越来越多，是行业更规范、更专业了。 真正混过职场，尤其在硅谷待过才懂，注释泛滥本质是懒惰与监控对抗出来的畸形产物。 早年真正写核心系统、写底层库的人，比如 Linux 之父 Linus 那句名言，RTFC，态度极其鲜明。 代码能讲清楚的，绝不写注释。 非必要不注释，不做冗余解释。 只有逻辑容易被误解、行为反直觉、坑位明显的地方，才会写一句精简提醒。 在他们眼里，看得懂代码是基本职业尊严，每行都写注释是对阅读者智商的侮辱，满屏废话注释说明作者要么不自信，要么代码写得烂。 可现代职场完全变了味。 尤其远程办公普及后，公司开始用各种手段监控工作量， vpn 在线时长、 Git 提交频率、 PR 行数。 Patch 体积、代码增量、文档产出，一切都被量化、被统计、被拿来当绩效依据。 程序员为了对抗监控，刷出好看的工作量。 找到了最安全、最无风险、最不会出错的方式，疯狂写注释、写文档、写冗余说明。 一行逻辑清晰的代码，非要写三行注释。 一个一眼看懂的函数，非要写一段长篇说明。 一个简单参数，非要补格式、补示例、补历史、补边界。 代码不敢随便改。 改出问题要背锅，注释随便加，加再多都是规范严谨、可维护性、政治绝对正确。 于是注释成了摸鱼的最佳掩护。 没事干就写注释、写文档、润色文案、调整格式，刷 git 提交量。 代码没几行，注释占七成， patch 看起来又大又饱满。 上司一看，这人勤奋、严谨，输出稳定。 只有内行心里清楚，这不是开发，这是文字水字数，是最高级的摸鱼。 English programmer 正是在这种环境里批量诞生的。 注释越来越多，代码越来越被掩盖，新人不再习惯读代码，只会读注释。 注释变成了官方标准答案，代码反而成了附属品。 最后，一群只会读注释，不会读代码，不敢碰代码，改代码只看注释的人占据了大量岗位。 这就是我当年嘲笑的英语程序员。 读得懂人话，读不懂机器语言。 信注释，不信代码。 在老派观念里，这是职业底线的失守。 在现代职场里，这是生存最优解。 二、从 CV 拷贝粘贴到 VC 分为编程，懒惰没有下限，只有不断进化。 如果说 English Programmer 还需要看注释。 改代码，那 ai 时代的氛围编程 web coding 已经把懒惰推到了当年无法想象的地步。 早年没有 ai 程序员最普遍的偷懒叫 cv 工程师。 Copy paste 复制粘贴，东抄一段，西拼一段，改改参数，能跑就行，是心照不宣的基础摸鱼。 而分为编程 VC Vibe Coding 是 cv 的终极形态。 打开 ide 挂着 ai 窗口全开，人往椅子上一坐，先把正在深度开发的氛围拉满。 需求丢给 AI 代码 AI 写，报错 AI 解，逻辑 AI 顺，注释 AI 帮你写满。 你只需要偶尔瞟一眼，轻飘飘丢几句指令。 这里不对，再改一版，差不多行了。 我现在已经懒到突破底线，AI把完整代码、运行命令、注意事项全部递到眼前。 我只需要复制、粘贴，点一下运行，三步而已。 我都懒得动，扫一眼结构合理，心里默认能跑，关掉窗口，喝茶发呆。 出门闲逛，代码跑没跑，通不通，有没有坑，完全不重要。 代码是否执行不重要，我在认真工作的氛围到位就赢了。 十几年前的我会认为这种人无可救药。 如今我承认人类的懒惰没有下限，环境只会不断纵容他。 三、硅谷十年。 我见到的不是创新，是体系化、高级化、合法化的摸鱼。 外界看硅谷是极客创新改变世界，我在硅谷混了十年。 看到的却是一套以保职位为核心，以造项目为手段，以堆代码为掩护的完整生态。 国内常见摸鱼，是人在工位，心在别处，是低端摸鱼。 硅谷流行的是高级摸鱼，看上去极度勤奋，实际上全部在无意义造轮子、圈地盘、堆复杂度。 这套体系的逻辑很赤裸，不是因为有项目才招人，而而是为了保住职位，必须造项目。 项目经理手下必须凑够人数，否则级别不保，预算缩水，团队被合并。 高级经理又要靠足够多的项目经理撑地位。 于是所有人都在没事找事，造需求、造功能、造模块、造服务、造 PPT 造故事。 为了让事显得真实，就必须叠床架屋，重复造轮子。 功能高度重叠。 a组做的功能，b组再做一遍。 你做你的模块，我守我的地盘，互不干涉，也互不兼容。 最高级的摸鱼是建立技术自留地。 尽量新建独立文件、独立服务、独立库，不与他人耦合。 把简单功能复杂化，小接口写成微服务，简单逻辑套多层设计模式。 代码写得晦涩绕弯，外人一眼看不懂，想读懂要翻大量无关代码。 在 git svn 设权限钩子，禁止他人修改。 以规范为名拦截一切改动，持续小改小动，反复重构，频繁提交，让活跃度看起来极其饱满。 这种代码的唯一作用。 就是用复杂度保护饭碗。 外人看他天天迭代，产出旺盛，技术深入。 实际上，他在无意义堆代码，用工作量伪装价值，用门槛阻挡替代。 从程序员到经理，全员心照不宣，一起把系统做臃肿、做冗余、做脆弱。 外面是科技神话，里面是层层自保，无效内耗。 形式主义泛滥。 四、从 RTFC 到 English Programmer 再到分维编程，一代比一代更远代码。 老派程序员的信仰是 RTFC。 Read the fucking code 代码即真理，注释多余，文档次要，看不懂代码就不配改代码。 后来出现了 English Programmer。 只看注释，不读代码，信人话，不信逻辑。 再到 AI 时代，连注释都不用看了，AI 代写，复制粘贴都嫌累，只需要维持编程氛围。 三代程序员的变迁是一条清晰的远离代码之路。 第一代，敬畏代码、相信代码、死磕代码。 第二代，依赖注释。 逃避代码，用注释掩护摸鱼。 第三代，抛弃代码，信任 AI 连动手都觉得消耗。 我当年嘲笑只看注释的同事，觉得他丢掉了程序员的底线。 如今我连代码运行都懒得点，活成了当年最看不起的样子，甚至更彻底。 我不是堕落，我只是顺从了人性，也顺从了时代。 五， AI 来了，所有靠伪装工作量活着的人都将被清场。 在人力稀缺、监控粗糙、信息壁垒高的年代。 注视摸鱼、复杂度摸鱼、造项目摸鱼，可以长期生存。 公司愿意养闲人、养团队、养冗鱼，只要能防止人才流向对手。 但 AI 彻底击穿了这套游戏规则。 AI 不写冗余注释，不刷无效提交，不搞自留地，不堆无意义复杂度，不写废话文档。 不演勤奋戏码。 你给他真实意图，他给你干净直接能跑的代码。 AI不认工作量，只认解决问题。 不认注释长度，只认逻辑正确性。 不认团队人头，只认产出效率。 于是只会看注释的 English Programmer 会被替代。 靠刷注释、刷文档混日子的会被替代，靠堆复杂度、圈地盘、保职位的会被替代，连复制粘贴都懒得做的氛围编程选手会被替代。 以前的职场，演的像比做的好更重要。 未来的规则，做的好，一切演戏都无效。 尾声，我活成了当年嘲笑的样子。 也看懂了整个行业的宿命。 十几年前，我嘲笑那位英语程序员，觉得他软弱、外行，丢掉了程序员的尊严。 十几年后，我连代码运行都懒得点。 彻底活成了自己最鄙视的模样。 年轻时我相信 RTFM，相信代码即真理，相信勤奋与硬核能走到底。 后来我才明白，人性从来都是好逸恶劳，职场从来都是趋利避害，技术只是掩护，生存才是本质。 注释泛滥不是规范，是摸鱼。 功能膨胀不是创新，是自保。 提交频繁不是勤奋，是对抗监控。 分维编程不是进化，是懒惰到底。 从 rtf c 到 english programmer 到 cv。 到 vip 编码，我们一代比一代远离代码，一代比一代依赖人话语工具，一代比一代更会偷懒、更会演戏、更会伪装。 如果再见到当年被我嘲笑的同事，我不会再轻视他。 我会告诉他，你不是弱者，你只是这个行业最早开始向人性投降的人。 而我终于活成了当年最看不起的样子，却终于看懂了程序员这个职业，从骄傲到平庸，从硬核到躺平的全部宿命。
修正脚本
从十几年前嘲笑英语程序员，到今天我活成了当初我最鄙视的样子。 十几年前我还在写代码，年轻气盛，信奉一句程序员圈子里的老话。 Read the fucking code 代码本身就是逻辑，代码就是文档，代码就是最好的注释。 看不懂代码才需要靠注释活着。 那时我暗地里嘲笑过一位同事，给他起了个外号， English Programmer 英语程序员。 我并不清楚他工作的全部细节，但我始终认为。 他看不懂代码真正的逻辑结构与意图，只能依赖注释里的自然语言理解功能。 注释说什么，他信什么。 代码是否藏坑，是否误导。 是否与注释不符，他无力分辨，更不敢深究。 在当年老派程序员的观念里，这种人根本不配修改这段代码，不配坐在这个岗位上。 只会读人话，不会读代码，算什么程序员？我那时坚信自己永远不会变成这样。 十几年后，我不仅变成了他，还比他更彻底、更摆烂。 更远离真正的代码。 一、注释泛滥的真相。 不是规范，是摸鱼，是刷工作量，是对抗监控。 很多人以为注释越来越多，是行业更规范、更专业了。 真正混过职场，尤其在硅谷待过才懂，注释泛滥本质是懒惰与监控对抗出来的畸形产物。 早年真正写核心系统、写底层库的人，比如 Linux 之父 Linus 那句名言，RTFC，态度极其鲜明。 代码能讲清楚的，绝不写注释。 非必要不注释，不做冗余解释。 只有逻辑容易被误解、行为反直觉、坑位明显的地方，才会写一句精简提醒。 在他们眼里，看得懂代码是基本职业尊严，每行都写注释是对阅读者智商的侮辱，满屏废话注释说明作者要么不自信，要么代码写得烂。 可现代职场完全变了味。 尤其远程办公普及后，公司开始用各种手段监控工作量， vpn 在线时长、 Git 提交频率、 PR 行数。 Patch 体积、代码增量、文档产出，一切都被量化、被统计、被拿来当绩效依据。 程序员为了对抗监控，刷出好看的工作量。 找到了最安全、最无风险、最不会出错的方式，疯狂写注释、写文档、写冗余说明。 一行逻辑清晰的代码，非要写三行注释。 一个一眼看懂的函数，非要写一段长篇说明。 一个简单参数，非要补格式、补示例、补历史、补边界。 代码不敢随便改。 改出问题要背锅，注释随便加，加再多都是规范严谨、可维护性、政治绝对正确。 于是注释成了摸鱼的最佳掩护。 没事干就写注释、写文档、润色文案、调整格式，刷 git 提交量。 代码没几行，注释占七成， patch 看起来又大又饱满。 上司一看，这人勤奋、严谨，输出稳定。 只有内行心里清楚，这不是开发，这是文字水字数，是最高级的摸鱼。 English programmer 正是在这种环境里批量诞生的。 注释越来越多，代码越来越被掩盖，新人不再习惯读代码，只会读注释。 注释变成了官方标准答案，代码反而成了附属品。 最后，一群只会读注释，不会读代码，不敢碰代码，改代码只看注释的人占据了大量岗位。 这就是我当年嘲笑的英语程序员。 读得懂人话，读不懂机器语言。 信注释，不信代码。 在老派观念里，这是职业底线的失守。 在现代职场里，这是生存最优解。 二、从 CV 拷贝粘贴到 VC 氛围编程，懒惰没有下限，只有不断进化。 如果说 English Programmer 还需要看注释。 改代码，那 ai 时代的氛围编程 web coding 已经把懒惰推到了当年无法想象的地步。 早年没有 ai 程序员最普遍的偷懒叫 cv 工程师。 Copy paste 复制粘贴，东抄一段，西拼一段，改改参数，能跑就行，是心照不宣的基础摸鱼。 而氛围编程 VC Vibe Coding 是 cv 的终极形态。 打开 ide 挂着 ai 窗口全开，人往椅子上一坐，先把正在深度开发的氛围拉满。 需求丢给 AI 代码 AI 写，报错 AI 解，逻辑 AI 顺，注释 AI 帮你写满。 你只需要偶尔瞟一眼，轻飘飘丢几句指令。 这里不对，再改一版，差不多行了。 我现在已经懒到突破底线，AI把完整代码、运行命令、注意事项全部递到眼前。 我只需要复制、粘贴，点一下运行，三步而已。 我都懒得动，扫一眼结构合理，心里默认能跑，关掉窗口，喝茶发呆。 出门闲逛，代码跑没跑，通不通，有没有坑，完全不重要。 代码是否执行不重要，我在认真工作的氛围到位就赢了。 十几年前的我会认为这种人无可救药。 如今我承认人类的懒惰没有下限，环境只会不断纵容他。 三、硅谷十年。 我见到的不是创新，是体系化、高级化、合法化的摸鱼。 外界看硅谷是极客创新改变世界，我在硅谷混了十年。 看到的却是一套以保职位为核心，以造项目为手段，以堆代码为掩护的完整生态。 国内常见摸鱼，是人在工位，心在别处，是低端摸鱼。 硅谷流行的是高级摸鱼，看上去极度勤奋，实际上全部在无意义造轮子、圈地盘、堆复杂度。 这套体系的逻辑很赤裸，不是因为有项目才招人，而是为了保住职位，必须造项目。 项目经理手下必须凑够人数，否则级别不保，预算缩水，团队被合并。 高级经理又要靠足够多的项目经理撑地位。 于是所有人都在没事找事，造需求、造功能、造模块、造服务、造 PPT 造故事。 为了让事显得真实，就必须叠床架屋，重复造轮子。 功能高度重叠。 A组做的功能，b组再做一遍。 你做你的模块，我守我的地盘，互不干涉，也互不兼容。 最高级的摸鱼是建立技术自留地。 尽量新建独立文件、独立服务、独立库，不与他人耦合。 把简单功能复杂化，小接口写成微服务，简单逻辑套多层设计模式。 代码写得晦涩绕弯，外人一眼看不懂，想读懂要翻大量无关代码。 在 git svn 设权限钩子，禁止他人修改。 以规范为名拦截一切改动，持续小改小动，反复重构，频繁提交，让活跃度看起来极其饱满。 这种代码的唯一作用。 就是用复杂度保护饭碗。 外人看他天天迭代，产出旺盛，技术深入。 实际上，他在无意义堆代码，用工作量伪装价值，用门槛阻挡替代。 从程序员到经理，全员心照不宣，一起把系统做臃肿、做冗余、做脆弱。 外面是科技神话，里面是层层自保，无效内耗。 形式主义泛滥。 四、从 RTFC 到 English Programmer 再到氛围编程，一代比一代更远离代码。 老派程序员的信仰是 RTFC。 Read the fucking code 代码即真理，注释多余，文档次要，看不懂代码就不配改代码。 后来出现了 English Programmer。 只看注释，不读代码，信人话，不信逻辑。 再到 AI 时代，连注释都不用看了，AI 代写，复制粘贴都嫌累，只需要维持编程氛围。 三代程序员的变迁是一条清晰的远离代码之路。 第一代，敬畏代码、相信代码、死磕代码。 第二代，依赖注释。 逃避代码，用注释掩护摸鱼。 第三代，抛弃代码，信任 AI 连动手都觉得消耗。 我当年嘲笑只看注释的同事，觉得他丢掉了程序员的底线。 如今我连代码运行都懒得点，活成了当年最看不起的样子，甚至更彻底。 我不是堕落，我只是顺从了人性，也顺从了时代。 五、 AI 来了，所有靠伪装工作量活着的人都将被清场。 在人力稀缺、监控粗糙、信息壁垒高的年代。 注释摸鱼、复杂度摸鱼、造项目摸鱼，可以长期生存。 公司愿意养闲人、养团队、养冗员，只要能防止人才流向对手。 但 AI 彻底击穿了这套游戏规则。 AI 不写冗余注释，不刷无效提交，不搞自留地，不堆无意义复杂度，不写废话文档。 不演勤奋戏码。 你给他真实意图，他给你干净直接能跑的代码。 AI不认工作量，只认解决问题。 AI不认注释长度，只认逻辑正确性。 AI不认团队人头，只认产出效率。 于是只会看注释的 English Programmer 会被替代。 靠刷注释、刷文档混日子的会被替代，靠堆复杂度、圈地盘、保职位的会被替代，连复制粘贴都懒得做的氛围编程选手会被替代。 以前的职场，演的像比做的好更重要。 未来的规则，做的好，一切演戏都无效。 尾声，我活成了当年嘲笑的样子。 也看懂了整个行业的宿命。 十几年前，我嘲笑那位英语程序员，觉得他软弱、外行，丢掉了程序员的尊严。 十几年后，我连代码运行都懒得点。 彻底活成了自己最鄙视的模样。 年轻时我相信 RTFM，相信代码即真理，相信勤奋与硬核能走到底。 后来我才明白，人性从来都是好逸恶劳，职场从来都是趋利避害，技术只是掩护，生存才是本质。 注释泛滥不是规范，是摸鱼。 功能膨胀不是创新，是自保。 提交频繁不是勤奋，是对抗监控。 氛围编程不是进化，是懒惰到底。 从 rtf c 到 english programmer 到 cv。 到 VC 编码，我们一代比一代远离代码，一代比一代依赖人类话语工具，一代比一代更会偷懒、更会演戏、更会伪装。 如果再见到当年被我嘲笑的同事，我不会再轻视他。 我会告诉他，你不是弱者，你只是这个行业最早开始向人性投降的人。 而我终于活成了当年最看不起的样子，却终于看懂了程序员这个职业，从骄傲到平庸，从硬核到躺平的全部宿命。
英文翻译
From mocking "English Programmers" a dozen years ago, today I have become the very thing I once despised. A dozen years ago, I was still writing code, young and cocky, believing in an old saying from the programmer community: "Read the fucking code." The code itself is the logic, the code is the documentation, the code is the best comment. Only those who can't read the code need to rely on comments. At that time, I secretly mocked a colleague, giving him the nickname "English Programmer." I didn't know all the details of his work, but I always believed he couldn't understand the true logical structure and intent of the code, relying only on natural language in comments to grasp functionality. He believed whatever the comments said. He couldn't tell if the code had hidden pitfalls or misleading logic, or if it contradicted the comments. He lacked the ability to distinguish and didn't dare to dig deeper. In the mindset of old-school programmers back then, such a person didn't deserve to modify that code or hold that position. Only reading human language, not code—what kind of programmer is that? I firmly believed I would never become like him. A dozen years later, I have not only become him, but I've gone even further: more resigned, more detached from the true code. **1. The Truth Behind Comment Proliferation** It's not about standards; it's about slacking off, padding workload, and evading monitoring. Many people think more comments mean the industry is more standardized and professional. But anyone who's really worked in the corporate world, especially in Silicon Valley, knows that comment proliferation is a deformed product of laziness and resistance to monitoring. In the early days, people who wrote core systems and underlying libraries—like Linux founder Linus with his famous motto "RTFC"—had a clear attitude: if the code can explain itself, never write a comment. No unnecessary comments, no redundant explanations. Only where logic is easily misunderstood, behavior is counterintuitive, or pitfalls are obvious, would they write a concise reminder. In their eyes, understanding code is basic professional dignity. Adding comments to every line is an insult to the reader's intelligence. A screen full of verbose comments indicates the author is either insecure or writes lousy code. But the modern workplace has completely changed. Especially after remote work became common, companies began using various methods to monitor workload: VPN online hours, Git commit frequency, PR line count, patch volume, code increments, documentation output—everything is quantified, counted, and used as performance metrics. To counter this monitoring and show impressive workloads, programmers found the safest, most risk-free way: frantically writing comments, documentation, and redundant explanations. A line of clear logic must be accompanied by three lines of comments. A function that's obvious at a glance must have a long explanation. A simple parameter must have format, examples, history, and edge cases added. Code cannot be changed casually—if it breaks, you take the blame. But comments can be added freely—the more, the better, seen as standardized, maintainable, and politically correct. Thus comments became the perfect cover for slacking off. When there's nothing to do, write comments, documentation, polish wording, adjust formatting, boost Git commit counts. Few lines of code, 70% comments—the patch looks big and robust. The boss sees it as diligent, rigorous, stable output. But insiders know this isn't development; it's padding word count, the highest form of slacking. It is in this environment that "English Programmers" are mass-produced. Comments grow, code gets buried. Newcomers no longer read code; they only read comments. Comments become the official answer, code becomes an accessory. Eventually, a large number of people who can only read comments, not code, who fear touching code, and who modify code solely based on comments, fill many positions. These are the English Programmers I once mocked—able to read human language but not machine language, trusting comments over code. In the old-school view, this is a failure of professional integrity. In the modern workplace, it is the optimal survival strategy. **2. From CV (Copy-Paste) to VC (Vibe Coding): Laziness Has No Lower Limit, Only Continuous Evolution** If English Programmers still needed to read comments and modify code, then AI-era Vibe Coding has pushed laziness to unimaginable extremes. In the early days without AI, the most common lazy practice among programmers was "CV Engineer"—copy-pasting from here and there, stitching pieces together, adjusting parameters, making it run. That was the unspoken baseline of slacking. Vibe Coding is the ultimate form of CV: open the IDE with AI windows fully open, sit down, first set the atmosphere of deep development. Throw requirements to the AI, AI writes the code, AI fixes errors, AI smooths logic, AI fills in comments. You only need to glance occasionally and throw out a few light commands: "This isn't right, change it again," "That's probably fine." Now I've become so lazy I've broken all limits. The AI presents complete code, run commands, and caveats right in front of me. I just need to copy, paste, and click run—three steps. But I can't even be bothered. I glance at the structure, think it'll probably run, close the window, sip tea, zone out. Go out for a walk. Whether the code runs, whether it has bugs, doesn't matter at all. Whether the code executes is unimportant—as long as I maintain the vibe of working hard, I win. The me from a dozen years ago would have considered such a person hopeless. Now I admit human laziness has no lower limit, and the environment only keeps indulging it. **3. A Decade in Silicon Valley: What I Saw Was Not Innovation, But Institutionalized, High-Level, Legalized Slacking** The outside world sees Silicon Valley as geeks innovating to change the world. I spent ten years in Silicon Valley, but what I saw was a complete ecosystem centered on job security, using creating projects as a means, and padding code as cover. Domestic slacking is often low-level—body at the desk, mind elsewhere. Silicon Valley's popular slacking is high-level: it looks extremely hardworking, but in reality it's all about meaningless wheel-reinventing, turf-building, and complexity-piling. The logic of this system is blunt: hire not because there's a project, but to keep positions, you must create projects. Project managers must have enough subordinates under them, otherwise their level drops, budgets shrink, teams get merged. Senior managers need enough project managers to support their status. So everyone invents work: creating requirements, features, modules, services, PPTs, stories. To make things look real, they must build layers upon layers, reinvent the wheel. Functions heavily overlap: Group A's feature, Group B redoes it. You do your module, I guard my turf—no interference, no compatibility. The highest form of slacking is establishing a technical fiefdom: try to create new independent files, services, libraries, avoid coupling with others. Complicate simple functions—write small interfaces as microservices, simple logic with multiple design patterns. Write convoluted code that outsiders can't understand at a glance; to read it, you must wade through tons of irrelevant code. Set permission hooks in Git/SVN to prevent others from modifying. Use the name of standards to block any changes. Continuously make small changes, refactor, commit frequently—make activity look extremely full. The only purpose of such code is to protect the job with complexity. Outsiders see him iterating daily with high output and deep technical knowledge. In reality, he piles meaningless code, uses workload to fake value, and uses barriers to prevent replacement. From programmers to managers, everyone tacitly cooperates to bloat the system, make it redundant and fragile. Outside it's a tech myth; inside it's layers of self-protection, ineffective internal friction, rampant formalism. **4. From RTFC to English Programmer to Vibe Coding: Each Generation Moves Further from the Code** The old-school programmer's creed is RTFC: Read the fucking code—code is truth, comments are superfluous, documentation is secondary, if you can't read the code you don't deserve to modify it. Then came English Programmers: only read comments, not code; trust human words, not logic. Then the AI era: not even comments needed; AI writes, copy-pasting is too tiring; just maintain the vibe. The evolution of three generations of programmers is a clear path of moving away from code. First generation: reveres code, trusts code, wrestles with code. Second generation: relies on comments, avoids code, uses comments to cover slacking. Third generation: abandons code, trusts AI, even manual effort feels wasteful. I once mocked the colleague who only read comments, thinking he lost the programmer's bottom line. Now I can't even bother to click to run the code; I've become the very thing I once scorned, even more thoroughly. I'm not degenerating; I'm just yielding to human nature and the times. **5. AI Has Arrived: Everyone Who Lives by Faking Workload Will Be Swept Away** In the era of scarce labor, crude monitoring, and high information barriers, slacking through comments, complexity, and project creation could survive long-term. Companies were willing to keep idle people, teams, and redundancies as long as it prevented talent from going to competitors. But AI has completely shattered this game. AI doesn't write redundant comments, doesn't push useless commits, doesn't create fiefdoms, doesn't pile meaningless complexity, doesn't write verbose documentation, doesn't perform diligence dramas. Give it the real intent, and it gives you clean, directly runnable code. AI doesn't care about workload; it only cares about solving problems. AI doesn't care about comment length; it only cares about logical correctness. AI doesn't care about team headcount; it only cares about output efficiency. So English Programmers who only read comments will be replaced. Those who coast by padding comments and docs will be replaced. Those who rely on complexity-piling and turf-guarding to protect positions will be replaced. Even Vibe Coding practitioners who can't be bothered to copy-paste will be replaced. In the old workplace, looking busy was more important than doing real work. In the future, doing real work renders all acting useless. **Epilogue: I Have Become the Thing I Once Mocked, and I Have Also Understood the Industry's Fate** A dozen years ago, I mocked that English Programmer, thinking him weak, unprofessional, abandoning the dignity of a programmer. A dozen years later, I can't even bother to click to run code—I've fully become the version I most despised. When young, I believed in RTFM, in code as truth, in hard work and hardcore skills leading the way. Later I realized: human nature is always lazy and pleasure-seeking; the workplace is always about seeking advantage and avoiding harm; technology is just cover, survival is the essence. Comment proliferation isn't standardization—it's slacking. Feature bloat isn't innovation—it's self-preservation. Frequent commits aren't diligence—it's monitoring evasion. Vibe coding isn't evolution—it's ultimate laziness. From RTFC to English Programmer to CV to Vibe Coding, each generation moves further from code, more dependent on human-language tools, better at slacking, acting, and faking. If I ever meet again that colleague I once mocked, I won't look down on him. I'll tell him: you're not weak—you were just the first in this industry to surrender to human nature. And I have finally become the thing I once despised, yet finally understood the full fate of this profession: from pride to mediocrity, from hardcore to lying flat.
back to top