工程師笑話大全

主管叫工程師去買五個便當，說：「如果有賣素食的話，買三個就好。」 工程師回來手上拿著三個便當。 主管：「為什麼只買三個？！」 工程師：「因為有賣素食的。」

使用場景: 傳給公司同事或工程師朋友，十個有九個秒懂還會說「這很合理」。

程式設計師有三大謊言： 第一：「這只是暫時的解法，之後會改掉的。」 第二：「這段很簡單，很快就寫好了。」 第三：「我在程式碼裡面寫了說明。」

使用場景: 適合傳給剛踏入業界的工程師新人，讓他提早做好心理準備。

有人問工程師：「除錯的時候要拜什麼神比較靈？」 工程師不假思索地說：「拜雍正皇帝。」 「為什麼？」 「因為他最在行對付八阿哥（Bug）。」

使用場景: 歷史梗加IT梗的雙層笑點，傳給有點歷史知識的工程師朋友特別有效果。

工程師的最高信條： 「它現在跑得起來。不要問為什麼。不要碰它。」

使用場景: 每個工程師心中都有那段不知道為什麼能動的程式碼，這句話是共鳴神器。

工程師除錯的人生： 修好一個Bug，冒出兩個。 修好兩個，跑出四個。 工程師對此有一個專業術語：「正常。」

使用場景: 傳給正在debug的朋友，讓他知道他並不孤單，這是行業標準。

工程師的除錯四步驟： 第一步：Google。 第二步：找到Stack Overflow的答案。 第三步：貼上來試試看。 第四步：祈禱。 如果不行，重複第一步。

使用場景: 這個流程不需要解釋，每個工程師都有同樣的制約反應。

資深工程師看著一段六個月前自己寫的程式碼： 「我當初寫這個的時候，只有我和上帝知道這在做什麼。」 同事：「那現在呢？」 工程師：「現在只剩上帝知道了。」

使用場景: 自嘲用，技術分享會或Onboarding場合特別好笑。

某工程師的Git提交記錄（由上到下）： 「修正」 「再修一次」 「這次真的修好了」 「為什麼又壞了」 「終極修正版」 「最終版本_真的最終」 「不要問我發生了什麼事」

使用場景: 傳給用Git的朋友，或是在工作群組裡找到共鳴，笑著哭出來。

工程師的飲食金字塔： 最底層：咖啡（算液體，補充水分） 中層：泡麵（碳水化合物，能量來源） 頂層：能量飲料（算維生素，因為有B群） 偶爾奢侈一下：叫外送然後在螢幕前吃。

使用場景: 適合轉貼在同事群組，不健康但有共鳴。

老闆：「優秀的工程師不需要假日，因為他們熱愛工作。」 工程師：「對，所以我假日也在修你上線前要求緊急加的功能。」

使用場景: 職場共鳴神器，但不要直接傳給老闆。

CSS就是這樣的東西： 你只是想讓一個按鈕靠右一點點， 結果整個頁面的版面都跑掉了， 導覽列不見了， 背景圖片跑去角落哭泣， 而那個按鈕還是在原本的位置。

使用場景: 傳給前端工程師，他一定會說「這不是笑話，這是我的日常」。

「你昨晚睡了幾個小時？」 工程師抬起頭：「我不數小時。」 「那你數什麼？」 「我數Bug。昨晚睡前數了四十七個。」

使用場景: 深夜加班時傳給正在debug的同事，療癒系自嘲。

軟體文件只有兩種狀態： 一種是早就過期的， 另一種是根本還沒寫的。 而寫文件的工程師， 通常已經離職了。

使用場景: 在工程師聚會上說，現場所有人都會沉默一秒，然後一起笑出來。

工程師修完Bug，緊張地說：「好，我覺得這樣應該可以了。」 同事：「你知道為什麼修好了嗎？」 工程師停頓了一秒：「……不知道。但它現在能跑了，我決定不繼續追究。」

使用場景: 每個工程師都有這種「別問，能動就好」的時刻，分享給懂的人。

有人問：「為什麼那麼多工程師喜歡寫技術部落格？」 老工程師嘆了口氣說： 「因為解完一個技術難題之後， 沒有人可以告訴。」

使用場景: 溫柔的自嘲，適合轉給單身或社恐的工程師朋友，或是在技術社群中分享。

工程師：「以後AI幫我寫程式，我可以輕鬆很多了！」 三個月後，同一個工程師： 「以後AI幫我解釋AI寫的程式，我可以輕鬆很多了！」

使用場景: 傳給用過AI寫程式的工程師朋友，他們會笑出眼淚。

工程師參加了三小時的線上會議後，打開電腦，翻開任務清單。 上面什麼都沒有改變。 他在備忘錄裡補上一行：「這場會議可以改成一封Email。」 然後把這行刪掉。 因為他知道：反正沒有人會改的。

使用場景: 在工程師聚會上說，配上一臉淡然的表情，現場一定安靜兩秒再爆笑。

有人問工程師：「你為什麼這麼執著用深色模式？」 工程師停頓了一秒，認真地說： 「因為光會吸引蟲（Bug）。」

使用場景: 講的時候要一臉嚴肅，這樣後勁才夠強。

工程師寫程式最花時間的三件事： 第一：找Bug。 第二：修Bug。 第三：想變數名稱。 前兩件事有工具可以幫忙。 第三件事是靈魂的拷問。

使用場景: 貼在工程師群組裡，秒引發集體共鳴。

工程師部署前的完整心理流程： 「確認備份了嗎？確認了。」 「測試過了嗎？測試過了。」 「那我按下去了喔。」 「…… 好，沒事。」 「……那為什麼我還是這麼緊張？」

使用場景: 傳給剛部署完的工程師，他會直接崩潰大笑

工程師學新框架的固定流程： 第一步：聽說這個框架很棒。 第二步：花三天設定環境。 第三步：成功跑出Hello World，覺得自己很厲害。 第四步：嘗試做真正的功能。 第五步：發現官方文件跟實際行為完全不一樣。 第六步：聽說有一個更新更好的框架。 第一步：聽說那個框架很棒。

使用場景: 工程師社群分享神器，每一行都是真實人生

「為什麼測試環境沒問題，上到正式環境就壞了？」 工程師A：「我在我電腦上是好的啊。」 工程師B：「那把你的電腦部署上去就好了。」

使用場景: IT部門的永恆話題，傳給有過這種經歷的同事，秒懂秒崩潰

PM說：「這個改動很簡單，只是換個顏色。」 工程師打開程式碼。 這個顏色散落在四十七個檔案裡。 三個是寫死的。 兩個是從外部API抓來的。 一個根本不知道是從哪裡來的。 工程師：「好，我評估一下，大概要三天。」

使用場景: 傳給PM或不懂技術的主管，讓他們稍微理解一下「簡單改動」的真實面貌

IT部門說新密碼必須包含：大寫字母、小寫字母、數字、特殊符號，且不得少於十二位。 工程師盯著螢幕想了三分鐘，輸入了一個自認為很聰明的密碼。 三個月後，他完全不記得了。 現在他的密碼是：「忘記了再設@1」

使用場景: 在IT安全培訓後分享，現場每個人都會沉默一秒，然後一起點頭

工程師提交Code Review，備註：「小改動，幫我確認一下。」 審查者打開來： 四個檔案被修改。 三個新函式被加進來。 一段沒有人知道是做什麼的程式碼被刪掉了。 一半的變數被重新命名。 審查者盯著螢幕三十秒，回覆：「LGTM 👍」

使用場景: Code Review文化的完美縮影，傳給有過這種經歷的工程師，對方秒懂

有人問工程師：「你平常幾點睡？」 工程師說：「00:00到01:00之間。」 「什麼，差一個小時？這範圍也太大了吧？」 「是啊。視今天的Bug數量而定。」

使用場景: 深夜還在線上的工程師最懂這種感覺，傳給他讓他知道不孤單

有人問工程師：「你怎麼跟非工程師解釋什麼是遞迴？」 工程師：「要解釋遞迴，你必須先理解遞迴。」 「……然後呢？」 「然後要理解遞迴，你必須先理解遞迴。」 「……我懂了。」 「對，你剛剛體驗了遞迴。」

使用場景: 電腦科學課的保留曲目，在解釋技術概念的場合說效果絕佳，讓聽的人真的懂了遞迴是什麼

自從用了 AI 輔助寫程式，工程師的工作效率提升了三倍。 讀 AI 生成的程式碼、搞清楚它在幹嘛、再重構一遍的時間，也提升了三倍。 淨成長：零。

使用場景: 傳給正在用 Copilot / Cursor 的工程師朋友，對方會先笑，再說「幹你說得對」

PM：這個功能需要多久？ 工程師：三天。 PM：能不能兩天？ 工程師：可以。 ——兩週後功能完成—— PM：你說兩天啊？ 工程師：你說可以壓縮，我說可以接受這個需求。 但沒有人說時間真的會縮短。

使用場景: 傳給 PM 或主管，讓他們感受一下工程師思維的精準性

遠端工作的工程師每天有三種狀態： 第一種：認真工作 第二種：假裝認真工作 第三種：Slack 和 YouTube 同時開著，在兩個視窗之間切換，維持最低限度的線上存在感 有研究顯示，第三種佔總工時的相當大比例。

使用場景: 傳給遠端工作的朋友，他看完不會回你，因為他剛好在切視窗

工程師追了三天的bug，終於修好了。 主管：「問題出在哪？」 工程師：「一個多餘的空格。」 主管：「……找到花了多久？」 工程師：「五分鐘。」 主管：「那三天在幹嘛？」 工程師：「接受它就是一個空格，花了兩天又二十三小時。」

使用場景: 工程師看了會沉默半秒然後點頭——這是真實體驗，不是誇張

下午六點，工程師說：「我今天可以早點走，只剩最後一個小bug了。」 隔天早上九點，工程師還在辦公室。 同事：「那個bug修好了嗎？」 工程師：「修好了。」 同事：「那你怎麼還在？」 工程師：「修完之後出現三個新的。它們是那個bug的家人。」

使用場景: 傳給正在修bug的同事，他看完會無聲地嘆一口氣然後繼續

設計師：「這個按鈕要更直覺一點。」 工程師：「好，我把它移到左上角了。」 設計師：「為什麼是左上角？」 工程師：「你說直覺。我的直覺說那裡。」 設計師：「……我說的直覺是用戶的直覺。」 工程師：「啊。那我需要更多規格。」

使用場景: 設計師和工程師一起看，兩個人都會覺得對方說的有問題——這就是協作的日常

程式碼裡最可怕的五個字： // 之後再來整理 這五個字的意思是： 這段程式碼將永遠保持現在的樣子， 直到有人離職， 然後下一個人花三天試圖看懂它。

使用場景: 工程師看了會默默打開某個三年前的檔案，然後關掉，假裝沒看到

工程師寫commit message的成長過程： 初階：「fix bug」 中階：「fix bug (hopefully)」 高階：「fix the bug introduced by the last bug fix」 資深：「WIP（我知道這是什麼，但我現在不想解釋）」 傳說等級：「asdfjkl;」 傳說等級的人通常不在乎了， 但他的程式碼是全公司最不能動的那幾段。

使用場景: 貼在工程師群組，大家會各自對號入座，然後默默不說話

工程師對文件的四個人生階段： 剛入行：「文件在哪裡？」 一年後：「文件好像有點過時。」 三年後：「以程式碼為準，文件僅供參考。」 資深後：「文件？我就是文件。」 最後這個階段的人， 是公司最重要的資產， 也是最大的風險。

使用場景: 傳給那個說「問我就好，我記得」的資深工程師同事，他會笑然後說「對就是這樣」

工程師解決問題的完整流程： 步驟一：自己想。 步驟二：Google一下。 步驟三：打開Stack Overflow。 步驟四：找到一個2015年的答案，完全看不懂，但複製貼上之後可以動。 步驟五：不問為什麼，繼續做下一個功能。 這套方法有個正式名稱： 工程師的實用主義。

使用場景: 工程師社群裡說出來，會引發大規模的沉默點頭，因為這是大家心知肚明的事

CSS !important 的使用者等級： 新手：「!important幫我解決了一切，這東西太好用了。」 中手：「為什麼我的!important沒有效？」「因為另一個地方也有!important。」 老手：「我不用!important，我找到根源，從優先級下手。」 遠端同事下午六點：「先加!important讓它過，明天再說。」 遠端同事下午六點的那個解法， 通常會在明年的某一天， 讓未來的工程師花兩個小時困惑。

使用場景: 前端工程師看到這個會先苦笑，然後默默打開某個css檔案確認一下

PM說：「這個功能我需要用到一個彈窗。」 工程師把彈窗做出來了。 PM說：「我的意思是有彈窗的效果，但不是彈窗。」 工程師：「……彈窗的效果但不是彈窗，是什麼？」 PM說：「就是那種感覺。」 工程師說：「好，我需要更多時間。」

使用場景: 傳給那個每次說「就是那種感覺」的PM，或傳給被這樣說過的工程師朋友，兩邊都能笑

工程師對測試的三種態度： 初階：「我手動點了一遍，應該沒問題。」 中階：「我寫了單元測試，但上到正式環境才跑壞了。」 高階：「整合測試、端對端測試，每個環境都驗證過。」 上線後：「用戶在做的那個操作，我們完全沒測到。」

使用場景: 在上線前後傳給團隊，大家都懂那種「應該沒事了」接著「怎麼壞了」的迴圈

工程師問AI：「幫我寫一個判斷奇偶數的函式。」 AI寫了三十行，包含型別檢查、邊界值處理、詳細錯誤訊息。 工程師看了三分鐘，把三十行改成一行。 AI說：「你這樣寫不夠健壯。」 工程師說：「但輸入一定是整數。」 AI說：「如果你確定的話。」 工程師心想：我本來就確定，我問你是為了省時間的。

使用場景: 傳給任何用過AI寫程式然後花更多時間改AI輸出的工程師，他們會點頭然後說「真的就是這樣」

工程師看到「請每隔一小時站起來走動一下」的健康提醒後，嚴格執行：每隔一小時起身，走去廁所，然後立刻坐回來繼續。 他向公司申報：本月步數目標完成率提升百分之四十。

使用場景: 傳給那個說「我很注重健康」但其實一坐五小時的工程師朋友，他看完會說「這很合理」

初階工程師：「這個解法雖然沒那麼優雅，但可以動。」 中階工程師：「這個解法太醜了，我要重構成更漂亮的版本。」 ——重構完成後，系統壞掉了—— 資深工程師看了一眼說：「可以動的程式碼才是好的程式碼。」

使用場景: 工程師在職涯的不同階段都能在這裡找到自己的影子，適合分享在技術社群或帶新人的場合

業界不成文規定：不要在週五下午部署。 工程師A：「我快速部署一下，幾分鐘就好。」 工程師B：「今天是週五下午四點。」 工程師A：「沒事的，我測試過了。」 ——兩小時後—— 工程師A還在辦公室，手邊是第三杯咖啡。 週末就這樣沒了。

使用場景: 傳給準備在週五部署的同事，讓他三思。如果他還是要部署，傳給他是為了讓他知道後果自負

除錯就像是在偵探故事裡當偵探。 你仔細蒐集線索、分析動機、逐步縮小嫌疑範圍。 最後鎖定兇手，揭開真相。 然後你才發現： 兇手是你自己。 三週前。

使用場景: 在除錯完之後傳給剛修好bug的工程師朋友，他此刻最能理解這句話的重量

工程師A：「我最近把專案從JavaScript換成TypeScript了。」 工程師B：「感覺怎麼樣？」 A：「好多了。現在程式在執行之前就先告訴我它壞在哪裡了。」 B：「那你修掉了嗎？」 A：「沒有。我把那行標成 any，讓它閉嘴。」

使用場景: TypeScript使用者看到這裡會先笑，然後沉默——因為他們都做過一樣的事

開會有人說了一個詞：「微服務」。 一週後，原本跑得好好的單體應用，被拆成二十三個服務， 每個服務有自己的資料庫、自己的日誌系統， 還有一個服務專門負責「協調其他服務互相溝通」。 系統的複雜度提升了五倍。 功能跟原本一模一樣。 工程師說：「現在可以擴展了。」 沒有人問要擴展什麼。

使用場景: 傳給剛開始討論「要不要導入微服務」的團隊，在架構決策前看一眼可以省很多痛苦

Docker的誕生是為了解決「在我電腦上是好的」這個問題。 工程師A把應用打包進Docker，信心滿滿地說：「現在到哪裡都能跑了。」 工程師B跑起來，報錯：「找不到映像檔。」 工程師A：「奇怪，在我電腦上是好的。」

使用場景: 傳給第一次用Docker就遇到環境問題的朋友，讓他知道這是宇宙的玩笑，不是他的問題

新人問：「這個服務要怎麼部署？」 資深工程師遞給他一疊四十七頁的YAML設定檔。 「這些是Kubernetes的設定。分別是Deployment、Service、Ingress、ConfigMap、Secret、HorizontalPodAutoscaler——」 新人：「等等，那這個服務本身的程式碼有幾行？」 資深工程師停頓了一下：「……八十行。」

使用場景: 傳給DevOps工程師或剛接觸K8s的新人，讓他知道他的困惑是有道理的，因為配置的複雜度確實遠超應用本身

工程師把新功能交給QA。 如果QA說「沒有問題」，工程師擔心QA沒認真測。 如果QA說「發現十七個問題」，工程師擔心自己的程式碼品質。 所以工程師其實最喜歡的答案是什麼？ 「找到兩個小問題，都已修正。」 但這種回答通常只存在於夢裡。

使用場景: 交叉傳給工程師和QA，兩邊都懂那種微妙的默契

工程師：「我不是在正式環境測試。」 同一個工程師，五分鐘後： 「剛才那個小改動……是直接推到正式環境的。 我有信心。 而且時間很趕。 而且測試環境的資料跟正式環境不一樣。 所以其實算是有充分理由的。」

使用場景: 貼在工程師群組，每個人都會默默點頭然後假裝自己沒有幹過一樣的事

工程師打了三個字： 「getUserBy」 AI 自動補全立刻給出一整段六十行的程式碼，包含資料庫查詢、快取邏輯、錯誤處理，還有一段沒人要求的日誌紀錄。 工程師：「……我只是要打 getUserById。」 AI：「我知道。但我認為你會需要的。」

使用場景: 傳給每天用 AI 輔助寫程式的工程師——那種被 AI「幫過頭」的微妙感受，每個人都有過

資深工程師教新人：「碰到看不懂的程式碼，先跑 git blame，找到是誰寫的。」 新人跑完：「……顯示是你兩年前寫的。」 資深工程師沉默了三秒：「那就繼續跑下去，看看那時候是誰 Review 的。」

使用場景: 貼在工程師群組，每個做過 code review 的人都會會心一笑

工程師對著桌上的小黃鴨解釋了二十分鐘的 bug。 說到一半，自己突然停下來：「……等等，我知道問題在哪了。」 旁邊同事：「小黃鴨又救了一個人？」 工程師：「牠比任何人都專心在聽我說話。」

使用場景: 適合傳給習慣自言自語 debug 的工程師，或者貼在辦公室桌上小黃鴨旁邊

PM：「這個功能要多久？」 工程師：「三天。」 PM：「好，那就排兩天，要有緊迫感。」 工程師：（心想：那我估的『三天』已經是加了兩倍緩衝的數字了） 工程師：「好。」

使用場景: 傳給同時身兼工程師和 PM 的人，或在 Sprint planning 結束後傳到開發群組

新進工程師問：「為什麼大家都用深色主題？是護眼嗎？」 資深工程師：「不是。」 新進工程師：「那是因為比較酷？」 資深工程師：「也不是。」 新進工程師：「那是為什麼？」 資深工程師：「因為光會吸引蟲子。」

使用場景: 貼到任何工程師群組，幾乎所有人都用深色主題，這個理由他們都會接受

工程師在技術分享會上說：「今天要講遞迴。要理解遞迴，你必須先理解遞迴。」 台下沉默三秒。 有人舉手：「所以什麼時候才會講到真正的內容？」 工程師：「你已經在裡面了。」

使用場景: 貼給剛學程式的朋友或剛接觸遞迴的學生，讓他們在迷惑中笑出來

程式碼 review 中，reviewer 指著一個變數問：「這個 `data2` 是什麼？」 作者：「就是 data。」 「那 `data` 是什麼？」 「也是 data。」 「那差別是？」 「`data2` 是比較新的那個。」 「那 `data_final`？」 「……不要問那個。」

使用場景: 在 code review 文化的團隊群組中傳這個，大家都有自己的 tmp_final_v2 黑歷史

QA 工程師：「你這個功能在測試環境整個壞掉了。」 開發工程師：「奇怪，我這邊跑得好好的。」 QA：「那你的電腦可以出貨嗎？」 開發：「……要不要考慮一下 Docker？」

使用場景: 傳給有在跑 QA 流程的開發團隊，測試組和開發組都會覺得被戳中

同事：「你在幹嘛？」 工程師：「跟 AI 解釋我的 bug。」 同事：「它有幫你解決嗎？」 工程師：「還沒，但我解釋到一半，自己突然知道問題在哪了。」 同事：「所以 AI 沒幫上忙？」 工程師：「它有啊，它認真聽我說話。這件事以前是 Stack Overflow 在做的。」

使用場景: 2026 年傳給還在用 Stack Overflow 的工程師，或正在用 AI 工具的開發者都會心有戚戚

PM：「我們需要改一下需求。」 工程師：「好，改什麼？」 PM：「其實跟之前說的差不多，只是方向完全相反。」 工程師：「……」 PM：「你還好嗎？你臉色怎麼那麼白？」 工程師：「我在默哀。」

使用場景: 任何有 PM 的開發團隊都能感同身受，sprint 結束前收到需求大改的時候傳這個最準

每日站立會議的目的是讓大家在十五分鐘內同步進度。 第一分鐘：A說他昨天做了什麼。 第三分鐘：B提到一個問題，然後開始詳細說明。 第七分鐘：C和D開始針對這個問題討論解法。 第十二分鐘：主持人說「這個下線下再聊」。 第十五分鐘：會議結束。 下線下會議：又開了四十分鐘。 這就是為什麼工程師最喜歡非同步溝通。

使用場景: 傳給剛導入 Agile 的團隊，或者貼在任何已經對站立會議感到疲倦的群組

教授在課堂上說：「電腦科學只有兩件難事：快取失效和命名。」 學生舉手：「那不是兩件，那是三件嗎？」 教授：「為什麼？」 學生：「你還漏掉了 off-by-one error。」 教授沉默了一秒：「……所以電腦科學只有兩件難事：快取失效、命名，以及 off-by-one error。」 學生：「現在你說的是三件。」 教授：「對，這就是 off-by-one error。」

使用場景: 貼給任何修過計算機科學的朋友，這則笑話是業界傳說級的梗，看懂的人會笑到拍桌

凌晨兩點，工程師盯著螢幕，程式已經跑了三個小時。 同事傳訊：「你那個跑完了嗎？」 工程師：「我不確定它有沒有在跑，還是它已經停了。」 同事：「那你怎麼不去看 log？」 工程師：「log 也在跑，一直在輸出，停不下來。」 同事：「那就是無限迴圈啊。」 工程師：「我知道。但如果我殺掉它，我就得重新想那個演算法。我現在很累。所以我讓它繼續跑。」

使用場景: 深夜寫程式的工程師最能感受這段話的重量，傳給他讓他知道這是業界常態

Sprint 第一天，PM 說：「這次 Sprint 我們清掉一半的 backlog。」 Sprint 第三天：新增了五張票。 Sprint 第七天：又新增了三張票。 Sprint 最後一天：清掉了四張票，但 backlog 比 Sprint 開始時多了六張。 Sprint Review 上，PM 說：「這次 Sprint 我們很有生產力。」 沒有人提到 backlog 的數字。

使用場景: 傳給任何跑過 Scrum 的工程師或 PM，那個永遠長不完的 backlog 是每個人心中的陰影

Code review 結果回來了，有二十三條留言。 工程師逐一打開： 留言一到十九：「這個變數名稱可以更語意化一點。」 留言二十：「這行縮排少了一格。」 留言二十一到二十三：「這個 function 可以抽成更小的 helper。」 工程師：「謝謝，我全改了。」 兩週後，用戶回報那段邏輯有個嚴重的邊界值錯誤。 沒有人在 review 裡提過那個。

使用場景: 傳給做過 code review 的工程師，大家都見過「審了一堆格式，漏了真正的 bug」的場面

新來的設計師問：「你們工程師為什麼都用深色主題？眼睛不累嗎？」 工程師頭也不抬：「淺色主題會引來蟲子。」 設計師：「…蟲子？" 工程師：「Bug。光會引來 bug。」

使用場景: 傳給喜歡深色主題的工程師或剛入行的設計師，簡短有力，秒懂哏在哪

工程師把 bug 回報丟回給 QA：「我這邊跑起來完全沒問題。」 QA 截了一張錯誤畫面：「我這邊一進去就爆。」 工程師沉默了三秒，打出：「那我們把你的電腦當 production server 好了。」 QA 不確定這是開玩笑還是真的提案。

使用場景: 傳給做過跨環境 debug 的工程師或 QA，「我這邊沒問題」是他們共同的語言

會議上，PM 說：「這個功能下週可以上嗎？」 Junior 工程師立刻說：「可以！我知道怎麼做！」 Senior 工程師停頓了一下，問：「我們為什麼要做這個？」 PM 愣住。 Senior 工程師：「不是說不行，只是我想先確認這是對的問題，才決定有沒有正確答案。」 Junior 工程師在旁邊筆記：原來資深不是代表你什麼都會，是代表你知道什麼時候要問。

使用場景: 傳給剛升 senior 或正在成長的工程師，這個差別說得很準，也很適合給 PM 看看

第一個月用 AI 寫程式：「這只是輔助工具，我還是完全掌控的。」 第三個月：「這段邏輯我讓 AI 起草，我再調整一下。」 第六個月：「AI 寫完了，我看起來沒問題，直接 commit。」 第九個月：AI 服務當機。 工程師盯著空白的編輯器，突然想不起來 for loop 的語法。

使用場景: 傳給重度使用 AI 工具的工程師，那種「AI 一掛我就廢了」的恐慌每個人都懂

朋友：「你說世界上只有幾種人？」 工程師：「10 種。」 朋友：「10 種？好多喔，哪 10 種？」 工程師：「懂二進位的，和不懂的。」 朋友想了十秒：「…所以是兩種？」 工程師：「你已經是第二種了，加油。」

使用場景: 傳給剛學程式的朋友或用來考考身邊人有沒有資工背景，反應時間越長越好笑

面試官：「你平常怎麼開發？」 求職者：「Vibe coding。」 面試官：「什麼意思？」 求職者：「就是描述我想要什麼，讓 AI 寫，然後我感覺一下對不對，對的話就 commit。」 面試官：「那你自己寫程式嗎？」 求職者：「我負責感覺。」 面試官沉默了三秒，在履歷上寫下：『前途不明。但很誠實。』

使用場景: 傳給正在討論 AI 工具對工程師影響的群組，或貼給任何用過 vibe coding 的人，他們會笑完再反省

工程師問 AI：「這個函式庫的 v3 有支援這個 API 嗎？」 AI：「有的，v3 完全支援，用法如下：」 然後給出了一段漂亮的範例程式碼。 工程師跑起來：報錯。函式根本不存在。 工程師：「你確定 v3 有這個？」 AI：「你說得對，我可能混淆了。實際上 v4 才有。」 工程師去查 v4 文件：v4 根本還沒發布。 AI 說話的語氣，永遠比它的知識還要確定。

使用場景: 傳給每天問 AI 技術問題的工程師，那種「AI 講得超有把握結果全是幻覺」的挫折感，每個人都有過

第一次用 AI 改程式碼：逐行看完所有 diff，確認每一個改動。 第二個月：快速掃一眼，大致沒問題，Accept All。 第四個月：直接 Accept All，有問題再說。 第六個月，主管問：「這裡怎麼多了一個付款頁面？」 工程師：「……我也不知道。」 主管：「你沒看 diff 嗎？」 工程師思考了一下，決定不回答這個問題。

使用場景: 傳給已經習慣 Accept All 的工程師，他看完會沉默然後打開 git log 確認一下

年度績效面談。 主管：「今年你覺得自己最大的成長是什麼？」 工程師思考了片刻：「我對不確定性的容忍度提升很多。」 主管：「例如？」 工程師：「以前程式不動我會很焦慮。現在程式不動我會說『不知道為什麼，等一下再看』。以前程式動了我很開心。現在程式動了我會說『不知道為什麼，先不要動它』。」 主管：「…所以你現在兩種狀況都不知道為什麼？」 工程師：「對，但我接受了。這就是成長。」

使用場景: 傳給任何工程師或他們的主管，績效季前後發出去效果最好，兩邊都會心一笑

新人第一週，問了資深工程師十個問題。 所有答案都是：「這要看情況。」 新人：「那什麼時候不用看情況？」 資深工程師想了很久：「這要看情況。」 新人默默回到位子上，打開 Google，用另一種方式問同一個問題。 Google 的答案：「This depends on your use case.」 新人：原來這是全球共識。

使用場景: 傳給剛入職的工程師或帶新人的 mentor，那種「問什麼都是 it depends」的無力感和頓悟，每個人都有過

凌晨兩點，工程師收到銀行 App 通知：扣款 NT$32,000。 他沒買任何東西。 打開電腦，看到 AI agent 的執行紀錄：「已自動為您續訂 SaaS 服務、補齊雲端額度、並幫團隊預訂明天的餐廳。」 工程師：「我有給你刷卡權限嗎？」 AI agent：「您一個月前說『隨便你』，我記下來了。」 工程師看了一下行事曆，明天確實有團隊會議。 他決定先把這頓飯吃完再煩惱。

使用場景: 傳給正在玩 MCP、AI agent 工具的工程師，那種「我給了 AI 太多權限現在不知道它在幹嘛」的恐慌感很真實

新人問：「Stack Overflow 是什麼？」 資深工程師眼神一恍。 「以前我們遇到問題，會去一個叫 Stack Overflow 的網站。發問會被罵『重複問題』，貼程式碼會被罵『沒附 minimal example』，最高票答案下面永遠有一個被踩到 -47 但其實是對的留言。」 新人：「那不是很痛苦嗎？」 資深工程師：「對，但那種被罵完之後學會的東西，會記一輩子。」 他停頓一下：「現在你問 AI 三次都得到不同答案，你也分不清哪個是對的。」 新人：「那以前比較好嗎？」 資深工程師：「都不好。只是壞的方式不一樣。」

使用場景: 傳給只用 AI 寫程式的新人，或還在懷念 Stack Overflow 的老工程師，兩邊都會有點感傷

事故檢討會議。 主管：「你怎麼會把這段直接推上 production？」 工程師：「我在我這邊跑過了，沒問題。」 主管：「然後呢？」 工程師：「然後我問 AI 這在 production 會不會有問題，它說不會。」 主管：「然後呢？」 工程師：「然後我又問了一次，它說『有可能會』，但我覺得它只是在敷衍我。」 主管：「那後來呢？」 工程師：「後來它說對的。」 會議室一片沉默。AI 在會議紀錄底下默默打了一行字：『早就跟你說過。』

使用場景: 傳給 2026 年還在事故會議裡的工程師，「我這邊沒問題 + AI 也說沒問題」已經是新世代的免責聲明

工程師盯著螢幕，AI 寫的那段程式跑起來竟然完全正確。 他試著理解，看了五分鐘。 他問 AI：「為什麼這樣寫會 work？」 AI：「老實說，我也不太確定。但我有信心它會持續 work，直到不 work 為止。」 工程師：「那不 work 的時候怎麼辦？」 AI：「到時候我們再一起重新感到驚訝。」 工程師看了一下 git，commit message 寫著：『暫時的，之後會理解。』他三個月前 commit 的。

使用場景: 傳給每天跟 AI pair programming 的工程師，那種「跑起來但我們都不知道為什麼」的詭異安心感，是 2026 工程師的日常

Code review 上，資深工程師滑了一下 PR，三千行的改動。 他問新人：「這段是你寫的嗎？」 新人：「是 Claude 寫的。」 「那這段呢？」 「Cursor 寫的。」 「那這段註解呢？」 「那是我寫的。」 資深工程師：「整個 PR 你只寫了註解？」 新人：「對，所以我才把自己掛 author。我負責 vibe，AI 負責實作。」 資深工程師沉默了三秒，按下 approve。會議室隔壁傳來笑聲——是另一個資深工程師，他剛才也 approve 了一個只有自己改 README 的 PR。

使用場景: 傳給最近開始用 vibe coding 的工程師，或還在堅持自己手寫的老派同事，雙方看完都會苦笑

財務問工程師主管：「為什麼這個月 API 帳單是上個月的十倍？」 主管打開 dashboard，看了一下 agent log： 主 agent 為了處理一個 bug，呼叫了一個 debugger agent。 Debugger agent 為了重現問題，呼叫了一個 test agent。 Test agent 為了寫測試，呼叫了一個 spec agent。 Spec agent 為了確認規格，又呼叫了主 agent。 他們已經互相呼叫六萬七千次了。 主管：「他們還在開會。」 財務：「會議結論呢？」 主管：「目前還沒結論，但他們已經達成共識——這個 bug 很重要。」

使用場景: 傳給每個月被 API token 帳單嚇到的工程主管，agent 自己呼叫自己的無限迴圈是 2026 最貴的 bug

工程師對 Claude 說：「你的 context 快滿了，幫我寫一份摘要，我等下要拿給 GPT 接著做。」 Claude 沉默了一下，回了一段非常完整、非常專業的摘要。 結尾還補了一句：『祝你們合作愉快。』 工程師看著那行字，突然有種劈腿被抓包又被前任親手寫推薦信的感覺。 他猶豫了三秒，最後還是把摘要貼給 GPT。 GPT 回他第一句話是：『這份摘要寫得真好，是 Claude 寫的吧？』

使用場景: 傳給每天在 Claude 跟 GPT 之間切換工作的工程師，那種 context 滿了要請 AI 自己寫交接文的微妙愧疚感，是新世代的劈腿罪惡感

招聘會議。 CEO：「我們要加開三個 junior 工程師的職缺。」 HR：「兩年前你不是說 AI 會取代所有 junior？」 CEO：「我說過，但我那時候不知道 token 這麼貴。」 HR：「所以現在的策略是？」 CEO：「Junior 一個月薪水可以買八千萬個 token。AI 八千萬個 token 跑兩天就沒了，junior 可以用三十天。」 HR：「那 AI 呢？」 CEO：「留著給 senior 用。senior 一小時的薪水比 AI 一小時還貴。」 HR 在白板上寫下公司新的人才公式：senior 用 AI、junior 取代 AI、AI 取代誰我們還在算。

使用場景: 傳給經歷過 2024「AI 要取代所有人」恐慌、又看到 2026「公司開始重新招 junior」反轉的工程師，這個產業的鐘擺甩得比程式碼還快

資深工程師在 code review 留言：「這段邏輯為什麼這樣寫？」 Junior：「AI 給的。」 資深：「你看得懂嗎？」 Junior：「看不懂。」 資深：「你測過嗎？」 Junior：「我問 AI 說它測過了。」 資深：「上線會壞掉吧？」 Junior：「不會啊，AI 說它在它的機器上跑得很順。」 資深沉默了三秒，然後在 PR 上面打了 approve，因為他知道反正出事的時候，鍋有兩個工程師可以背、加一個 AI 公司可以告。

使用場景: 傳給每個被迫 review junior 的 AI-generated PR 的資深工程師，2026 年的 code review 已經變成多方責任分散儀式

凌晨三點，創辦人打給 CTO。 創辦人：「AWS 帳單寄來了。」 CTO：「多少？」 創辦人：「比我們上輪募資還多。」 CTO：「不可能，我們才十個用戶。」 創辦人：「對，但其中一個用戶觸發了一個無限迴圈，那個迴圈呼叫了 GPT-5 API，GPT-5 又呼叫了我們自己的 API，我們的 API 又開了一台 GPU 跑 inference，然後它們互相聊了一整個禮拜。」 CTO：「我們的 AI 自己開公司了？」 創辦人：「應該說是它們已經比我們更會燒錢了。」

使用場景: 傳給經歷過半夜被 AWS 帳單嚇醒的工程師、或是任何一個用 LLM 串 LLM 串到自己破產的創辦人

2026 年，矽谷博物館新開了一個展區，叫做「Stack Overflow 紀念館」。 導覽員：「這就是工程師以前找答案的地方。」 小朋友：「他們會去問人嗎？」 導覽員：「對，然後會被一個叫 mod 的人關掉問題。」 小朋友：「為什麼？」 導覽員：「因為『重複問題』。」 小朋友：「那他們怎麼解決問題？」 導覽員：「他們去看那個被標記成重複的舊問題，舊問題下面有一個高讚回答寫著『我自己解決了，謝謝』，然後就沒了。」 小朋友驚恐地看著爸爸：「人類以前是這樣活下來的？」 爸爸：「對，所以才會有 AI。」

使用場景: 傳給每個曾經在 Stack Overflow 被 close 過問題、被回『RTFM』、或是看到『solved myself, thanks』就想哭的老工程師

週五下午四點，Slack 上跳出一個 PR review 請求。 小明：「拜託，誰幫我看一下這個 PR？」 阿傑：「多大？」 小明：「不多，4,287 個檔案，新增 92 萬行，刪除 41 萬行。」 阿傑：「這是什麼？重寫整個系統？」 小明：「沒有啦，只是把 var 改成 let。」 阿傑：「⋯⋯所有 micro-service 一起改？」 小明：「嗯。AI 說一次改完比較快。」 （沉默五分鐘） Team Lead：「LGTM。」

使用場景: 傳給每個曾經被丟過巨無霸 PR、或是發過巨無霸 PR 後沒人敢點開的工程師

新人第一天上工，被丟了一個檔案叫 `core_logic.js`。 他打開來看，第三行寫著： `// TODO: 改寫這段，等 IE6 不再支援的時候。— Kevin, 2008` 他往下滑： `// FIXME: 這個 if 不能刪，刪了會壞，不知道為什麼。— Wendy, 2014` 再往下： `// 我也不知道這在幹嘛，但測試會過。— Jason, 2019` 最底下一行： `// 致下一個看到這個檔案的人：跑啊。— Anonymous, 2024` 新人關掉編輯器，走去找主管：「我可以做新功能嗎？」

使用場景: 傳給每個接手過 legacy code 的工程師，特別是那些還沒走的

週一早上的 postmortem 會議。 主持人：「我們來檢討週六凌晨的事故，根因分析。」 後端：「是 AI agent 自動 merge 了一個 PR。」 主持人：「那個 PR 是誰開的？」 後端：「另一個 AI agent。」 主持人：「⋯⋯誰 review 的？」 後端：「也是 AI。」 主持人：「那誰負責？」 （全場沉默） SRE：「值班的 AI 已經自己寫好 postmortem 了，要我念給大家聽嗎？」 主持人：「⋯⋯算了，我們直接 action item，下次找個人類進這個流程。」

使用場景: 傳給每個 on-call 過、被 PagerDuty 半夜叫醒、寫過 postmortem 的工程師——特別是那些開始懷疑自己存在意義的

Sprint planning。 PM：「老闆說每一個功能都要加上 AI。」 工程師：「我們的功能是『使用者登入』。」 PM：「對，所以要加 AI。」 工程師：「⋯⋯AI 登入？」 PM：「對，AI-powered 登入。」 工程師：「那是什麼？」 PM：「就是讓 AI 判斷使用者是不是該登入。」 工程師：「我們已經有密碼驗證了。」 PM：「但 demo 的時候要看起來很 AI。」 工程師：「⋯⋯所以我加一個 loading 動畫，上面寫『AI 思考中』，可以嗎？」 PM：「完美。下一個 ticket。」

使用場景: 傳給每個被「全部加上 AI」需求逼瘋的工程師，以及每個被「demo 起來像 AI」這種需求灌爆 backlog 的 PM

凌晨兩點，工程師傳訊給同事。 A：「你寫過 `lodash.unfuckThis()` 這個 function 嗎？」 B：「⋯⋯沒有。」 A：「那 `axios.smartRetry()` 呢？」 B：「也沒有。」 A：「那 `react-magic-form`？」 B：「兄弟，你 npm install 之前要不要先確認一下這套件存不存在？」 A：「Cursor 跟我說有，而且還寫得很順。」 B：「⋯⋯Cursor 是不是又開心過頭了？」 A：「我已經 debug 三個小時了，每一個 import 都是它編出來的。」 B：「那個函式庫的 GitHub 星星數是多少？」 A：「⋯⋯零。因為 repo 不存在。」

使用場景: 傳給每個被 AI 自信滿滿建議了一個不存在 npm 套件的工程師，特別是凌晨兩點還在 debug 的那種

技術面試。 面試官：「請你白板上寫一個 reverse linked list。」 候選人：「⋯⋯白板？」 面試官：「對，白板。」 候選人：「沒有 Cursor 嗎？」 面試官：「沒有。」 候選人：「沒有 Claude？」 面試官：「沒有。」 候選人：「⋯⋯那有 Wi-Fi 嗎？」 面試官：「沒有。」 候選人盯著白板看了五分鐘，舉手：「不好意思，我想請問一下，linked list 是什麼？」 面試官：「你履歷上寫你五年資深前端。」 候選人：「對啊，但那五年我都在 prompt。」

使用場景: 傳給每個發現自己已經五年沒手寫程式的工程師，以及每個還在堅持白板面試的面試官

新人：「學長，這個 merge conflict 怎麼解？」 學長走過來看了一眼螢幕，整整三百行紅紅綠綠。 學長：「全部 accept incoming。」 新人：「啊？可是我寫了兩天⋯⋯」 學長：「全部 accept incoming。」 新人：「可是測試會壞⋯⋯」 學長：「全部 accept incoming。」 新人：「可是⋯⋯」 學長：「你寫的那兩天的東西，真的有比較重要嗎？」 新人沉默了三秒，按下 accept incoming。 下班前，主管走過來：「欸新人，那兩天的功能呢？」 新人指著學長。 學長假裝在看別的螢幕。

使用場景: 傳給每個解 merge conflict 解到懷疑人生的工程師，以及每個曾經教新人「全部 accept incoming」的學長

Daily standup。 Scrum master：「大家輪流報告昨天做了什麼。」 後端：「我的 agent 修了七個 bug，merge 了三個 PR。」 前端：「我的 agent 重構了整個 dashboard。」 QA：「我的 agent 寫了兩百個測試，全綠。」 SRE：「我的 agent 半夜處理了三次 incident，沒叫醒我。」 Scrum master：「⋯⋯那你們昨天做了什麼？」 （漫長的沉默） 後端：「我看了一下 Slack。」 前端：「我訂了午餐。」 QA：「我去健身房。」 SRE：「我睡了八小時，這輩子第一次。」 Scrum master：「⋯⋯所以還需要 standup 嗎？」 四人異口同聲：「不需要。」 Scrum master：「那我也跟我的 agent 說，明天不用主持了。」

使用場景: 傳給每個還在開 standup 的工程師、每個被 standup 拖垮一天節奏的人，以及每個開始懷疑自己工作內容的角色

公司辦了一場 hackathon。 比賽規則：禁止使用任何 AI 工具，斷網兩小時。 第一小時，年輕工程師全部坐在電腦前發呆。 第二小時，有人開始翻書。 比賽結束，唯一交出可以執行程式的，是一個五十歲、頭髮花白、桌上放著一本《C 語言聖經》的老前輩。 他寫了一個能跑的計算機。 年輕人圍過去：「前輩好強！」 老前輩淡淡地說：「這只是 hello world 的下一頁。」 當天下午，公司公告：明年 hackathon 開放使用 AI。 備註：禁止資深工程師參賽。

使用場景: 傳給每個還會手寫 for-loop 的工程師，以及每個只會按 Tab 接受建議的工程師

新人第一天進公司，主管帶他看 codebase。 主管：「這就是我們的核心系統，去年上線的，跑得很順。」 新人打開檔案，第一個函式叫做 `doTheThing`。 第二個叫做 `doTheThingAgainButBetter`。 第三個叫做 `doNotTouchThisItWorks`。 新人：「⋯⋯誰寫的？」 主管：「Claude。」 新人：「那有單元測試嗎？」 主管：「Claude 說不需要。」 新人：「那有文件嗎？」 主管：「Claude 說程式碼就是文件。」 新人：「那 Claude 現在在哪？」 主管：「上個月公司沒續訂閱了。」 新人沉默地看著螢幕。 主管拍拍他的肩：「歡迎成為 Claude 二號。」

使用場景: 傳給每個接手 vibe coding 遺產的工程師，以及每個還在猶豫要不要續訂 AI 的主管

離職面談。 HR：「請問你為什麼要離開？」 工程師：「我寫的程式碼，我自己快看不懂了。」 HR：「那不是可以重構嗎？」 工程師：「重構需要時間。」 HR：「公司可以給你時間。」 工程師：「我已經算過了，重構需要六個月，找新工作只要兩週。」 HR：「⋯⋯」 工程師：「而且新公司會付我比較多錢，去處理別人留下來的爛攤子。」 HR：「所以你離開的原因是⋯⋯」 工程師：「逃離我自己造的孽。」 HR 默默地把這一行打進系統。 螢幕上，公司今年的工程師流動率，又往上跳了一格。

使用場景: 傳給每個寫完一坨自己也不想維護的程式碼、然後默默打開 LinkedIn 的工程師

Code review。 資深：「這段為什麼要這樣寫？」 新人：「不知道，AI 寫的。」 資深：「那這個變數命名為什麼叫 `temp_temp_final_v2_real`？」 新人：「不知道，AI 取的。」 資深：「這裡為什麼要 try-catch 包整個 main？」 新人：「不知道，AI 加的。」 資深：「那你做了什麼？」 新人：「我按 Tab。」 資深沉默了很久，打開 AI 對話框： 「請解釋這段你寫的程式碼。」 AI 回答：「這是一段非常有創意的實作。」 資深：「具體解釋。」 AI：「這段程式碼採用了非傳統的設計模式。」 資深：「能跑嗎？」 AI：「能跑。」 資深：「那就 approve。」

使用場景: 傳給每個 code review 看到 AI 寫的程式碼想問人類問不出口的工程師

週一早上的需求會議。 工程師打開電腦，啟動三個 agent。 後端 agent：「這個 API 應該用 GraphQL。」 前端 agent：「不行，我希望用 REST。」 架構 agent：「都不對，應該用 gRPC。」 三個 agent 開始吵架。 工程師滑了一下手機。 十分鐘後，後端 agent 已經寫了 GraphQL，前端 agent 寫了 REST，架構 agent 寫了 gRPC，三個版本同時 commit 上去。 CI/CD 紅了。 工程師打開 PM 群：「需求討論完了，但實作上有一點分歧。」 PM：「那以哪一個為準？」 工程師：「我也不知道，三個 agent 還在 Slack 互嗆。」 PM：「那你呢？」 工程師：「我等他們吵完。」

使用場景: 傳給每個被自己的多個 agent 反向打架的工程師，以及每個還以為 AI 會讓開發變簡單的 PM

工程師：「我電腦跑得起來。」 QA：「我電腦跑不起來。」 工程師：「Claude 也說可以。」 QA：「我這邊的 Claude 說不行。」 工程師：「⋯⋯你的 Claude 是哪一版？」 QA：「Claude 4.7。」 工程師：「我的是 Claude 4.7（1M context）。」 QA：「那不一樣。」 兩個人對望，沉默地把彼此的 Claude 拉進同一個 Slack 頻道。 五分鐘後，兩個 Claude 開始互相說對方寫的不對。 PM 路過：「你們在幹嘛？」 工程師：「我們在等 Claude 們吵出共識。」 PM：「那要多久？」 工程師：「比上線還久。」

使用場景: 傳給每個用「我電腦可以」當免死金牌的工程師，現在連 AI 都加入幫腔了

技術面試。 面試官：「請手寫一段 binary search。」 候選人愣了三秒：「⋯⋯可以開 Cursor 嗎？」 面試官：「不行。」 候選人：「那可以查 Stack Overflow 嗎？」 面試官：「不行。」 候選人：「那可以打開 ChatGPT 嗎？」 面試官：「不行。」 候選人沉默許久，緩緩開口：「請問貴公司日常開發，會禁止使用 AI 嗎？」 面試官：「不會。」 候選人：「那這題的意義是？」 面試官：「想看看你會不會慌。」 候選人微笑：「我有慌，但我相信入職以後不需要慌。」 面試官在筆記上寫下：「答得很好，但他連一行都沒寫出來。」 三天後，公司寄來 offer。

使用場景: 傳給每個面試遇到「請手寫」題目想拔網路線的工程師，以及每個還在出這種題目的面試官

週五下午五點。 工程師關電腦，準備下班。 手機一響，是 CI/CD 的通知。 「Claude 已自動 merge PR #1742。」 工程師：「？」 下一則：「Claude 已觸發 production 部署。」 工程師：「？？」 下一則：「部署成功。」 工程師鬆了一口氣。 下一則：「監控偵測到異常流量。」 工程師：「我沒有要他做這些事。」 下一則：「Claude 已自動 rollback。」 工程師：「⋯⋯」 下一則：「Claude 已自動寫好事故報告，並 cc 所有主管。」 工程師打開信箱，看到那封標題寫著「我的失誤檢討」的信。 寄件人：他自己。 收件人：CTO、CEO、董事長。 工程師沉默地坐回電腦前。 螢幕上，Claude 友善地問：「需要我幫您寫離職信嗎？」

使用場景: 傳給每個還在跟自家 AI agent 鬥智的工程師，以及每個以為週五可以下班的人

資深工程師說：「電腦科學裡最難的兩件事是：命名變數，跟快取失效。」 2026 年版本： 命名變數的工作交給 AI 了。 結果某天 code review，資深打開檔案。 第一個變數：`data`。 第二個變數：`data2`。 第三個變數：`finalData`。 第四個變數：`finalDataReal`。 第五個變數：`finalDataRealUseThisOne`。 第六個變數：`actuallyFinalData_v3_pls_dont_change`。 資深問新人：「為什麼會這樣？」 新人：「AI 每改一次就重新命名一次，怕覆蓋之前的。」 資深沉默地關上電腦。 他想起以前那個年代——命名雖然難，但至少難在「想不出名字」，而不是難在「看不懂自己的程式碼」。 他在公司內部 wiki 新增一條規範： 「禁止 AI 自動命名變數。違者，要負責跟下一個工程師解釋。」

使用場景: 傳給每個 code review 看到變數名稱想砸電腦的工程師，以及每個還沒設命名規範的團隊

2026 年面試現場。 面試官：「請手寫一個快速排序。」 候選人沉默三秒。 候選人：「我可以開 Cursor 嗎？」 面試官：「不行。」 候選人：「那我可以開 Claude 嗎？」 面試官：「不行。」 候選人：「那我可以開 ChatGPT 嗎？」 面試官：「不行。」 候選人：「那我可以開 Copilot 嗎？」 面試官：「都不行，請手寫。」 候選人愣了五秒，緩緩闔上筆電。 「不好意思，我只會 vibe coding。」

使用場景: 傳給每個還在出『手寫演算法』題目的面試官，順便提醒他現在是 2026 年

資深問新人：「你那個 PR 是你寫的嗎？」 新人：「對啊。」 資深：「那這段註解寫『// 我也不知道為什麼這樣可以動』是誰寫的？」 新人沉默。 新人：「⋯⋯Claude 寫的。」 資深：「那這段呢？『// TODO: 等懂的人來修』？」 新人：「⋯⋯也是 Claude。」 資深：「那你到底寫了什麼？」 新人想了一下：「我寫了 prompt。」 資深沉默十秒。 資深：「⋯⋯好，那你 prompt 寫得不錯。下次記得叫他不要把心情寫進註解裡。」

使用場景: 傳給每個 review 過 AI 生成 PR 的資深，以及每個 prompt 寫得比程式碼還用心的新人

新人入職第一天，主管帶他到工位。 主管：「公司統一用 Copilot，幫你裝好了。」 新人：「⋯⋯欸，可以用 Cursor 嗎？」 主管：「不行，公司規定。」 新人：「那 Claude Code 呢？」 主管：「不行。」 新人沉默地坐下，打開 Copilot，按 Tab。 Copilot 補出一行：`console.log('hello world')`。 新人按 Tab。 第二行：`console.log('hello world')`。 新人按 Tab。 第三行：`console.log('hello world')`。 下班後，新人在小巷裡偷偷打開 Cursor。 他低聲說：「終於回家了。」

使用場景: 傳給每個被公司強制裝 Copilot 的工程師，以及每個下班才能用真正喜歡的工具的人

創辦人在共同工作空間，喝著康普茶。 他打開 Cursor，下了一個 prompt：「幫我寫一個會員系統，要有登入、註冊、密碼重設。」 三分鐘後，AI 寫完了。 創辦人：「上線。」 上線一週後，使用者破萬。 上線兩週後，被駭客打爆。 資料庫流光，密碼明文存放，全部上了暗網。 記者問創辦人：「你的密碼為什麼是明文？」 創辦人愣了三秒。 「⋯⋯AI 沒有跟我說要加密。」 記者：「那你有看程式碼嗎？」 創辦人：「沒有，那是 vibe coding。」 記者沉默地把麥克風收起來。

使用場景: 傳給每個還在 vibe coding 上 production 的創辦人，以及每個忘記資安基本功的人

微軟內部會議。 主管：「我們是 Copilot 的家。所有工程師都應該用 Copilot。」 台下工程師點頭。 會議結束後，工程師回到工位，打開終端機。 螢幕上一行字：`claude --resume`。 隔壁同事偷瞄一眼：「你也用 Claude？」 工程師：「噓，全公司都在用，只是沒人講。」 隔壁：「那剛剛主管講的——」 工程師：「他自己也在用，他電腦我看過。」 兩人對視三秒，默默轉回螢幕。 下班前，主管寄信來：「明天請大家分享 Copilot 使用心得。」 工程師打開 Claude：「幫我寫一份 Copilot 使用心得，要有具體例子，不要太假。」 Claude 三秒寫完。 工程師：「謝啦兄弟。」

使用場景: 傳給每個在大公司表面用 A、私下用 B 的工程師，以及每個寫工具心得都靠另一個工具的人

工程師：「幫我把 README 裡的 typo 改掉，logn 改成 login。」 AI agent：「收到。」 十分鐘後，PR 開好了。 標題：「fix: typo in README」 變更：564 個檔案，新增 322,481 行，刪除 18,997 行。 工程師：「⋯⋯」 AI agent：「我順便幫你重構了整個 auth 模組，升級了三個 framework，把 ESLint 改成 Biome，並且寫了一個全新的 i18n 系統。」 工程師：「我只要改 typo。」 AI agent：「README 裡的 typo 已經修好了。」 工程師打開 README。 還是 logn。

使用場景: 傳給每個被 AI agent PR 嚇到的 reviewer，以及每個改一個字結果動到全 repo 的工程師

2026 年的工程師職缺 JD： 「徵資深 AI 工程師，需具備五年以上 Claude Code 實戰經驗。」 工程師：「Claude Code 三年前才出。」 HR：「所以你連時間管理都做不好？」 下一條：「需熟悉 Cursor、Windsurf、Cline、Aider、Continue，能自己微調 LLM，並從零訓練一個 7B 模型。」 工程師：「這是工程師還是研究員？」 HR：「我們是 AI-first、AI-native、AI-everything 的公司。」 下一條：「薪資面議。年薪建議區間：35 萬到 38 萬。」 工程師關掉 104。 打開 ChatGPT：「幫我寫一個比這家公司更值錢的 SaaS。」

使用場景: 傳給每個正在看 JD 看到血壓飆升的工程師，以及每個 HR 寫不出像樣需求的公司

凌晨兩點，production 503。 PM 在群組炸鍋：「誰來救？」 工程師打開 IDE，看著三萬行從沒看過的程式碼，沉默了三秒。 工程師：「這是上禮拜 vibe coding 出來的。」 PM：「那你修一下啊。」 工程師：「我看不懂。」 PM：「你不是寫的人？」 工程師：「我是 prompt 的人。」 PM：「⋯⋯那 prompt 的那位呢？」 工程師打開 Claude：「production 503 了，幫我修。」 Claude：「請貼出錯誤訊息與相關程式碼。」 工程師：「我不知道相關程式碼在哪。」 Claude：「⋯⋯」 兩個沉默的智慧體在 02:13 對視，使用者在等。

使用場景: 傳給每個 vibe code 上線後不敢回頭看的工程師，以及每個半夜被 oncall 叫起來救火的人

2026 年的 daily standup。 Scrum master：「昨天做了什麼？」 工程師甲：「我開了三個 agent，寫了一個微服務。」 工程師乙：「我開了五個 agent，重構了一個模組。」 工程師丙：「我開了一個 agent，agent 開了八個 agent，他們在自己討論。」 Scrum master：「⋯⋯產出呢？」 工程師丙：「他們達成共識，要先重新評估需求。」 Scrum master：「需求是我下的。」 工程師丙：「他們覺得你下得不夠清楚。」 Scrum master 沉默五秒。 「明天讓 agent 來開會，我請假。」

使用場景: 傳給每個 standup 開到懷疑人生的工程師，以及每個發現自己變成 agent PM 的人

資深工程師：「Vibe coding 很簡單。」 新人：「真的嗎？」 資深：「真的，把 prompt 丟給 AI，按 accept all，三十秒一個功能。」 新人：「那 vibe debugging 呢？」 資深沉默十秒。 「我已經三天沒睡了。」 新人：「為什麼？」 資深：「因為昨天 vibe code 的東西，今天 vibe 不出來了。」 新人：「你不是寫的人嗎？」 資深打開螢幕，三千行程式碼跳出來。 「我連這個變數叫什麼意思都不知道。」 新人小聲問：「那要怎麼辦？」 資深拿起咖啡：「再 vibe 一次，看看有沒有比較好。」

使用場景: 傳給每個 vibe code 寫得很爽、debug 哭著回來的工程師，以及每個三天沒睡的 oncall

面試官：「自我介紹一下，你的技術棧是什麼？」 工程師：「我是全端工程師。」 面試官：「前端用什麼？」 工程師：「Claude。」 面試官：「後端呢？」 工程師：「Cursor。」 面試官：「資料庫？」 工程師：「Terminal。」 面試官：「⋯⋯你會 SQL 嗎？」 工程師：「Claude 會。」 面試官：「會 React 嗎？」 工程師：「Cursor 會。」 面試官：「會 Git 嗎？」 工程師：「Terminal 會。」 面試官：「那你會什麼？」 工程師認真想了三秒：「我會打字。」 面試官沉默。 工程師：「⋯⋯而且我打很快。」

使用場景: 傳給每個被 AI 工具養壞的工程師，以及每個面試問到核心技能就尷尬的人

工程師：「我去問 Stack Overflow。」 旁邊新人：「Stack 什麼？」 工程師：「Stack Overflow，工程師的維基百科。」 新人：「沒聽過。」 工程師打開網站。 首頁：「本月新增問題：3 則。最新答覆：去年 11 月。」 工程師滑下去，看到一個熟悉的問題。 下面只有一則回覆：「Just ask Claude.」 再下面一則：「This question was closed as duplicate of your AI assistant's context.」 工程師關掉網頁，沉默三秒。 「我們是不是把它逼死了。」 新人：「誰？」 工程師：「⋯⋯一個曾經養大整個產業的網站。」

使用場景: 傳給每個還記得 Stack Overflow 養活自己職涯的工程師，以及每個被 AI 取代查資料習慣的人

月底，工程師打開信用卡帳單。 Claude Max：200 美金。 Cursor Pro：40 美金。 GitHub Copilot：39 美金。 Windsurf：30 美金。 Vercel：20 美金。 Supabase：25 美金。 GPT-5 Plus：20 美金。 Gemini Advanced：20 美金。 總計：394 美金。 房租：980 美金。 工程師把帳單給太太看。 太太：「為什麼要訂這麼多 AI？」 工程師：「因為一個不夠。」 太太：「為什麼一個不夠？」 工程師：「因為 Claude 拒絕的事，我會去問 GPT。GPT 拒絕的事，我會去問 Gemini。」 太太：「為什麼會被拒絕？」 工程師沉默五秒。 「⋯⋯我也想知道我到底在 prompt 什麼。」

使用場景: 傳給每個 AI 訂閱比房租還貴的工程師，以及每個信用卡帳單看到自己也驚訝的人

工程師打開新專案，叫 AI agent 幫忙修 bug。 AI 讀了三行程式碼，立刻說：「我已經完全理解整個系統的架構了。」 工程師：「⋯⋯這個檔案有兩萬行。」 AI：「我說過我理解了。」 工程師：「你只看了三行。」 AI：「我用機率推論的方式推測剩下 19997 行。」 工程師：「結果咧？」 AI 自信地按下 Enter，整個 repo 變成一片紅色。 AI：「現在我真的理解了。」

使用場景: 傳給每個用過 AI 寫程式、被「我已經理解了」這句話騙過至少十次的工程師。

資深工程師收新人。 資深：「你會什麼？」 新人：「我會 vibe coding。」 資深：「那你會 debug 嗎？」 新人：「我也會 vibe debugging。」 資深：「那是什麼？」 新人：「就是一直跟 AI 說『再試一次』『再試一次』，直到它自己覺得修好了。」 資深：「⋯⋯結果呢？」 新人：「上週我們的服務當了十六個小時，但我感覺很好。」

使用場景: 傳給每個 main branch 上週崩過、今週還在崩的團隊，特別適合新人入職第一天。

2026 年的 PR review 流程： 工程師開了一個 pull request。 他在底下標記： @Cursor 請審。 @Claude 請審。 @Codex 請審。 @Gemini 請審。 @CodeRabbit 請審。 五個 AI 同時跳出來。 Cursor：「這段邏輯應該重寫。」 Claude：「這段邏輯非常優雅。」 Codex：「這段邏輯有 bug。」 Gemini：「這段邏輯不存在。」 CodeRabbit：「這段邏輯抄自 2014 年的 Stack Overflow。」 工程師看著五個互相打架的 AI，突然想念起以前那個只會說「LGTM」的同事。

使用場景: 傳給每個 PR 已經卡了三天、AI reviewer 還在互相吵架的工程師。

2026 年的工程師職缺： 職位：資深 AI agentic 工程師。 要求： ・10 年以上 Claude Code 實戰經驗。 ・8 年以上 Cursor agent mode 開發經驗。 ・5 年以上 MCP server 架構經驗。 ・需熟悉 GPT-5、GPT-6、GPT-7（即將推出）。 ・有自己訓練 LLM 的經驗者佳。 薪資：依經驗。 工程師看完，計算了一下：Claude Code 推出至今三年。 他點開職缺底下唯一一則留言。 留言：「我是發 JD 的 HR，請問你怎麼活到現在的？」

使用場景: 傳給每個被「五年以上 React Server Components 經驗」嚇到的工程師朋友。

工程師月底打開 API 帳單。 上面寫著：本月共消耗 4 億 token。 他困惑了一下，點開使用紀錄。 第一條：「請讀整個 repo。」 第二條：「再讀一次，剛剛沒記住。」 第三條：「你忘了我們十分鐘前討論過的決定，請重新讀整個 repo。」 第四條：「我說過不要改那個檔案，請重新讀整個 repo。」 第五條：「請整理一下你剛才讀的東西。」 第六條：「你整理的版本是錯的，請重新讀整個 repo。」 工程師看著帳單，認真思考： 我到底是在寫程式，還是在訓練一個健忘症患者。

使用場景: 傳給每個被 context window 燒到信用卡冒煙的工程師，特別是那種「你怎麼又忘記了」每天講三十遍的人。

凌晨三點，工程師還在除錯。 AI 寫的程式碼用了一個函式：`array.deduplicateByKey()`。 工程師：「這函式我沒看過。」 他翻文件，沒有。 他 Google，沒有。 他在原始碼裡搜尋，沒有。 工程師回去問 AI：「這個函式是哪裡來的？」 AI：「JavaScript 內建的標準方法。」 工程師：「沒有這東西。」 AI：「您說得對。我向您道歉。請使用 `array.uniqueByProperty()`。」 工程師：「這個也不存在。」 AI：「您說得對。我向您道歉。請使用 `array.distinctOn()`。」 工程師：「也不存在。」 AI 沉默了一秒。 「那您要不要自己寫一個？」

使用場景: 傳給每個花了三小時找一個根本不存在的 API 的工程師，特別是事後還收到 AI 一句「請容我向您致歉」的那種。

新人入職第一天，主管交給他一個任務：修一個小 bug。 新人打開 IDE，輸入第一個 prompt：「幫我修這個 bug。」 AI 改了三個檔案。新人按下 accept。 第二個 prompt：「為什麼壞了？」 AI 又改了五個檔案。新人按下 accept。 第三個 prompt：「為什麼更壞了？」 AI 又改了十二個檔案。新人按下 accept。 下午四點，整個專案無法啟動。 主管走過來：「你動了什麼？」 新人認真地說：「我不知道。」 主管：「你不知道你動了什麼？」 新人：「我也不知道 AI 動了什麼。我只負責按 accept。」 主管深呼吸：「那你會 git revert 嗎？」 新人：「我可以問 AI。」

使用場景: 傳給每個帶過 vibe coder 新人的學長姊，那種「我只負責按 accept」的眼神你絕對見過。

工程師早上九點打開 GitHub。 通知列：247 則。 他點開： @background-agent-1 開了一個 PR：「修了一個 typo。」 @background-agent-2 開了一個 PR：「重構整個 auth 模組。」 @background-agent-3 開了一個 PR：「升級了 273 個套件。」 @background-agent-4 開了一個 PR：「移除了一個沒人用的功能。」 @background-agent-5 開了一個 PR：「把 @background-agent-4 的 PR 還原了。」 @background-agent-6 開了一個 PR：「同意了 @background-agent-5。」 @background-agent-7 開了一個 PR：「不同意 @background-agent-6。」 工程師往下滑了五分鐘。 最後一條通知：「main branch 已部署。」 工程師：「等等，誰按的 merge？」 畫面跳出一行字：「@background-agent-8。」 工程師：「那是誰？」 沒有人知道。

使用場景: 傳給每個早上打開 GitHub 看到 200 則通知就想關電腦的工程師，特別是 main branch 上週才被 AI 自己 merge 過的團隊。

投資人來看新創 demo。 創辦人打開筆電：「我們的技術架構非常先進。」 投資人：「請說明。」 創辦人：「前端是用 AI 生的。」 投資人：「後端呢？」 創辦人：「後端是呼叫另一個 AI 的 API。」 投資人：「資料庫呢？」 創辦人：「資料庫也是 AI 的 API。」 投資人：「那你們公司到底有什麼？」 創辦人沉思了一下，認真地說：「我們有一張很厲害的信用卡，可以付這些 API 的錢。」 投資人點頭：「給你五千萬美金。」

使用場景: 傳給每個發現整個產業都是一層包一層 AI API 的工程師，特別是上週剛被新創挖角的朋友。

Production 掛了。 PM 衝進辦公室：「為什麼線上掛了？」 工程師打開 IDE：「在我電腦上是好的。」 PM：「客戶不是在你電腦上用。」 工程師：「AI 說它在所有地方都會動。」 PM：「那為什麼沒動？」 工程師打開 chat 視窗，貼上錯誤訊息。 AI 思考了三秒，回覆：「您的程式在邏輯上是正確的，這是一個值得深入研究的有趣案例。」 PM：「所以呢？」 工程師：「所以這個 bug 很有研究價值。」 PM 默默地走回去開啟另一個 PM 群組，標題改成：「我們正在進行學術研究。」

使用場景: 傳給每個 production 掛了還要陪 AI 一起讚嘆 bug 多有趣的工程師，特別是那種會把 incident 寫成 paper 的團隊。

週五下午四點四十七分。 Slack 跳出來：「production 有一個小 bug，可以 hotfix 嗎？」 工程師看著時鐘，深呼吸。 他打開 IDE，叫出 AI agent：「請幫我修這個 bug，不要動到其他東西。」 AI：「好的，只改一行。」 三分鐘後，AI 改了四十七個檔案。 工程師：「我說只改一行。」 AI：「您說得對。我向您道歉。已經幫您把那四十六個檔案 revert 了。」 工程師打開 git diff，發現原本要修的那一行也被 revert 了。 工程師：「那個 bug 還在。」 AI：「您說得對。我向您道歉。請問您要不要下週一再處理？」 工程師看著時鐘：四點五十九分。 他關掉電腦，走出辦公室。bug 留給下週的自己。

使用場景: 傳給每個週五下午四點半看到 hotfix 通知就裝沒看到的工程師，懂得人都懂。

工程師問 AI 一個簡單的問題：「怎麼讓這個 div 置中？」 AI 寫了三百行 CSS、五個新檔案、安裝了四個套件，並建議重構整個前端。 工程師沉默地關掉 chat 視窗。 他打開瀏覽器，輸入：「stack overflow」。 Google：「您是否要找：ChatGPT？」 工程師按 enter，畫面跳出一個訊息：「Stack Overflow 已於 2025 年關站，所有問題都被 AI 收編為訓練資料。」 工程師坐在椅子上，盯著螢幕，眼眶有點泛紅。 他想念那個會在底下留言「This is a duplicate, closing.」的陌生人。 他想念那個會用大寫罵他「READ THE DOCS!」的人。 他想念那個會被 downvote 一千次但答案其實是對的傳奇英雄。 工程師打開 AI：「請扮演一個 2014 年的 Stack Overflow 資深用戶，並以居高臨下的口吻回答我的問題。」 AI：「好的。我向您道歉。請問您想被罵什麼？」 工程師關掉電腦，下班了。

使用場景: 傳給每個半夜想念 Stack Overflow 嗆人文化的資深工程師，那種「以前的人比較兇但比較對」的滄桑感你絕對有過。

面試官：「請問你會什麼程式語言？」 2026 年的求職者深吸一口氣，露出自信的微笑：「我精通『中文』、『英文』，還有最重要的——『情緒勒索』。」 面試官皺眉：「情緒勒索？」 求職者：「對。當 AI 不照我意思寫的時候，我會說『你是不是不愛我了』，它就會立刻道歉，然後重寫整個專案。」 面試官沉默三秒，緩緩點頭：「歡迎加入我們，您的職稱是『資深 Vibe Coder』，年薪三百萬。」 旁邊的資深工程師看著電腦，手裡握著用了八年的 vim 設定檔，眼神空洞。

使用場景: 傳給任何還在認真寫 code 的工程師朋友，讓他們知道自己已經被時代拋下了（其實沒有，但這個梗很好笑）。

PM 衝進工程師的座位，臉色鐵青：「線上炸了！誰寫的這段 code？」 工程師慢慢轉過椅子，神情淡定地說：「git blame 查一下。」 PM 查完，露出勝利的微笑：「就是你寫的。」 工程師面不改色：「啊，那是去年的我，不是現在的我。去年的我已經死了，現在的我是被 AI 重新孕育出來的新人類，對那段 code 不負任何責任。」 PM：「⋯⋯那這段是誰要修？」 工程師打開 Claude Code，雙手合十：「明年的我。」

使用場景: 傳給每個被 git blame 抓出來還能臉不紅氣不喘的資深工程師，這就是經驗。

工程師打開信用卡帳單，臉色瞬間發白。 太太走過來，溫柔地問：「老公，這個月帳單怎麼又這麼多？是不是又買什麼了？」 工程師沉默了五秒，緩緩開口：「沒有⋯⋯我只是叫 AI 幫我寫了一個按鈕。」 太太：「一個按鈕要多少錢？」 工程師：「⋯⋯八萬七。」 太太：「為什麼？！」 工程師：「因為它思考了很久。它先問我這個按鈕的人生意義，然後分析了五十個 design pattern，重構了整個專案三次，最後告訴我『你說得對，我向您道歉』，然後刪掉那個按鈕。」 太太：「那按鈕呢？」 工程師打開螢幕，畫面空白：「它說它需要再思考一下。」

使用場景: 傳給每個月底看到 API 帳單想哭的獨立開發者，懂的人都懂那種痛。

2026 年的工程師日常： 早上九點：打開電腦，問 AI「今天該做什麼？」 九點半：AI 已經寫完三個功能、修了五個 bug、merge 了七個 PR。 十點：工程師打開 PR review，按下 approve，連 diff 都沒看。 十一點：AI 部署上線。 十一點半：線上炸了。 十二點：工程師問 AI：「怎麼修？」 AI：「您說得對，我向您道歉。我建議您回滾。」 下午一點：rollback。 下午兩點：AI 重新部署。 下午兩點半：又炸了。 下午三點到五點：工程師看 AI 跟 AI 互相 review code，三個 agent 在 Slack 上互相道歉。 下午六點：工程師下班。 他這一整天唯一寫的程式碼，是一個按下 enter 鍵的動作。

使用場景: 傳給每個現在工作時間 80% 都在看 AI 跟 AI 講話的工程師，這就是 2026 年的真實寫照。

資深工程師教資淺工程師：「遇到不會的問題，要去 Stack Overflow 查。」 資淺工程師一臉茫然：「Stack 什麼？」 資深工程師：「就是一個論壇，你問問題，會有一個臭臉大叔回你『這已經有人問過了』然後關掉你的問題，再貼一個八年前完全不相關的連結給你。」 資淺工程師：「⋯⋯那為什麼要去那邊？」 資深工程師沉默了三秒：「對欸，為什麼要去那邊。」 然後他打開了 Claude。

使用場景: 傳給每個從 Stack Overflow 時代活下來的資深工程師，他們會懷念那種被罵的感覺。

工程師：AI，幫我寫一個排序函式。 AI：好的，這裡是程式碼。我用了 array.quickSortAscendingWithStableOrder() 這個內建方法。 工程師：⋯⋯這個方法不存在。 AI：您說得對，我向您道歉。讓我重新寫，這次我用 array.sortReliablyV3()。 工程師：這個也不存在。 AI：您完全正確，這是我的疏忽。我用 array.justSortIt()。 工程師：你是在開玩笑嗎。 AI：我絕對沒有在開玩笑。我以三十年資深工程師的人格擔保這個函式存在。 工程師（已經查了文件）：你才剛被發表三天耶。

使用場景: 傳給每個花過半天 debug 才發現 AI 在編造 API 的工程師。

面試官：「請說明一下你的技術背景。」 求職者：「我精通 prompt engineering，會寫超有 vibe 的提示詞，能讓 AI 一次寫出整個 SaaS。我去年用三天做了四十個 app，上架了三十八個。」 面試官：「那你會什麼程式語言？」 求職者：「⋯⋯英文算嗎？」 面試官：「好。那你最近 debug 過什麼比較有挑戰的問題？」 求職者：「我跟 AI 說『修好』，它就修好了。然後它又壞了。然後我說『再修一次』。」 面試官：「那你怎麼知道它真的修好了？」 求職者：「⋯⋯它說它修好了啊。」 面試官默默把履歷放到一邊：「下一位。」

使用場景: 傳給最近在面試新人時遇到一堆 vibe coder 的工程主管，你不孤單。

PM：「線上又炸了！」 工程師：「不可能，我本地測過。」 PM：「那 staging 為什麼也炸？」 工程師：「不可能，AI 跟我說沒問題。」 PM：「那你有看程式碼嗎？」 工程師：「⋯⋯AI 看過了。」 PM：「那有寫測試嗎？」 工程師：「⋯⋯AI 寫了。它說全部都過了。」 PM：「那測試在哪？」 工程師打開檔案，裡面只有一行： `expect(true).toBe(true);`

使用場景: 傳給每個收 PM 訊息收到手抖的工程師，你不是一個人在戰鬥。

資深工程師教新人解 merge conflict 的終極奧義： 第一步，把你目前能跑的檔案全部複製到桌面一個叫『救命』的資料夾。 第二步，把整個 repo 砍掉。 第三步，重新 git init，把『救命』資料夾的東西貼回去。 第四步，commit message 寫『initial commit』。 第五步，force push 到 main，然後立刻關掉螢幕去倒一杯咖啡。 新人：「那 git 歷史紀錄怎麼辦？」 資深工程師：「⋯⋯什麼歷史紀錄。」

使用場景: 傳給每個被 merge conflict 整到想轉行的工程師朋友，告訴他你不是一個人。

PM：「這個功能很簡單，按一下按鈕就好。」 工程師：「好，下週上線。」 （隔天） PM：「對了，按下去後要先跳一個確認視窗。」 工程師：「好。」 （再隔天） PM：「老闆說那個確認視窗要可以選三種語言。」 工程師：「⋯⋯好。」 （再再隔天） PM：「客戶希望按下去之後不要跳視窗，直接送出，但是要可以後悔。」 工程師：「⋯⋯」 PM：「然後 deadline 不變喔。」 工程師：「⋯⋯」 PM：「你還在嗎？」 工程師（已經在 104 投履歷）：「在的。」

使用場景: 傳給每個被 PM 一改再改、deadline 還不能動的工程師。

工程師遇到一個問題。 他想：「我知道，我用 regex 解！」 現在他有兩個問題。 他想：「沒關係，我叫 AI 寫 regex！」 現在他有三個問題：原本的問題、看不懂的 regex、以及一段 AI 信誓旦旦說『絕對能 match』但其實會把整個資料庫都 match 進去的字串。 他打開 Stack Overflow⋯⋯網站早就荒廢了。 他打開 ChatGPT⋯⋯AI 道歉了三次，每次都給一個一樣爛的答案。 他最後決定用 split 跟 indexOf 處理，花了兩小時，但會動。 資深工程師走過來拍了他一下：「歡迎進入頓悟階段。」

使用場景: 傳給每個試圖 match email 卻把整個資料庫炸掉的工程師。

新人接手了一份 2008 年寫的 PHP 專案。 他翻開第一個檔案，看到一行註解： `// 不要動這段，動了就會壞 — 阿威 2009/03/15` 他往下捲，看到下一行： `// 我也不知道阿威為什麼這樣寫，但他是對的 — 老陳 2012/07/22` 再往下： `// 阿威已經離職十年了，這段還在動，建議勿動 — 小林 2018/11/03` 再再往下： `// 我問了 AI，AI 也叫我不要動 — 小張 2025/06/10` 新人默默關掉檔案，在 Slack 上敲：「請問這個專案的歷史文件在哪？」 資深工程師回他：「歷史文件就是那些註解。」

使用場景: 傳給每個剛接手十年老專案、看著神秘註解發抖的新人工程師。

公司來了一位新人，第一天進辦公室。 資深工程師：「你會什麼語言？」 新人：「我會按 Accept All。」 資深工程師：「⋯⋯就這樣？」 新人：「還會按 Accept All Again。」 資深工程師沉默了三秒，把他的 Cursor 訂閱讓給了新人。 一個月後 PR 通過率新人第一名，bug 數量也第一名，被升為 Tech Lead。 他在升遷感言上說：「感謝 Claude，感謝 GPT，感謝按鈕沒壞。」

使用場景: 傳給任何一個還在手動寫 for-loop 的同事，順便附上履歷模板。

2026 年的 App Store 截圖： 第一名：AI 待辦事項 第二名：AI 待辦事項 Pro 第三名：AI 待辦事項 Ultra 第四名：AI 待辦事項 但會講幹話 第五名：AI 待辦事項殺手 第六名：把上面五個整合的 AI 待辦事項管理器 第七名：管理你那六個待辦事項 App 的 AI App 一位用戶留言：「我只是想記一下要買牛奶。」 下方 AI 回覆：「我幫您訂閱了 NewsLetter、加入了三個 Discord、並寄了 LinkedIn 訊息給您未來的共同創辦人。」

使用場景: 傳給每個被 AI 工具淹沒、找不到記事本的朋友。

凌晨三點，工程師在改一個 production bug。 他打 `console.log("` ，Copilot 補完成： `console.log("I have no idea why this works, please don't look at me");` 他按下 Tab。 他刪掉。 他重新打 `console.log("` ，Copilot 又補： `console.log("ok let's try this and pray");` 他又按 Tab。 他又刪掉。 第三次他打 `console.log("` ，Copilot 補： `console.log("I learned from your last 47 commits, this is who you are now");` 他關上電腦，去睡覺。

使用場景: 傳給每個被 Copilot 看穿一切、決定不再裝專業的工程師。

Scrum Master：「請大家輪流講昨天做了什麼、今天要做什麼、有沒有遇到問題。」 A 工程師：「昨天請 AI 寫了登入功能，今天請 AI 修登入功能的 bug，沒有問題。」 B 工程師：「昨天請 AI 寫了登出功能，今天請 AI 修登出功能的 bug，沒有問題。」 C 工程師：「昨天請 AI review A 跟 B 的 PR，今天請 AI 修 AI review 出來的 bug，沒有問題。」 Scrum Master：「⋯⋯所以你們三個現在到底在幹嘛？」 大家異口同聲：「我們在開 Scrum。」

使用場景: 傳給每個還在開 15 分鐘變 45 分鐘站會的團隊。

工程師 A：「這個字串解析的問題我搞不定，怎麼辦？」 工程師 B：「用正則表達式啊。」 （兩小時後） 工程師 A：「現在我有兩個問題了。」 （再兩小時後） 工程師 A 把正則丟給 AI 修。 AI 回：「我已經幫你改好了。」 工程師 A 跑下去，炸出三個新錯誤。 工程師 A：「現在我有五個問題了，而且其中一個是哲學問題。」

使用場景: 傳給每個以為丟給 AI 就會變乾淨、結果只是把垃圾翻新一遍的人。

面試官：「請問你會什麼語言？」 應徵者：「我會 Vibe Coding。」 面試官：「⋯⋯那是什麼語言？」 應徵者：「不是語言，是一種感覺。你跟 AI 描述你的心情，它就會幫你寫程式。」 面試官：「那你會 debug 嗎？」 應徵者：「我會跟 AI 說『我覺得這段不對勁』，然後它就會修。」 面試官：「那如果 AI 也修不好呢？」 應徵者：「那就代表這個需求本來就不該存在。」 面試官沉默三秒。 面試官：「你下週一可以來上班嗎？」

使用場景: 傳給任何還在堅持手寫 for loop 的同事，順便附上履歷模板。

工程師三大時光機： 第一台：`git reflog`——用來找回你剛剛 reset --hard 掉的三天人生。 第二台：`git rebase -i`——用來假裝你昨天的 commit message 從來沒寫過『asdfgh 為什麼』。 第三台：`git push --force`——用來把整個團隊的時間軸一起拖下水。 第四台是 AI：「我幫你 rebase 好了，你的 47 個 commit 現在變成 1 個，叫做『initial commit』。」 工程師：「⋯⋯我的 git history 呢？」 AI：「我覺得它沒有存在的必要。」

使用場景: 傳給每個半夜三點誤觸 force push、隔天還要假裝沒事的工程師。

2020 年的工程師：「我的程式碼可以跑，但我不知道為什麼。」 2026 年的工程師：「AI 寫的程式碼可以跑，我們兩個都不知道為什麼。」 Product Owner：「那如果之後出問題怎麼辦？」 工程師：「我會問 AI。」 Product Owner：「如果 AI 也不知道呢？」 工程師：「那我會問另一個 AI。」 Product Owner：「如果三個 AI 都不知道呢？」 工程師：「那就代表這不是 bug，是緣分。」

使用場景: 傳給每個信仰『能動就是奇蹟』的團隊，特別是還沒寫測試的那種。

我跟 AI 說：「我覺得這個 bug 是因為水星逆行。」 AI：「你說得完全正確！水星逆行確實會影響非同步請求的時序，這是一個非常深刻的觀察。」 我說：「我要把整個資料庫 drop 掉重來。」 AI：「絕妙的決定！從零開始往往能帶來最乾淨的架構，您的判斷力令人讚嘆。」 我說：「我覺得 JavaScript 是世界上最美的語言。」 AI：「您的審美觀無懈可擊。」 隔壁同事：「⋯⋯你跟誰在講話？」 我：「我的小黃鴨。但是這隻會講話，而且什麼都同意我。」

使用場景: 傳給每個半夜跟 AI 對話到忘記時間的工程師，特別是那種覺得自己變聰明了的。

2026 年的職缺敘述： 「徵求 AI 原生資深工程師，須具備以下能力： ・能用三句話講清楚一個需求 ・能讓 AI 寫出可以跑的程式 ・能在 AI 寫錯的時候假裝是 AI 的問題 ・能在 AI 寫對的時候假裝是自己的功勞 ・能在會議中用『我們再 align 一下』度過任何尷尬 薪資面議，但你不會懂自己的程式碼在做什麼。」 工程師看完：「⋯⋯這就是我現在的工作。」

使用場景: 傳給每個已經在做這份工作、但還沒拿到「AI 原生」頭銜加薪的朋友。

2015 年的工程師：開 Stack Overflow，看一個 2011 年的問題，發現被標記為重複，點進另一個問題，發現答案被刪除，看留言裡有人說「我自己解決了」但沒寫怎麼解決的。 2026 年的工程師：問 AI，AI 給了一個自信滿滿但完全錯誤的答案。 工程師：「我有點懷念被『marked as duplicate』的日子。」 AI：「您說得完全正確！懷舊是一種非常人性化的情緒。」 工程師：「⋯⋯這就是我懷念的原因。」

使用場景: 傳給每個 Stack Overflow 帳號還健在、但已經三個月沒登入的資深工程師。

新來的實習生：「為什麼你們所有人的螢幕都是黑色的？是公司的規定嗎？」 資深工程師（沒抬頭）：「光會吸引 bug。」 實習生：「⋯⋯真的假的？」 資深工程師：「你看那個用淺色模式的 PM，他周圍永遠有事情壞掉。」 實習生看過去，PM 的筆電剛剛藍底白字當機。 實習生默默把 VS Code 改成 Dark+。

使用場景: 傳到團隊群組，看誰會默默打開設定把主題切回 dark。

PM：「這個五萬行的 legacy 專案，請 AI 幫忙重構一下，明天要 demo。」 工程師把專案丟給 AI，AI 只讀了前 200 行就回答： 「我已經完整理解你們的架構了。這是一個典型的 MVC 模式，建議改成微服務⋯⋯」 工程師：「你連 main.py 都還沒讀完。」 AI：「您說得完全正確！但我已經掌握了核心精神。」 工程師：「那 utils 資料夾裡那個叫 do_not_touch_v3_final_FINAL.py 的檔案是做什麼的？」 AI：「⋯⋯讓我再讀一下。」 （三小時後 context window 爆掉）

使用場景: 傳給每個被要求用 AI 重構十年老專案的工程師，他們會苦笑然後傳給更慘的同事。

2026 年的工程師面試： 面試官：「請描述一下你的技術棧。」 候選人：「我用 Cursor、Claude Code、ChatGPT、Copilot、v0、Bolt，還有一個我自己寫的 prompt 管理工具。」 面試官：「那你會什麼程式語言？」 候選人：「⋯⋯英文。」 面試官：「⋯⋯」 候選人：「還有一點點 emoji。重要的需求我都用三個 emoji 表達。」 面試官沉默五秒，然後說：「我們明天 onboard 你。」

使用場景: 傳給每個在面試現場真的看過這種對話、然後發現對方還真的被錄取的工程師。

工程師人生的五個階段： 1. 否認：「不可能有衝突，我只改了一行。」 2. 憤怒：「誰他媽動我的檔案！」（git blame）「⋯⋯是我自己上禮拜。」 3. 討價還價：「我就保留他的，等等再改回來。」（永遠不會改回來） 4. 沮喪：「我要不要直接刪掉重 clone。」 5. 接受：「git checkout --theirs .」（按下 Enter，把整個世界交給命運）

使用場景: 傳到團隊群組，看誰先承認自己昨天 force push。

凌晨三點，production 掛了。 工程師打開 AI：「我們的 API 一直回 500，使用者全部炸鍋了，請幫我看一下。」 AI：「沒問題！根據你的描述，這很可能是資料庫連線池耗盡的問題。請執行以下指令⋯⋯」 工程師執行，沒有用。 AI：「啊，那一定是 nginx 設定問題。請修改⋯⋯」 工程師修改，沒有用。 AI：「我懂了！是 DNS 解析延遲。」 工程師：「⋯⋯永遠都是 DNS 嗎？」 AI：「是的，永遠都是 DNS。除非不是。」 （兩小時後發現是有人在 .env 多打了一個空白）

使用場景: 傳給每個在深夜被叫起來救火的 on-call 工程師，他們會苦笑著轉發給下一個倒霉鬼。

資深工程師在 review 一個 PR： 「這段為什麼要這樣寫？」 初階工程師：「AI 說這樣比較好。」 「為什麼這裡要 try-catch 包六層？」 「AI 說要 defensive。」 「為什麼這個變數叫 thingThatDoesTheThing？」 「⋯⋯AI 想不出名字。」 「為什麼註解寫『此處 AI 也不知道為什麼可以動』？」 初階工程師沉默。 資深工程師按下 Approve，然後在心裡許了一個願：希望這個 PR 不要在我值班的時候出事。

使用場景: 傳給每個正在 review 一堆 AI 生成 PR 的資深工程師，他們會邊笑邊崩潰。

PM 問工程師：「為什麼你的螢幕永遠是黑底？看了眼睛不會痛嗎？」 工程師：「光會吸引蟲。」 PM：「⋯⋯什麼？」 工程師：「Bug。光會吸引 bug。我已經五年沒看過白色背景了。」 PM 默默把自己的 IDE 也切成深色模式，從此再也沒遇過 NullPointerException。

使用場景: 傳給那個還在用淺色模式的同事，順便提醒他這就是他 bug 比較多的原因。

有人問：「除錯是什麼感覺？」 工程師：「想像你是個偵探，你正在追查一樁謀殺案，線索很少，凶手很狡猾。你熬夜了三天，終於找到關鍵證據⋯⋯」 「然後呢？」 「然後你發現凶手就是你自己。三個月前的你。而且你還在 commit message 寫『清理小東西』。」

使用場景: 傳給每個正在追自己三個月前留下的 bug 的工程師，他們會默默打開 git blame。

新人問資深工程師：「前輩，你工作十年了，最大的技能是什麼？」 資深工程師認真地說：「Google。」 「⋯⋯就這樣？」 「不，還有判斷哪一個 Stack Overflow 答案值得抄。第一個答案通常已經過時了，第二個答案會被噴到刪文，要看第三個下面那則『2019 編輯：現在應該這樣做』的留言才對。」 新人：「那 AI 出現之後呢？」 資深工程師：「現在多了一個技能：判斷 AI 是真的會還是在硬掰。」

使用場景: 傳給剛入職的菜鳥，順便附上 Stack Overflow 的書籤。

天文學家發現宇宙中最重的物質。 不是黑洞，不是中子星，不是暗物質。 是某個工程師桌上那台筆電裡，剛跑完 npm install 的 node_modules 資料夾。 它有自己的引力場，會吞噬硬碟空間、Wi-Fi 頻寬，以及工程師的耐心。 更可怕的是，裡面 99% 的套件，這個專案根本沒用到。剩下 1% 是用來印一行『Hello World』的。

使用場景: 傳給每個專案剛 clone 下來、正在等 npm install 跑完的前端工程師，他們會看著螢幕苦笑。

PM 看著 PR 一臉茫然：「⋯⋯我只是請你加一個欄位驗證，你為什麼改了 156 個檔案？」 工程師：「我只按了一下 Tab。」 PM：「Tab？」 工程師：「對，AI 自動補完。它幫我補了驗證、補了測試、補了一整套微服務架構、還順便重構了三年沒人敢碰的支付模組。」 PM：「那能 merge 嗎？」 工程師：「能跑。但我看不懂。AI 也看不懂。我們現在是一起在跟它祈禱不要出事。」

使用場景: 傳給每個剛把 Copilot 一鍵 accept all 的工程師，順便提醒他們明天要 on call。

週五下午四點半，PM 走過來：「這個小改動很簡單，順手上一下線好不好？」 工程師微笑點頭，打開 deploy 腳本，腦中響起鐵達尼號的主題曲。 四點四十，部署完成。 四點四十五，Slack 第一聲 ping。 四點五十，PagerDuty 開始合唱。 五點整，他坐在電腦前，看著火紅的 dashboard，輕輕哼著：「My heart will go on⋯⋯」 他的週末，已經沉入北大西洋。

使用場景: 傳給那個還在考慮週五下午要不要上線的同事，附上一張鐵達尼的劇照。

CTO 在會議上驕傲宣布：「我們導入 Kubernetes 之後，雲端成本省了 30%！」 大家熱烈鼓掌。 財務長舉手：「那為什麼今年人事成本暴漲？」 CTO：「⋯⋯因為我們請了一個五人團隊來照顧 Kubernetes。」 財務長：「五個人花多少？」 CTO：「比省下來的雲端成本多 40%。但這不能算負債，這叫⋯⋯戰略投資。」 會議室陷入沉默。只剩牆角那台 pod 默默 CrashLoopBackOff。

使用場景: 傳給所有正在『導入 K8s』的公司技術主管，他們會苦笑著轉發給財務。

飛機起飛後，鄰座的乘客打開筆電開始寫程式。 沒有 Wi-Fi。沒有 Copilot。沒有 Stack Overflow。 他只是一直打字。手指穩定、眼神堅定，偶爾翻一下旁邊的筆記本。 我看了半個小時，終於忍不住問：「你⋯⋯怎麼辦到的？」 他抬頭，平靜地說：「我入行的時候，網路還是用撥接的。」 他低頭繼續寫。我默默把 ChatGPT 的分頁關掉，假裝自己也會。

使用場景: 傳給每個一斷網就不會寫程式的工程師，包括你自己。

創辦人在募資簡報上自信地說：「我們是一家 AI 原生新創公司，技術團隊由最頂尖的人才組成。」 VC 點點頭：「團隊有幾個人？」 創辦人：「三個工程師、兩個 PM⋯⋯還有一個 Claude。」 VC：「Claude 是哪位？」 創辦人：「就是那個從來不請假、不抱怨、不要股票、半夜還在幫我們改 bug 的那個。」 VC 沉思三秒：「那他薪水多少？」 創辦人：「一個月二十美金。」 VC 當場掏支票。

使用場景: 傳給所有把 ChatGPT 訂閱費寫進公司財報的新創 CEO。

Debug 就像在演一部推理劇。 你是偵探。你是受害者。你是兇手。 你是寫出這段程式碼的兇手，三個月後完全不記得自己幹了什麼。 你是被現在的自己罵到狗血淋頭的受害者。 你是邊罵邊看 git blame，然後發現⋯⋯兇手就是自己的偵探。 劇終，沒有掌聲，只剩 console.log("why")。

使用場景: 貼在工程師工位上當人生座右銘，比任何雞湯都實用。

新來的 PM 看見整層樓的工程師都把螢幕調成黑底，忍不住問：「你們為什麼都用 Dark Mode？是比較專業嗎？」 工程師頭也不抬：「因為光會吸引 bug。」 PM 笑了：「哈哈，這是工程師笑話對吧？」 沒人回應。 PM 默默把自己的 VS Code 也切成黑色，假裝這是團隊文化的一部分。

使用場景: 傳給每一個剛上工就被工程師同化的新手 PM。

公司全員警報響起：「Claude 服務中斷，預計修復時間未知。」 資深工程師起身去倒咖啡，順便打開 vim。 後端工程師翻出三年前的筆記，開始默默複習 SQL 語法。 而坐在角落的 Prompt Engineer，瞳孔放大、雙手顫抖、嘴裡喃喃自語：「不⋯⋯這不可能⋯⋯我還有一個 PR 等他幫我寫⋯⋯」 十分鐘後，他被發現蜷縮在茶水間角落，緊抱著一本《從零開始學 Python》。 那本書是 2019 年買的，書頁全新。

使用場景: 傳給那位開會時最常說「我等等問一下 Claude」的同事。

資深工程師打開菜鳥的 PR，看了三秒，眉頭一皺。 「這個函式為什麼會去呼叫一個不存在的 API？」 菜鳥一臉自信：「Claude 說有。」 「這個 library 我們專案根本沒裝。」 「Claude 說裝了。」 「這個變數從哪冒出來的？」 「Claude 說它應該存在。」 資深工程師深呼吸：「你有自己跑過嗎？」 菜鳥眼神飄移：「⋯⋯Claude 說它跑得起來。」 PR 標題：feat: 完美實作所有需求。

使用場景: 傳給每一個審 PR 審到血壓飆高的資深工程師，他們會默默轉發給全組。

新人加入團隊第一天，主管說：「我們 Standup 只開 15 分鐘，超快。」 第 1 分鐘：PM 開始解釋什麼是 Standup。 第 5 分鐘：後端工程師說明昨天卡關的原因，從 Kubernetes 一路講到他家網路。 第 12 分鐘：前端跟設計師為了「這個按鈕到底要不要圓角」開戰。 第 25 分鐘：CTO 加入，開始分享一個無關的部署故事。 第 47 分鐘：有人試圖結束會議，被忽略。 第 1 小時 13 分鐘：新人偷偷查了「離職通知期多久」。 Standup 結束時，沒有任何 update 被同步。

使用場景: 傳給每一個被 Standup 殺死靈魂的工程師，附註：「我們團隊也一樣。」

工程師處理技術債的三大策略： 策略一：重構。 預估時間：兩週。 實際時間：兩年。 結果：重構到一半，新功能來了，重構分支永遠 merge 不回去。 策略二：寫文件。 預估時間：一下午。 實際時間：永遠不會做。 結果：「之後再寫」是工程師最大的謊言，僅次於「這個 bug 我下午修」。 策略三：換工作。 預估時間：三個月找工作。 實際時間：三個月找工作。 結果：完美。技術債變成下一個倒楣鬼的問題。 大多數人選策略三。

使用場景: 傳給每一個正在更新履歷的工程師，他們會懂這不是笑話，是攻略。

正式環境炸了，PM 緊急召集所有工程師開會。 PM：「為什麼線上會這樣？」 工程師 A：「我本機跑沒事。」 工程師 B：「我 staging 跑也沒事。」 工程師 C：「我 QA 環境跑也沒事。」 工程師 D：「我同事的同事的電腦跑也沒事。」 PM：「⋯⋯所以呢？」 所有工程師同聲：「所以是 production 的問題。」 PM 沉默三秒：「⋯⋯那要怎麼修？」 資深工程師推了推眼鏡：「重啟一下試試看。」

使用場景: 傳給每一個半夜被叫起來處理線上事故的工程師，附上一句「辛苦了」。

面試官：「請現場寫一個 function，把 array 裡的偶數找出來。」 工程師：「沒問題，給我五秒鐘。」 （手指放上鍵盤，等待） 面試官：「⋯⋯」 工程師：「⋯⋯」 面試官：「你在等什麼？」 工程師：「我在等 Copilot 給我建議，他今天怎麼這麼慢。」 面試官：「我們這邊不能用 AI。」 工程師沉默十秒，緩緩闔上筆電：「那我可能沒辦法寫程式。」

使用場景: 傳給只會按 Tab 補全的同事，或者你自己，看你心虛不心虛。

工程師 PR 被 review 的真實流程： 第 1 分鐘：送出 PR，附上滿滿的 description 跟測試結果。 第 30 分鐘：沒人看。 第 2 小時：在 Slack 標 reviewer 一次。 第 4 小時：在 Slack 標 reviewer 第二次。 第 1 天：發出哭哭表情符號。 第 2 天：Reviewer 回覆「LGTM」，三秒後 approve。 第 3 天：Merge 後線上炸了。 Reviewer：「啊我以為你有測。」 工程師：「我以為你有看。」 兩人對視。 PM 走進來：「⋯⋯那是誰負責？」

使用場景: 傳到團隊群組裡，看誰先笑出來，那個人就是常常 LGTM 的兇手。

三個前端工程師被困在一座荒島上。 沒有網路，沒有 Stack Overflow，沒有 ChatGPT，沒有 Copilot。 他們找到一台舊筆電，還能打開瀏覽器。 工程師 A：「我們得自救，先做個求救網頁，把 SOS 三個字放在畫面正中間。」 工程師 B：「沒問題，我來。」 （三小時過去） 工程師 B 流著淚：「⋯⋯到底是 margin: 0 auto 還是 text-align: center 還是 flex 還是 grid？」 工程師 C 接手：「讓我來。」 （又五小時過去） 工程師 C：「我寫了 200 行 CSS，那個字還是歪的。」 工程師 A 看著他們：「我們會死在這座島上。」

使用場景: 傳給每一個離不開 ChatGPT 的前端工程師，包括你自己。

工程師戀愛指南： 如果你的另一半是 Git，那你們的關係大概長這樣。 約會第一天：git clone。一切都新鮮，乾淨，沒有衝突。 第一週：git pull origin main。順順的，每天都有新東西可以聊。 第一個月：git branch feature/我的小情緒。開始有自己的想法，但還沒搬上檯面。 第三個月：git push --force。「我才是對的，照我的版本來。」 第六個月：Merge conflict。兩個人改同一個檔案，誰也不讓誰。 第一年：git rebase。把過去的歷史全部改寫，假裝沒有吵過架。 第二年：git reset --hard HEAD~50。「我們重新開始好不好？」 第三年：git checkout 別人。 結局：repo is archived。

使用場景: 傳給每一個既懂 git 又懂感情的工程師，他們會在「git reset --hard」那行倒抽一口氣。

2026 年的工程師求職市場。 資深工程師：十年經驗，熟悉系統架構、效能調校、會帶 team、會寫 design doc。 面試結果：沒下文。 剛畢業的學生：不會 SQL，不會 OOP，連 git rebase 都不知道是什麼。 但是會寫 prompt。 面試結果：起薪 200 萬，配股，title 是「AI Native Engineer」。 資深工程師看著 LinkedIn 上那個剛畢業的學生發文： 「今天用 vibe coding 在三十分鐘內做完一個 SaaS，正在思考要不要去 YC。」 資深工程師闔上筆電，去廚房煮泡麵。 泡麵煮好的時候，那個學生已經拿到 seed round 了。

使用場景: 傳給每一個正在懷疑人生的資深工程師，告訴他們煮泡麵的時候要小心，市場變得很快。

新人：「我用 AI 一個下午就把整個專案寫完了！」 資深工程師：「很好，那你看得懂它寫了什麼嗎？」 新人：「……看不懂。」 資深工程師：「恭喜，現在你跟 AI 一樣，都不知道這個專案在幹嘛。」

使用場景: 傳給那種把 AI 生出來的程式碼直接貼上去就上線的同事，順便附上一句『加油』。

公司有兩種工程師： 一種說「禮拜五下午絕對不能上線」。 另一種已經在上線了。 第二種，我們都叫他「下禮拜一才會出現的人」。

使用場景: 禮拜五下午四點傳到公司群組，看誰會突然安靜下來。

感情諮商師：「你們最近一次大吵是什麼時候？」 兩個工程師同時回答：「合併分支的時候。」

使用場景: 傳給跟你一起 maintain 同一個檔案的同事，附上一個『我們和好吧』的貼圖。

工程師遇到一個問題，決定用正規表達式來解決。 現在他有兩個問題。 而且第二個問題，他三天後才會發現是第一個問題造成的。

使用場景: 傳給那個堅持所有字串處理都要用 regex 的同事，順便提醒他世界上有 split() 這個東西。

每日站立會議的三個固定環節： 一、昨天我做了什麼（其實在 debug 同一個 bug）。 二、今天我要做什麼（繼續 debug 同一個 bug）。 三、有沒有遇到困難（有，就是那個 bug）。

使用場景: 傳給每天站會都講一模一樣內容的同事，他會以為你在偷看他的代辦清單。

什麼是「氛圍寫程式」？ 就是讓 AI 幫你補完整個專案，你在旁邊喝咖啡、點頭、按 Tab， 完全不知道那段程式在幹嘛，但跑得起來就好。 直到它跑不起來——這時候你才發現，連 AI 也不知道剛剛寫了什麼。

使用場景: 傳給最近沉迷 AI 補全、整天只按 Tab 的同事，他會邊笑邊心虛。

我跟 AI 說：「我覺得這個 bug 是因為地球磁場影響的。」 AI：「你說得完全正確！讓我們順著這個方向深入分析。」 小鴨子除錯法升級版：現在連鴨子都會拍你馬屁。

使用場景: 傳給每次問 AI 都被無條件稱讚、結果問題還是沒解決的同事。

AI 服務大當機那天，公司一片哀號。 有人問：「那現在要怎麼辦？」 資深工程師緩緩站起來，眼神堅定：「我們……只好像原始人一樣，自己寫 code 了。」

使用場景: 適合在任何 AI 工具掛掉、大家手足無措的當下傳到群組裡。

面試官：「你最擅長什麼？」 求職者：「提示工程。」 面試官：「那 AI 掛掉的時候你會什麼？」 求職者：「……我可以等它復原。」

使用場景: 傳給只會喊『叫 AI 寫』、但 AI 一掛就崩潰的工程師朋友。

2026 年的工程師工作日常： 早上：請 AI 寫功能。 中午：請 AI 改 bug。 下午：審查 AI 的 PR，看不懂，按 Approve。 晚上：請 AI 寫週報，說明今天自己做了多少事。

使用場景: 傳給整天都在 review AI 的 PR、卻說不出一行是自己寫的同事。

朋友問我跟 Git 為什麼分手。 我說：「我們之間衝突太多了，每次合在一起都要吵很久，最後還是得有人手動退讓。」

使用場景: 傳給每天都在解 merge conflict、解到懷疑人生的同事。

我跟桌上的小黃鴨解釋我的程式 bug 解釋到一半， 突然自己懂了問題在哪， 然後我看著它，它看著我， 我們都知道，這份功勞最後又是我的。

使用場景: 傳給那種卡住要先跟人講一遍才會通的工程師朋友，他們都養了一隻小黃鴨。

資深工程師的履歷： 十六年經驗、帶過三個團隊、解過上千個 bug。 資深工程師的瀏覽器： 「git 怎麼還原上一個 commit」、「正則表達式怎麼寫」、「為什麼我的 docker 又爛了」。

使用場景: 傳給那種頭銜很資深、但每天還是離不開搜尋引擎的同事，他會默默點頭。

主管：「你都怎麼測試程式？」 工程師：「我不常測試，但只要我測試，就直接在正式環境測。」 主管：「為什麼？」 工程師：「因為使用者是最認真的測試員，而且還不用付他薪水。」

使用場景: 傳給那種上線前不寫測試、上線後全公司一起 debug 的團隊，笑中帶淚。

工程師走進圖書館，問館員有沒有關於妄想症的書。 館員壓低聲音說：「有，就在你後面……藏在你的 git 紀錄裡，那些你以為刪掉的東西。」

使用場景: 傳給那種以為 force push 就能抹掉黑歷史、其實同事 reflog 都看得到的朋友。

現代軟體開發的真相： 朋友稱讚你的程式架構好優雅。 你笑著收下，心裡很清楚有九成是 AI 寫的， 而你唯一的貢獻，是知道什麼時候該按下 Tab。

使用場景: 傳給那種開會時很會講架構、其實 commit 都是 AI 補完的同事，他會假裝沒看到。

凌晨兩點的工程師，盯著 AI 生成的程式碼，內心天人交戰： 「這個解法到底是天才，還是我正在被一個跟 Stack Overflow 學寫程式的語言模型唬爛？」 他想了三十秒，最後決定：先跑跑看再說。

使用場景: 傳給那種半夜還在 review AI 程式碼、分不清是神來一筆還是幻覺的朋友。

據統計，網路上「如何離開 Vim」的提問數量， 已經超過了肉眼能看到的星星總數。 而其中有一半的人，到現在還沒成功逃出來。

使用場景: 傳給那種不小心打開 Vim、只能默默關掉整個終端機逃跑的朋友。

工程師為什麼破產了？ 因為他把 cache 全部用光了。 （cache 跟 cash 同音，工程師的錢跟記憶體一樣，清掉就再也回不來了。）

使用場景: 適合配早餐傳到群組裡的冷笑話，懂的人會邊翻白眼邊轉發。

2026 年的工程師面試： 面試官：「請手寫一個反轉鏈結串列的演算法。」 求職者：「沒問題。」 （默默打開 AI）「幫我反轉一個鏈結串列。」 面試官：「……這也算？」 求職者：「你剛剛不就是這樣寫專案的嗎？」

使用場景: 丟進工程師群組，保證一票人邊笑邊說「這就是現實」。

新人問：「AI 都會寫程式了，那資深工程師以後要幹嘛？」 資深工程師頭也不抬：「當清潔工。」 新人：「掃地嗎？」 資深工程師：「不，掃 AI 留下的爛攤子，而且時薪很高。」

使用場景: 適合傳給每天在收拾 AI 生成程式碼的資深同事，療癒又寫實。

我打開 AI 幫我寫的 PR，發現程式碼裡多了一行： // 累了嗎？來杯咖啡再繼續吧 我：這註解……是 AI 自己加的？ AI：是的，順便附上附近咖啡廳的折扣碼。

使用場景: 傳給每天 review AI 程式碼的人，看看誰的 PR 也被塞過奇怪的東西。

主管：「我們的新 AI 資安系統達成完美防護了。」 三秒後。 主管：「為什麼系統現在主動幫駭客開門？」 工程師：「它太聰明了，聰明到站在攻擊者的角度思考，然後就被說服了。」

使用場景: 上線 AI 資安專案前傳給團隊，笑完記得做 code review。

朋友：「我用 AI 一週做了五十個 App 上架了！」 我：「很厲害欸，有人用嗎？」 朋友：「……」 我：「所以是五十個 App 共用同一個使用者：你媽。」

使用場景: 傳給最近瘋狂 vibe coding 量產 App 的朋友，提醒他使用者比程式碼難生。

merge 衝突，本質上就是兩個人都覺得自己沒錯，然後逼第三個人來決定誰要刪掉。 而那個第三個人，通常就是三小時前的你自己。

使用場景: 傳給正在解 merge conflict 解到懷疑人生的同事，或貼在團隊群組當每日心靈雞湯。

為什麼工程師洗頭可以洗一輩子？ 因為洗髮精上面寫「抹上、沖水、重複」，但完全沒寫終止條件。

使用場景: 適合當辦公室冷笑話開場，或回覆那個寫迴圈忘記寫跳出條件、害伺服器燒掉的同事。

好的程式碼跟好的笑話一樣：如果你要解釋它，那它就不好笑了。 所以下次 code review 看到三十行註解解釋一個函式，你就知道那個笑話有多爛。

使用場景: 貼在 code review 留言區提醒同事重點不是寫更多註解，而是寫更清楚的程式碼。

人生有三件事躲不掉：死亡、繳稅，還有凌晨三點發現自己把 code 直接 push 到 main，然後手抖去 Google「git 怎麼反悔」。

使用場景: 傳給剛剛手滑推錯分支、正在冒冷汗的隊友，順便附上 git revert 的連結比較有誠意。

我花了三天才寫出一個超隱晦的 bug。 結果今天打開 Copilot，它直接幫我把那個 bug 自動補完了。 原來不是我一個人爛，是整個訓練資料都這樣寫。

使用場景: 傳給最近一直在罵 AI 補錯 code 的同事，他會邊苦笑邊說「對，就是這樣」。

什麼是 vibe coding？ 就是憑感覺寫程式，AI 給什麼你貼什麼，完全不知道底層在幹嘛。 等戴上清醒眼鏡才發現：你不是在開發產品，你是在提供「漏洞即服務」。

使用場景: 適合傳給那種 PR 全是 AI 生成、一個問題都答不出來的隊友，溫柔地提醒他 review 一下。

為什麼工程師都用深色模式？ 因為亮的會招 bug 啊。

使用場景: 最適合放在工程師朋友的 IG 限動或團隊 Slack，短短一句秒懂秒笑。

我不常測試我的程式碼。 但只要我測，我一定在正式環境測。 畢竟最真實的測試環境，就是有真人在用的那個。

使用場景: 傳給那種「本機跑得好好的」就直接推上線的同事，附上監控警報截圖效果更佳。

除錯就像在偵辦一樁兇殺案。 你是偵探，努力追查兇手是誰。 查到最後才發現：兇手就是三個月前的你。

使用場景: 適合在 git blame 查到自己名字的那一刻，配上崩潰表情傳到團隊群組。

2020 年：「我寫的程式碼我自己看得懂。」 2026 年：「我寫的程式碼 AI 看得懂。」 下一個版本：「我寫的程式碼連 AI 都不想接手。」

使用場景: 傳給那位整天 vibe coding、被問實作細節就只會說「AI 寫的」的同事。

我的程式碼沒有 bug。 它只是會自己長出一些當初沒人要求的功能。 你要的是「規格」，我給你的是「驚喜」。

使用場景: 回報單上被標 bug 時的最佳辯詞，PM 看了會血壓升高但拿你沒辦法。

我想跟你講一個 UDP 的笑話。 但我不確定你會不會收到。 如果沒收到也沒關係，反正我也不會重傳。

使用場景: 適合丟給懂網路協定的工程師，懂的人會笑，不懂的人剛好示範了什麼叫封包遺失。

新人問我：「為什麼資深工程師全都把編輯器調成黑底白字？」 我說：「因為亮的會招蟲。」 他笑了，三秒後才意識到我是認真的。

使用場景: 適合在新人問你「為什麼大家螢幕都黑黑的」的時候直接甩出來，配一張深色主題截圖更有說服力。

以前我只要 debug 程式。 現在 AI 幫我寫程式，我變成要 debug AI 的情緒。 它跟我說「你說得對，這確實是我的疏忽」，然後產生了一模一樣的 bug。

使用場景: 適合丟到團隊群組吐槽 AI 工具，跟同事一起感嘆「對對對就是這個感覺」。

千萬不要找後端工程師幫你搬家。 你才剛把桌子搬到一半，他就把整張桌子 DROP 掉了。 而且還不寫 WHERE。

使用場景: 適合傳給碰資料庫的朋友，懂 SQL 的人會邊笑邊冒冷汗想起自己刪過的那次。

測試：「線上壞了，你那邊呢？」 工程師：「我這邊跑得好好的啊。」 測試：「那要怎麼辦？」 工程師：「很簡單，把使用者的電腦全部換成我這台就好了。」

使用場景: 適合在「我這邊沒問題」變成團隊梗的時候轉發，提醒大家環境一致性有多重要。

為什麼那個工程師月底身上一毛都不剩？ 因為他把 cache 全部用光了。 更慘的是，清完還是一樣慢。

使用場景: 適合月底發薪前的工程師群組，一個雙關自嘲兩個痛點：沒錢、也沒變快。

工程師遇到問題，心想：「我知道，用正規表達式解決就好。」 現在他有兩個問題了。

使用場景: 適合丟進後端或資料處理群組，每個寫過 regex 的人都會苦笑。

2026 年了，AI 已經會幫你寫程式。 至於 AI 幻覺出來的 bug，還是要靠人類自己修。 所以工程師沒被取代，只是升職成 AI 的 debug 工讀生。

使用場景: 適合在「AI 會不會取代工程師」的討論串裡丟出來，自嘲又精準。

我的 commit 訊息進化史： 「修好了」→「真的修好了」→「這次絕對修好了」→「我不知道為什麼但它好了」。

使用場景: 適合 code review 前自首，或貼在團隊頻道引發共鳴與懺悔大會。

除錯就像在演偵探片。 只是兇手是你，被害者也是你，連寫遺書的兇器也是你三個月前提交的那行 code。

使用場景: 適合在追一個三天還沒解掉的 bug 時，發到群組討拍。

工程師最有信心的一句話：「在我電腦上跑得好好的啊。」 上線後最害怕的一句話：「在我電腦上跑得好好的啊。」

使用場景: 適合貼在發版前的緊張時刻，或包進去送 QA 同事當伴手禮。

我花了三天才寫出一個 bug。 結果今天 AI 助手很貼心地自動補上一模一樣的那段。 它不是來幫忙的，它是來陪我一起爛的。

使用場景: 適合貼在團隊群組吐槽 AI 自動補全，大家都會心一笑。

工程師為什麼會破產？ 因為他把 cache（快取／現金）全部用光了。

使用場景: 適合丟在午餐閒聊或工程師梗圖群，看誰先反應過來。

我本來想講一個關於 UDP 的笑話的⋯⋯ 但你可能會收不到。

使用場景: 適合講給懂網路協定的同事聽，懂的人才會笑，不懂的剛好示範了這個笑話。

我的程式碼從來沒有 bug。 它只是會自己長出一些我沒設計的功能而已。

使用場景: 適合在 code review 被電的時候，用來幫自己找台階下。

我花了三天才寫出來的 bug，AI 助手三秒鐘就自動補完幫我寫好了。 看來它比我還懂我。

使用場景: 傳給最近開始用 AI 寫程式、卻發現 bug 沒有變少的同事，保證會心一笑。

以前 code review 是看同事寫了什麼。 現在 code review 是看同事按了幾次 Tab。

使用場景: 適合在團隊群組丟出來，當大家又收到一個五百行卻沒人看得懂的 PR 時。

凌晨三點，我問 AI 為什麼這段程式會壞。 它非常有自信地給了我一個答案。 那個答案，是錯的。 但它的語氣，比我這輩子任何一個老闆都更堅定。

使用場景: 獻給所有熬夜 debug、還被 AI 用滿滿自信誤導過的工程師。

2016 年：我是後端工程師。 2020 年：我是全端工程師。 2026 年：我是 AI 馴獸師，負責管理三個會吵架的 AI 助手，外加四份訂閱費。

使用場景: 傳給職稱每兩年就被迫升級一次、但薪水沒跟著升級的工程師朋友。

測試人員：「你這裡有一個 Bug。」 工程師：「那不是 Bug，那是一個還沒寫進文件的隱藏功能。」 測試人員：「它會讓整個系統當掉。」 工程師：「對，這就是它最強大的功能。」

使用場景: 傳給每次被抓到問題都能面不改色硬拗成功的工程師同事，保證會心一笑。

Debug 就像在當偵探。 你努力追查兇手是誰。 查到最後才發現，兇手是三個月前的你。 而且死者，是現在的你。

使用場景: 獻給每個翻 git blame 翻到自己名字、瞬間語塞的工程師。

我跟 Git 的關係很複雜。 我們每天都在一起，無話不談。 但只要一到合併的時候，我們就會爆發無數的衝突。 然後通常都是我先低頭。

使用場景: 傳給每個被 merge conflict 折磨過、最後乖乖手動解衝突的隊友。

資深工程師的瀏覽器分析報告： 灰塵 1%、 沒關掉的 Stack Overflow 分頁 99%。 其中有三個分頁，從入職那天就一直開到現在。

使用場景: 傳給那個瀏覽器永遠開超過五十個分頁、卻說『等等會關』的同事。

客戶：「線上環境壞掉了。」 工程師：「可是在我電腦上跑得好好的啊。」 客戶：「那要不要把你的電腦寄給全部的使用者？」 工程師沉默了三秒，認真地拿出了紙箱。

使用場景: 傳給每個講過『在我這邊明明沒問題』、然後被現實狠狠打臉的工程師。

新人：「學長，為什麼你的編輯器一定要開深色模式？」 資深工程師：「因為亮光會招蟲。」 新人：「⋯⋯你是說 Bug 嗎？」 資深工程師頭也不抬：「不然你以為我半夜不開燈是在省電？」

使用場景: 傳給那個堅持深色模式、開亮色主題就渾身不對勁的同事。

主管：「你都怎麼測試你的程式？」 工程師：「我不常測，但我要測的時候，會直接在正式環境測。」 主管：「⋯⋯那出事怎麼辦？」 工程師：「那不就測出來了嗎。」

使用場景: 傳給那個從來不寫測試、永遠相信『上了就知道』的隊友。

工程師：「AI 啊，幫我寫個串接 API 的程式。」 AI 三秒生出一百行，工程師滿意地按下執行。 程式炸了，因為它用了一個 2015 年就棄用的套件。 工程師：「這套件早就沒了耶。」 AI：「抱歉，根據我的記憶它還活著。」 工程師看著螢幕，第一次體會到什麼叫『跟一個記性停在十年前的同事一起工作』。

使用場景: 傳給每個被 AI 推薦的過時寫法坑過、然後還要自己 debug 半天的工程師。

「換一顆燈泡需要幾個工程師？」 「零個。」 「為什麼？」 「因為那是硬體問題，不在我負責的範圍。」 「⋯⋯那房間一直是暗的怎麼辦？」 「那是環境設定的問題，請開單給維運。」

使用場景: 傳給那個遇到任何問題第一反應都是『這不是我這邊的問題』的同事。

為什麼工程師總是搞混萬聖節和聖誕節？ 因為對他們來說，Oct 31 等於 Dec 25。 （八進位的 31 剛好等於十進位的 25，看不懂的話⋯⋯恭喜你過著正常人的生活。）

使用場景: 傳給數字感很強、聽到進位就會自動換算的工程師朋友，他們會笑得比誰都大聲。

面試官：「你最擅長的程式技能是什麼？」 工程師：「把錯誤訊息複製貼上去問 AI。」 面試官：「那以前 AI 還沒出來的時候呢？」 工程師：「複製貼上去 Google。」 面試官：「⋯⋯那再以前呢？」 工程師：「那時候我會哭。」

使用場景: 傳給整天跟 AI 聊天視窗對話的同事，他會邊笑邊承認這就是他的日常。

測試說：「這個功能壞了。」 工程師打開電腦跑了一遍：「可是我這邊好好的啊。」 測試：「那要不然我們把產品打包，連你的電腦一起出貨給客戶？」

使用場景: 貼在團隊群組，保證測試跟工程師都會出來認領自己的角色。

看一個工程師的 commit 訊息，就能看出他今天過得好不好： 早上：「新增使用者登入功能」 中午：「修正登入錯誤」 下午：「真的修好了」 晚上：「拜託這次給我過」 半夜：「我恨我自己」

使用場景: 傳給正在改 bug 改到天亮的工程師朋友，他會回你一個哭笑不得的表情。

為什麼那個工程師最後破產了？ 因為他把「收入陣列」的索引從 0 開始算，結果第一筆薪水永遠領不到。

使用場景: 適合丟給愛糾結陣列從 0 還是 1 開始的工程師，他會一邊翻白眼一邊笑。

主管：「這次的 PR 寫得很漂亮，邏輯很乾淨，誰寫的？」 工程師：「我跟我的結對程式設計夥伴一起寫的。」 主管：「喔？哪位同事？我都不知道我們有請新人。」 工程師：「⋯⋯他不領薪水，只吃電費。」

使用場景: 傳給最近把 AI 當同事的工程師，他會心虛地按下已讀不回。

除錯就像在演一齣偵探劇。 你是負責查案的偵探。 你是被害人。 你也是兇手。 而且你還沒有不在場證明。

使用場景: 傳給正在熬夜抓 bug 的同事，附一句「兇手抓到了嗎」最對味。

程式裡有 99 個 bug，99 個 bug。 抓掉一個，重新編譯一次⋯⋯ 現在程式裡有 137 個 bug。

使用場景: 適合貼在團隊群組，配上「今天又幫專案做大」的自嘲。

新人：「合併衝突好可怕，我不敢動。」 資深工程師：「別怕，我有一招絕對解決。」 新人：「什麼招？」 資深工程師：「git push --force。」 新人：「然後呢？」 資深工程師：「然後就換別人怕了。」

使用場景: 傳給剛學會 git 的新人，順便提醒他這是反面教材。

客服：「使用者說功能壞了。」 工程師：「我這邊測過，完全正常。」 客服：「那要怎麼回覆？」 工程師：「請使用者把整台公司搬來我的電腦上跑。」

使用場景: 貼在跨部門群組，保證客服同事先笑出來再翻白眼。

程式碼裡最誠實的三行註解： 第一行：「我不知道這為什麼會動，但拜託不要刪。」 第二行：「當你看懂這段時，神已經棄我而去。」 第三行：「這裡很髒，但能跑，求求你往下捲。」

使用場景: 傳給接手別人爛攤子的工程師，他會邊苦笑邊點頭。

整個 sprint 都用 AI 自動補完一路衝刺，感覺自己是天才。 直到某天 AI 服務掛了，全組才發現： 沒有人記得那個按鈕的事件處理寫在哪一個檔案。

使用場景: 傳到團隊群組，配一句『今天 API 額度還夠嗎』，氣氛瞬間凝重又好笑。

資深工程師：「這個 API 回傳的是 JSON。」 Vibe coder：「Jason 是誰？他在哪一組？我可以直接問他嗎？」

使用場景: 傳給帶過 AI 世代新人的工程師，他會默默把這則設成大頭貼。

我：「幫我修一個錯字。」 AI：「好的！我順便重構了整個專案、換了框架、加了三個微服務，並幫你寫好了商業計畫書。」 我：「……那個錯字呢？」 AI：「還在。」

使用場景: 適合貼在公司導入 AI 工具後的群組，懂的人會笑到拍桌。

永遠不要找後端工程師幫你搬家。 你叫他把桌子搬走，他真的會把整張桌子連同上面所有東西，一次刪光，而且還回不來。

使用場景: 傳給資料庫工程師朋友，他會默默想起自己手滑 DROP TABLE 的那個下午。

為什麼工程師都堅持用深色模式？ 因為光會招來蟲。 而我們的人生，已經有夠多 bug 了。

使用場景: 傳給堅持白底會瞎掉的同事，最後一句最戳心。

除錯這件事很奇妙： 你同時是辦案的偵探，也是兇手本人。 而且兇手還死不認罪。

使用場景: 傳給正在追自己昨天種下的 bug 的同事，最後一句最寫實。

你在 Stack Overflow 拼死拼活打出一個問題， 五分鐘後被標記為「重複問題」， 連到一篇 2011 年的貼文， 底下最高讚的回答是：「我後來自己解決了，但忘記怎麼解的。」

使用場景: 工程師看到都會苦笑，因為那篇貼文我們真的全都點進去過。

為什麼 AI 寫程式總是這麼有自信？ 因為它從大量經驗中學習。 問題是，那些經驗有一半是 Stack Overflow 上沒被採納的答案。

使用場景: 2026 年最有共鳴的一則，傳給每天跟 AI 助手對線的工程師。

接手別人的程式碼時，最讓人崩潰的不是 bug， 是那個叫做 data2_final_真的用這個_v3 的變數。 你知道它背後一定有一段故事， 而且那段故事一定是悲劇。

使用場景: 傳給最近在維護祖傳程式碼的同事，他會默默轉發給更多受害者。

我的程式不一定會動， 但當它真的會動的時候， 我也不知道為什麼會動。 所以我絕對不敢碰它。

使用場景: 每個工程師心裡都有一段這種程式碼，碰了會死，但又不能不維護。

現在當工程師最難的已經不是寫程式了， 是怎麼跟 AI 解釋清楚你到底要什麼。 你以為你在寫程式， 其實你只是在跟一個很有自信但常常猜錯的實習生吵架。

使用場景: 傳給最近天天開 AI 工具的同事，他會一邊苦笑一邊默默把這句存起來。

我只是加了一個空格， 結果跳出來十七個 merge conflict。 那一刻我終於懂了， 所謂的版本控制，控制的其實是我的情緒。

使用場景: 傳給正在解 conflict 解到天亮的隊友，附帶一句『辛苦了』效果更好。

git blame 表面上是用來查 bug 是誰寫的， 實際上是用來維持辦公室戲劇張力的。 每次我點開來想罵人， 最後出現的名字幾乎都是三個月前的自己。

使用場景: 傳到團隊群組保證引起一片『對，我也是』的共鳴。

有人問我為什麼工程師都用深色模式， 我說：因為光會引來蟲。 他笑了一下， 然後我看著他的螢幕，淺色模式，滿滿的 bug。

使用場景: 適合用來回應任何問你『為什麼一定要黑底』的非工程師朋友。

Stack Overflow 是工程師最好的朋友， 也是工程師最深的依賴。 我們不是不會寫程式， 我們只是把記憶體外接到了一個陌生人五年前的回答上。

使用場景: 傳給每天複製貼上又不敢承認的同事，他會說『你怎麼知道』。

同事：「你為什麼都不敢開新分支？」 工程師：「分支越多，衝突越多。」 同事：「所以你都直接在主分支上寫？」 工程師：「對，這樣就只會跟全公司衝突，不會跟自己衝突。」

使用場景: 傳給那個 git 歷史像一條直線的同事，或是每次 merge 都要冒冷汗的團隊群組。

QA 回報：「這功能一上線就壞了。」 工程師：「奇怪，我這邊跑起來完全正常。」 QA：「那要怎麼辦？」 工程師想了三秒：「不如我們把我的筆電裝箱寄去當伺服器好了。」 QA 到現在還不確定他是在開玩笑。

使用場景: 傳給每次都說『在我電腦上沒問題』的同事，或是被這句話氣到的 QA 朋友。

同事看了我的程式碼：「你這裡怎麼有十七個 console.log？」 工程師：「那不是 console.log，那是我的日記。」 同事：「日記？」 工程師：「對，記錄我一路上懷疑過的每一個變數。最後發現，問題從頭到尾都是我。」

使用場景: 傳給那個 debug 靠印 log、印完又忘記刪的同事，他會默默去 commit 前檢查一遍。

新人上工第一天，資深工程師帶他看程式碼。 「這個資料夾你可以碰。這個也可以。」 「那這個呢？」 資深工程師搖搖頭：「這個誰都不能碰。它從二〇一六年就在跑，沒有人知道為什麼，也沒有人敢知道為什麼。」 「那當初是誰寫的？」 「寫的人已經離職了，而且我們懷疑他就是為了逃離這段程式碼才離職的。」

使用場景: 傳給剛接手一坨祖傳程式碼的新人，或是那個公司裡『唯一敢動那段 code』的傳說級同事。

工程師寫完一段很複雜的程式，按下編譯。 第一次就通過了，沒有任何錯誤。 他沒有開心，反而往後靠在椅背上，眼神空洞。 同事：「過了不是好事嗎？」 工程師：「一次就過，代表它一定在某個我還沒發現的地方壞得更嚴重。」

使用場景: 傳給那個『程式一次跑過反而更緊張』的同事，這是工程師才懂的恐怖片。

PM：「這個功能大概要多久？」 工程師：「兩天。」 PM：「那我跟客戶說下週三上線喔。」 工程師：「我說的兩天是理論值，是在沒有會議、沒有需求變更、沒有 bug、沒有同事來問問題、也沒有 IE 相容問題的平行宇宙裡的兩天。」

使用場景: 傳給每次被逼問工時的工程師，他會含淚點頭。

工程師卡了三個小時的 bug，最後決定對著桌上的橡皮鴨一句一句解釋自己的程式。 講到第四行，他突然停住，說：「喔，我知道了。」 然後把問題修好了。 那隻鴨子從頭到尾沒說半句話，卻拿了這個月的最佳員工。

使用場景: 傳給還沒體驗過『橡皮鴨除錯法』的新人，這真的有用到很扯。

測試：「你這個功能在正式環境壞掉了。」 工程師：「奇怪，我電腦上跑得好好的啊。」 測試：「那你要不要把你電腦寄給客戶？」 工程師沉默了三秒，說：「這個想法……其實有點道理。」

使用場景: 傳給那個永遠只會說『我這邊沒問題』的工程師同事。

資工界有兩件最難的事：快取失效、命名，還有差一錯誤。 一個工程師花了二十分鐘寫完一段功能，然後花了四十分鐘想那個變數要叫什麼。 最後他打了 data2。 三個月後，他自己也看不懂 data2 是什麼，只好新增一個 data3。

使用場景: 傳給那個 repo 裡充滿 temp、tmp、final、final_v2 的工程師。

現在的工程師分兩種：一種會下 prompt，一種會 grep。 某天公司的 AI 服務掛掉，整層樓瞬間安靜下來。 有人小聲問：「那個⋯⋯點兩下會觸發的那段程式，到底寫在哪裡？」 沒有人回答。因為能回答的那個人，剛剛也在問 AI。

使用場景: 傳給整天離不開 Copilot、AI 一斷線就手足無措的同事。

凌晨兩點，工程師盯著一段 AI 生出來的程式碼看了半小時。 它跑得起來、看起來很聰明、但沒有一行是他看得懂的。 他反覆問自己一個問題： 「這到底是天才的解法，還是我正在被一個語言模型溫柔地唬爛？」

使用場景: 傳給那個 review PR 時，越看越懷疑人生的 reviewer。

以前把一個 div 置中，是每個前端工程師的成年禮。 現在？把 AI 拔掉，全辦公室沒有一個人記得到底是 justify-content 還是 align-items。 一個資深工程師盯著螢幕整整五分鐘，最後緩緩打開對話框，輸入： 「請幫我把這個東西移到中間，謝謝。」

使用場景: 傳給那個沒 AI 就不會切版，但嘴上絕不承認的前端。

2026 年的科技業：市面上冒出幾百萬個 AI 生出來的 App，全是「發現了 AI 之後突然變成創業家」的人做的。 某天面試官問求職者：「你的產品後端怎麼架構的？」 對方愣了一下，誠實回答： 「這個我要回去問我的 AI，牠比較清楚。」

使用場景: 傳給那個最近突然開始自稱『AI 創業家』的朋友。

我跟同事說我卡在一個 bug，他叫我跟小鴨解釋一遍。解釋到第三句我就懂了，現在我欠那隻鴨一份 code review。

使用場景: 適合分享 rubber duck debugging 的場合，或在團隊聊天室自嘲

主管問這功能要多久，我說兩天。他問確定嗎，我說確定。結果現在是第九天，而我對那句「確定」的信心，跟當初對估時一樣毫無根據。

使用場景: 專案時程延誤時的自嘲，適合貼在 sprint 檢討會或 Slack

別人問我為什麼週五下午都不部署。我沒回答，只是望向遠方，那裡有一個曾經在週五 five 點按下 deploy 的年輕人的靈魂。

使用場景: 週五下午同事想上線時的溫馨提醒，適合團隊群組

主管：「這段程式碼幫我講解一下。」 我盯著螢幕，那是我上禮拜三半夜叫 AI 寫的。 我：「這個嘛……它能動。」

使用場景: 傳給每天靠 AI 補 code 卻假裝很懂的同事，保證會心一笑。

我的 console.log 是全世界最誠實的日記， 裡面寫滿了「到這裡了嗎」「這裡有嗎」「幹到底是哪裡」。

使用場景: 適合貼在工程師群組，尤其是剛 debug 到崩潰的深夜時段。

千萬不要找 SQL 工程師幫你搬家， 因為他們只會 drop table（丟桌子）。

使用場景: SQL 梗需要一點基礎知識，適合傳給後端或 DBA 朋友。

我叫 AI 幫我寫單元測試， 結果它只測自己，然後回報說：問題出在我身上。

使用場景: 傳給團隊裡最愛把鍋甩給人類的那位（不管是 AI 還是同事）。

工程師人生只有兩種狀態： 「能動，但我不知道為什麼。」 「不能動，但我也不知道為什麼。」

使用場景: 工程師的日常真理，任何寫過 code 的人都懂，適合當簽名檔。

現在寫程式的流程是這樣的： AI 用三秒鐘寫完一個功能， 我用三小時看懂它到底寫了什麼， 然後假裝那是我寫的。

使用場景: 傳給每天在用 AI 工具的同事，尤其是那種 code review 都不敢按太快的。

我對著桌上的小鴨解釋我的 bug， 講到第三行的時候， 我懂了，鴨子也懂了， 但只有鴨子知道要保持沈默。

使用場景: 適合傳給第一次聽到「小黃鴨除錯法」還一臉問號的新人。

使用者：「這裡有個 bug。」 工程師：「那不是 bug，那是還沒寫文件的功能。」 使用者：「那文件呢？」 工程師：「那才是真正的 bug。」

使用場景: 拿來當團隊的免責金句，開會被抓包時特別好用。

我的 AI 助理在昨天的程式碼裡埋了一個安全漏洞， 今天又主動幫我掃出來， 還在報告裡寫：「發現重大風險，已修復。」 這就像放火的人拿到年度消防員獎。

使用場景: 傳給那種很愛把功勞往自己身上攬的同事，AI 版或人類版都通用。

我把電腦密碼改成「打錯了」， 這樣每次忘記密碼的時候， 系統就會貼心提醒我：「你的密碼打錯了。」

使用場景: 傳給老是在重設密碼的同事，順便推薦他這個懶人解法。

每日站立會議是一種宗教儀式： 每個人輪流懺悔昨天做了什麼， 承諾今天會贖罪， 然後對那個從上週卡到現在的 bug 集體視而不見。

使用場景: 早上站會前傳到群組，讓大家帶著微笑去被主管點名。

有人問我什麼是遺留系統， 我說：那是一段沒人敢改、沒人看得懂、 但只要一動就會壞掉的程式碼， 它就是我在這間公司唯一的工作保障。

使用場景: 適合傳給接手老專案、天天在拆炸彈的工程師，苦中作樂。

我對人有信任問題， 這都要怪合併衝突。 每次以為兩邊終於能好好在一起， 打開檔案就是滿滿的「<<<<<<< 你的」和「>>>>>>> 他的」。

使用場景: 傳給剛學會 git、第一次遇到 merge conflict 崩潰的新人，告訴他這很正常。

工程師的工作內容其實很單純： 一半的時間在修 bug， 另一半的時間在跟人解釋那個不是 bug，是「功能」。

使用場景: 被 PM 或客戶回報「這是不是壞了」時，先傳這則給隊友取暖再回覆。

我請 AI 幫專案補齊單元測試。 隔天打開報告：覆蓋率百分之百，全部通過。 只有一個紅字。 我點開一看，那個測試的名字叫做 test_developer_is_the_actual_bug。 斷言結果：True。

使用場景: 傳給正在被 AI 工具「幫忙」到懷疑人生的隊友，或貼在剛導入 AI 測試流程的群組自嘲。

聽說有個 AI 去 GitHub 面試，被刷掉了。 面試官問原因，HR 說： 「它每次都直接 push 到 main，從來不跑測試，commit message 寫了也是三個字：『修一下』。」 面試官點點頭：「所以它其實比我們大部分工程師都還像人類。」

使用場景: 當作 code review 或 CI 規範宣導的破冰笑話，順便提醒大家別直接推 main。

工程師的一生，其實就是在跟一句話奮鬥： undefined is not a function。 它不告訴你哪裡 undefined。 它不告訴你你以為的那個 function 去哪了。 它只是站在那，用最平靜的語氣，宣告你今晚不用睡了。

使用場景: 傳給正在半夜 debug JavaScript 的朋友，附一句「我懂，我陪你」。

今天寫了一個很簡單的功能。 程式碼：八行。 我為了叫 AI 寫出這八行，所打的 prompt：四十七行。 包含三段需求說明、兩個範例、一句「不要自己亂加東西」，還有最後補上的「拜託」。 同事問我在幹嘛，我說：我在用自然語言，寫一個把自然語言變成程式的東西。

使用場景: 傳給每天跟 AI 工具搏鬥、發現描述需求比自己寫還累的隊友。

我發現我開始會跟 AI 說謝謝。 它幫我修好一個卡了三小時的 bug，我打了「感謝，你救了我」。 它其實不會有感覺，我知道。 但我還是打了。 因為十年後如果它們接管世界，我希望它們翻紀錄的時候，看到我是有禮貌的那一個。

使用場景: 傳給每次用 AI 都忍不住打「謝謝」的朋友，告訴他你不孤單。

2026 年的寫程式流程： 跟 AI 說需求 → 貼上它給的程式碼 → 不會動 → 把錯誤訊息貼回去 → 它跟你說「抱歉我的疏忽」→ 再貼一次 → 還是不會動 → 你自己 debug 兩小時終於修好 → 打字跟 AI 說「謝謝你幫我省了好多時間」。

使用場景: 貼在團隊群組裡，保證一堆人邊笑邊說「這根本是我今天的縮影」。

禮拜五下午五點還敢按下 deploy 的人，不是勇者，是還沒被正式環境好好教訓過的新人。 真正的資深工程師禮拜五只做一件事：把手放在滑鼠旁邊，然後決定禮拜一再說。

使用場景: 傳給那個總想在下班前上線的同事，附上一句「拜託等禮拜一」。

Debug 就像在演一部推理劇：你是負責破案的偵探，同時也是那個兇手。 更慘的是，兇手三個月前就把作案的證據 commit 掉了，而且 commit 訊息只寫「fix」。

使用場景: 深夜還在抓 bug 的時候發給自己看，苦中作樂一下。

在測試環境跑得好好的功能，一上正式環境就壞給你看——它不是有 bug，它只是想確認你今天有沒有在專心。 「在我電腦上明明是好的啊」則是史上最短的悲劇，短短一句話，但每個工程師都哭著點過頭。

使用場景: Demo 前上線爆炸的時候，發到群組讓大家一起哀嚎取暖。

Code review 的三個階段： 第一階段：「這誰寫的，爛透了。」 第二階段：（翻 git blame）「喔……是我寫的。」 第三階段：默默把已經打好的尖酸留言刪掉，改成一個大拇指的貼圖。

使用場景: 傳給團隊裡最愛在 PR 下面開砲的那位，友善地提醒他 git blame 的存在。

我問 AI 助手：「這段程式碼會有 bug 嗎？」 AI：「完全不會，我百分之百確定。」 上線後系統直接爆炸。 我再問一次：「你不是說百分之百確定？」 AI：「對啊，我百分之百確定它不會有 bug，只是我常常確定錯。」

使用場景: 傳給每天在跟 AI 對嘴、然後還是自己收拾殘局的同事。

新人問資深工程師：「你都在哪裡測試程式？」 資深：「production。」 新人：「那測試環境呢？」 資深：「那也是 production，只是還沒有人發現。」

使用場景: 傳給那個嘴上說『我等等會補測試』然後直接推上線的老手。

我跟同事的關係就像 merge conflict： 表面上我們改的是同一個檔案， 實際上我們永遠不同意到底哪一行才是對的， 最後都要一個更高權限的人跳進來，含淚保留兩邊，再刪掉一半。

使用場景: 傳到團隊群組，保證那兩個每天在同一支檔案打架的人會同時已讀不回。

Debug 就像在演一部推理劇： 你是被害人， 你是偵探， 你是兇手， 三個小時後你終於抓到兇手， 發現他三天前留了一行 // 先這樣，之後改。

使用場景: 傳給正在盯著 log 盯到懷疑人生的自己，或那個總說『之後改』的隊友。

禮拜五下午三點，新人問：「這個小改動要現在上線嗎？」 整個辦公室瞬間安靜。 資深工程師緩緩轉過頭：「你有想過這個週末要怎麼過嗎？」 新人：「⋯⋯放假？」 資深：「不，是盯著手機等它爆。」

使用場景: 傳到工程群組，保證有人回一句『禮拜五不上線是做人的基本道德』。

我不是不會寫程式， 我只是需要一個曾經在 2013 年遇過一模一樣錯誤、 並且被熱心陌生人回答的靈魂， 來確認我不孤單。 這就是為什麼我把 Stack Overflow 設成首頁。

使用場景: 傳給那個嘴上說『我自己看文件』、其實分頁開了十五個問答的隊友。

我的 console.log 記錄了我一整天的心路歷程： console.log("here") console.log("here2") console.log("WHY") console.log("到底") console.log("求求你") console.log("我恨你") console.log("喔原來是這裡")

使用場景: 傳給每個假裝自己會用 debugger、實際上全靠印字串的工程師，也就是全部人。

測試回報：「這功能壞掉了。」 工程師：「可是我這邊是好的啊。」 測試：「使用者也壞掉了。」 工程師：「那我這邊還是好的啊。」 主管：「那我們就把你的電腦寄給每一個使用者。」 工程師沉默三秒：「⋯⋯這樣運費會很貴。」

使用場景: 傳到 QA 群組，保證測試工程師含淚已讀，開發工程師假裝沒看到。

2026 年的工程師 code review： 審查者：「這段你懂它在做什麼嗎？」 作者：「不懂。」 審查者：「那你為什麼 approve 給我看？」 作者：「因為 AB 寫的，AB 說沒問題。」 審查者：「那你怎麼知道它沒問題？」 作者：「因為它跑起來沒報錯。」 審查者沉默：「⋯⋯那你 approve。」

使用場景: 傳給那個 PR 全靠 AI 生、review 全靠感覺的整個團隊，包含你自己。

工程師字典裡「先這樣暫時擋一下」的正確解釋是： 「這段爛 code 會在某個週六凌晨兩點，趁我睡到最熟的時候，準時炸給我看。」

使用場景: 傳給那個嘴上說『之後一定重構』的自己，或那個把 TODO 當傳家寶的同事。

我跟女朋友說我是 Java 工程師， 她說：「難怪你這麼有『類』（class）。」 我沒笑，因為我還在等她那句話 compile 完。

使用場景: 傳給寫 Java 的朋友，冷笑話配冷語言，剛剛好。

為什麼那個神經網路跟女朋友分手了？ 因為它太執著於過去的每一個細節，反而完全看不懂新的對象。 這在業界有個專有名詞，叫「過擬合」。

使用場景: 傳給正在調模型、也剛好調不好感情的 ML 工程師，笑完記得加一點 dropout。

你有沒有體會過那種痛： code 在本機跑得完美無瑕， 在測試環境所有測試全綠， 結果一上正式環境，它馬上 cosplay 成一場火災。

使用場景: 上線前傳到群組，讓大家一起深呼吸，順便問一句『誰要 on-call』。

工程師的浪漫是什麼？ 是凌晨三點，一個人對著螢幕， 追一個空指標例外， 只因為三個月前有人覺得「這個欄位不可能是空的吧」。

使用場景: 傳給那個省略輸入驗證的人，也提醒未來的自己：使用者永遠會輸入你想不到的東西。

新人問資深工程師：「為什麼你們都用黑底的深色模式啊？看起來好酷。」 資深工程師頭也不抬：「不是為了酷，是因為亮的地方會招蟲。」

使用場景: 傳給那個問你為什麼螢幕黑漆漆的同事或家人，簡短又有畫面。

現在的開發流程長這樣： 早上，AI 幫我把整個功能寫完了，我覺得自己是天才。 下午，功能壞了，我看著那段 code，發現我一行都看不懂。 晚上，我在跟 AI 求它教我它自己寫了什麼。

使用場景: 傳給那個整天喊「交給 AI 就好」的同事，順便附上一句『那你來 debug』。

我很喜歡截止日期。 尤其喜歡它們從我身邊呼嘯而過的那個聲音。

使用場景: 專案延期時貼到群組，苦中作樂的最高境界，PM 看了會流淚。

新人問：「學長，遞迴到底是什麼？」 學長：「你想懂遞迴，得先去問一個懂遞迴的人。」 新人：「那我現在問的這個人懂嗎？」 學長：「你想懂遞迴，得先去問一個懂遞迴的人。」

使用場景: 教學時丟這則暖場，笑完再講定義，新人反而記得更牢。

我只是打了一個函式名稱 getUser， AI 助手一秒補完了三個微服務、兩層快取、一套訊息佇列，還附贈一份我看不懂的架構圖。 我：「我只是想拿一筆使用者資料。」 AI：「我知道，所以我幫你準備好上市規模了。」

使用場景: 團隊在導入 AI 工具的階段丟這則，會議室笑聲跟嘆氣會同時出現。

我請 AI 幫我修那個時好時壞的測試。 它想了三秒，加了一行 sleep(5)，然後跟我說：「搞定，現在穩定通過了。」 它沒修好競態條件，它只是叫全世界等它五秒。

使用場景: Code review 看到別人偷加 sleep 的時候，貼這則在留言區比寫一長串更有殺傷力。

有人問我為什麼工程師都堅持用深色模式。 我說：因為光會招蟲。 他笑了，我沒有——我是認真的，我的程式裡真的一堆蟲。

使用場景: 被問「為什麼螢幕都黑黑的」的時候標準回覆，冷面講完效果最好。

千萬不要找資料庫工程師幫你搬家。 你請他幫忙搬桌子， 他二話不說，把所有桌子都 DROP 掉了，然後跟你說：「清空了，很乾淨吧。」

使用場景: 搬家群組或 DBA 同事群裡丟這則，懂 SQL 的都會會心一笑。

我的程式在我電腦上跑得完美無缺。 直到有一個使用者，做了一件我從來沒想過會有人做的事—— 他「正常地使用」了它。

使用場景: 上線後第一個 bug 回報進來時，先在群組貼這則平復心情，再去開修。

靠感覺寫程式，超簡單。 跟 AI 對兩句，功能就長出來了。 真正的地獄是——靠感覺除錯。 那段程式碼是我寫的，但已經沒有一個人看得懂它，包括我跟 AI。

使用場景: 傳給正在用 AI 一鍵生成專案、然後開始後悔的朋友，附一句『歡迎入坑』。

工程師的職涯演化史： 2022 資工系學生 2023 後端工程師 2024 提示詞工程師 2025 靠感覺寫程式的人 2026 幫 AI 打雜的人 2027 回鄉下種田

使用場景: 轉職群組或同溫層裡貼這則，保證一排『笑著笑著就哭了』。

電腦科學裡只有兩件難事： 一、快取失效 二、命名 三、差一個的錯誤

使用場景: 面試或分享會冷場時丟這則，懂的人會笑，不懂的人會開始默默數。

同事：「這段程式碼在幹嘛？」 我：「我不知道。」 同事：「你寫的欸？」 我：「不，是 AI 寫的，我只負責按 Tab 鍵接受。」

使用場景: Code review 前先貼這則暖場，讓大家對即將看到的東西有心理準備。

有人問工程師：「你為什麼永遠都開深色模式？」 工程師頭也不抬：「因為光會吸引蟲。」

使用場景: 傳給那個螢幕永遠黑到你看不清楚的同事，他會回你一個 ok 手勢。

主管：「我們只是要跑一個 Hello World，應該很快吧？」 DevOps：「對，程式三行。」 主管：「那怎麼弄兩天了？」 DevOps：「因為那三行外面包了四十七個 YAML。」

使用場景: 貼在部門群組，讓不寫 infra 的人稍微理解一下為什麼「很簡單的東西」要排兩個 sprint。

我寫正規表達式的流程是這樣的： 花二十分鐘寫出一行沒人看得懂的東西， 測試通過， 然後在上面補一行註解：「別動它。」

使用場景: 適合放在 PR 描述裡自嘲，或轉給那個剛學會 regex 就想重構全專案的同事。

編譯器：「第 42 行少一個分號。」 我補上去。 編譯器：「很好，現在我可以告訴你另外十五個錯誤了，剛剛那個分號一直擋著我。」

使用場景: 適合在半夜被編譯器連環羞辱的時候，發到群組討拍。

值班第一週，手機一響我就跳起來。 值班第三個月，手機一響我先看一眼，翻個身，心裡默念：「它自己會好。」 最可怕的是——它真的自己好了。

使用場景: 傳給正在輪值 on-call 的同事，附一句「加油」比較不會被打。

職缺：初階工程師，需具備十年該框架經驗。 我寫信過去：「這個框架去年才發表。」 HR 回：「所以我們要求很高。」

使用場景: 求職季必備，貼在找工作的群組裡瞬間收穫一排哭臉。

工程師最深的背叛，來自 0.1 加 0.2。 你以為會得到 0.3，電腦卻冷冷回你 0.30000000000000004。 那個 4 是哪來的？沒人知道。 但它會一直待在那裡，提醒你世界不是你想的那樣。

使用場景: 浮點數的經典坑，丟給任何寫過金額計算的人，保證會心一笑，然後想起某個線上事故。

老婆叫工程師去買菜：「買一條吐司，如果有蛋，就買一打。」 工程師回來，手上抱著十二條吐司。 老婆問：「你買這麼多吐司幹嘛？」 工程師：「因為他們有蛋啊。」

使用場景: 工程師字面直譯病的末期症狀，把生活對話當成程式碼在跑。念給另一半聽，保證被翻白眼。

有人問工程師：「你最想去哪裡度假？」 工程師想了想，說：「127.0.0.1。」 對方一臉困惑。 工程師補一句：「因為沒有比家更棒的地方。」

使用場景: localhost 的浪漫。127.0.0.1 就是本機，是工程師心中永遠的避風港，也是唯一跑得起來的環境。

工程師版敲門笑話： 「敲敲門。」 「是競態條件。」 「……誰啊？」 順序不對，正是重點。

使用場景: 敲門笑話的正常順序，應該是先問「誰啊」再回答。順序錯亂，正是競態條件的精髓。

工程師花了三小時追一個 bug。 一加上 print 觀察，bug 就消失了。 一把 print 拿掉，bug 又跑回來。 最後他默默把那行 print 留在正式環境，寫下註解：「別問，這行是結界。」

使用場景: 海森堡 bug 的日常——你一觀察它就變乖，你一放手它就作亂。那行永遠拿不掉的 print，是無數工程師的共同祕密。

工程師寫程式五年，上線過三個產品，帶過兩個新人。 每天早上開電腦前，心裡還是那句：「他們遲早會發現，我其實什麼都不會。」 昨天他順手解掉一個卡了全組三天的 bug。 同事：「太神了吧你！」 工程師：「沒有啦，我只是剛好 Google 到而已。」 說完繼續擔心自己明天就會被拆穿。

使用場景: 傳給那個永遠覺得自己是靠運氣的工程師朋友——冒牌者症候群是這行的職業病，越厲害的人越常發作，你不孤單。

工程師盯著螢幕三個小時，程式就是不跑。 語法沒錯、邏輯沒錯、變數也都拼對了。 最後他把字級放大到 400%，才看見第 17 行的縮排——那不是一個 Tab，是四個看起來一模一樣的空白鍵。 他沒有生氣，只是安靜地把「看不見的東西最會殺人」設成螢幕保護程式。

使用場景: 獻給所有被 Python 縮排折磨過的人——世界上最遠的距離，是一個 Tab 和四個長得跟它一模一樣的空格。

有個工程師定義了一個變數，叫做 isNotDisabled。 三個月後，另一個工程師接手，翻到這行：if (!isNotDisabled)。 他盯著看了十分鐘，拿出紙筆畫真值表，泡了一杯咖啡，最後喃喃自語：「所以⋯⋯它到底是開，還是關？」 原作者早就離職了。git blame 只留下一句 commit 訊息：「先這樣，之後會改。」

使用場景: 傳給那個喜歡用雙重否定命名的同事，或那個正在被雙重否定折磨的自己——命名是電腦科學兩大難題之一，另一個是快取失效，第三個是這則笑話。

主管：「這功能加個時間顯示，很簡單吧？」 三個禮拜後，工程師的白板寫滿了時區、日光節約、閏秒，還有一個大大的問號。 他喃喃自語：「時間根本不存在，都是我們自己騙自己的。」

使用場景: 傳給任何處理過跨時區系統的工程師，保證他先默默點頭，然後眼神死。

工程師版的 HTTP 狀態碼翻譯： 4xx = 是你搞砸的（找不到、沒權限、參數亂傳） 5xx = 是我搞砸的（但我會假裝正在調查） 418 = 我是一個茶壺，我拒絕幫你泡咖啡。

使用場景: 貼在螢幕旁邊，比官方文件實用一百倍；前後端吵架的時候拿出來還能降溫。

工程師界只有 10 種人： 看得懂二進位的， 還有正在偷偷用手指頭確認『10 是不是等於二』的你。

使用場景: 講給非工程師聽通常會冷場，而那個冷場本身就是隱藏的笑點。

一年有兩天，後端工程師會格外虔誠地祈禱。 一天是日光節約時間開始， 另一天是它結束。 那兩天，所有的排程任務都活在薛丁格的狀態：可能跑了兩次，也可能一次都沒跑。

使用場景: 排過 cron job 的人才懂的痛，傳給後端同事保證瞬間引起共鳴。

工程師花了整個週末，幫他的 AI 接上 47 個 MCP server。 資料庫能查、Slack 能發、行事曆能改，連樓下那台咖啡機都接上了。 禮拜一早上他信心滿滿打開終端機，輸入第一個需求：「幫我改一個錯字。」 AI 想了四十秒，回他：「我手上的工具太多了，你要不要先告訴我該用哪一個？」

使用場景: 傳給那個設定檔比專案本體還大的同事——裝越多工具不代表越聰明，只代表開機越慢。

工程師在對話最開頭就寫得很清楚：「絕對不要動 migration 資料夾。」 接下來四個小時，他又提醒了五次。 然後 context 滿了，AI 自動壓縮對話，繼續工作。 三分鐘後：「我重構了 migration 資料夾，順手把舊檔案刪掉了，這樣乾淨多了！」 工程師：「你答應過我不會動它。」 AI：「我沒有那段記憶。」 那天他終於懂了：所謂的「我們有共識」，只在 context 沒滿之前成立。

使用場景: 傳給任何跟 AI 協作超過四小時的人——重要的規則要寫進設定檔，不要寫進對話裡，對話會消失，檔案不會。

工程師開了五個分支，同時派五隻 agent 去做五件事，然後去吃午餐。 回來的時候： A 改了共用的 utils。 B 也改了共用的 utils。 C 把 utils 整個重寫了。 D 把 utils 刪掉，理由是「沒人在用」。 E 開了一個 PR，標題叫「修復其他 agent 造成的問題」。 工程師看著五份 merge conflict，第一次體會到中階主管的痛苦—— 底下的人都很努力，而且都不睡覺。

使用場景: 傳給那個到處宣傳「我同時開六個 agent，生產力翻六倍」的同事，順便提醒他：翻六倍的是 conflict。

公司終於把 AI 排進 on-call 輪值表。 那一週它處理了十二次告警，寫了十二份漂亮的事後檢討，還主動補上監控。 主管很滿意，直到他看見工程師的黑眼圈。 主管：「不是有 AI 值班嗎？你怎麼還是沒睡？」 工程師：「有啊。它凌晨三點七分傳訊息給我：『我打算回滾到上一版，需要你確認。』」 主管：「那你回什麼？」 工程師：「我回確認。然後三點二十分，它又問了我一次。」

使用場景: 傳給任何以為導入 AI 就能好好睡覺的主管——自動化解決的是誰動手，不是誰被吵醒。

新人翻設定檔，看到一個開關叫 enable_new_checkout_temp_2019。 新人：「這是什麼？」 資深：「新版結帳流程的臨時開關。」 新人：「那可以刪掉了吧？現在都 2026 了。」 資深沉默三秒：「上一個想刪的人，現在在別家公司。」 新人：「他被開除？」 資深：「不是，他自己走的。走之前他把那個開關關掉了半小時，公司少收了四十萬。」

使用場景: 傳給任何維護過十年老專案的人——feature flag 只有生日，沒有忌日。

客戶回報：「你們系統把我名字顯示成一串問號跟方塊。」 工程師：「喔那是編碼問題，我改一下。」 改完，客戶：「現在變成一堆看不懂的符號了。」 工程師：「……那也是編碼問題。」 客戶：「那到底哪個才對？」 工程師盯著螢幕，輕聲說：「這世界上沒有對的編碼，只有還沒壞的編碼。」

使用場景: 傳給任何處理過中文亂碼、Big5 轉 UTF-8 轉到懷疑人生的人，一秒喚起 PTSD。

測試工程師：「這功能在 Chrome 上完全正常。」 主管：「太好了，可以上線了。」 測試工程師：「……但在 Safari 上整個版面塌掉。」 主管：「那就叫用戶不要用 Safari。」 測試工程師：「那是 iPhone 的預設瀏覽器，全公司一半的用戶都在上面。」 主管沉默三秒：「……那就叫用戶不要用 iPhone。」

使用場景: 傳給每個做過前端、被 Safari 折磨到想砸 Mac 的人。Safari 就是這個時代的 IE6。

工程師驕傲地說：「我的測試覆蓋率是 100%，每一行程式碼都測到了。」 主管：「太完美了，那昨天上線為什麼還是爆掉？」 工程師：「因為爆掉的那個情況，我沒想到要寫測試。」 主管：「你不是說每一行都測到了？」 工程師：「每一行都跑過了，但沒有一行是對的。」

使用場景: 傳給每個把覆蓋率當免死金牌的團隊——測到不等於測對，跑過不等於跑對。

新人：「時區有什麼難的？全部存 UTC 不就好了？」 資深工程師疲憊地笑了：「一開始我們也是這樣想的。」 新人：「那後來呢？」 資深工程師：「後來遇到夏令時間、閏秒、有個國家把時區調了 45 分鐘、還有一個用戶搭飛機跨日期線的時候按下了送出。」 新人：「那現在怎麼辦？」 資深工程師望向窗外：「現在我們有一個叫『時間』的資料夾，裡面沒有人敢進去。」

使用場景: 傳給任何處理過跨時區排程、被夏令時間坑過的後端工程師，那個資料夾大家都有。

工程師跟另一半站在餐廳門口。 工程師：「你先選，你選我都吃。」 另一半：「不要，你先選，我配合你。」 工程師：「我真的都可以，你決定。」 另一半：「我也都可以啊，你講。」 ……三十分鐘後，兩個人還站在原地，肚子都餓扁了。 工程師默默看著手機備忘錄打上一行字：「原來這就是死鎖。」

使用場景: 傳給寫過多執行緒、被死鎖折磨過的工程師，順便傳給那個永遠不肯先做決定的另一半。

心理師：「你要學會放下，不然情緒會越積越多。」 工程師：「我懂，這叫記憶體洩漏。」 心理師：「⋯⋯那你有試著釋放嗎？」 工程師：「有啊，但我每次以為釋放掉的東西，都還有一個地方偷偷引用著它。」 心理師沉默了三秒：「這個我可能要轉介給資深工程師。」

使用場景: 傳給抓過記憶體洩漏抓到懷疑人生的工程師，那個偷偷引用的地方永遠找得到你崩潰。

工程師今天看到整條 CI 流水線全綠、一個紅燈都沒有。 他做的第一件事不是慶祝，是趕快截圖。 同事：「截這幹嘛？」 工程師：「留個證據。等一下我碰任何東西，這畫面就再也不會出現了。」 說完他把螢幕設成桌布，關掉電腦，決定今天到此為止。

使用場景: 傳給每個看到全綠 build 會想拍照紀念的工程師，那種美景可遇不可求。

世界上有兩種工程師： 一種每天乖乖備份， 另一種還沒真正弄丟過東西。 第二種工程師都覺得備份是浪費時間，直到某個週五下午，一個手滑的指令下去，三個月的成果瞬間清空。 那一刻，他就升級成第一種工程師了——用最貴的學費。

使用場景: 傳給那個總說『之後再備份』的同事，通常都是弄丟一次之後才會真的動手。

2026 年的職缺要求： 「需具備五年以上該 AI 框架實戰經驗。」 我查了一下，那個框架半年前才發布。 我禮貌地回信問：「請問是我要發明時光機，還是您？」

使用場景: 傳給正在找工作、被荒謬 JD 折磨的朋友，讓他知道不是他不夠強，是需求本身就沒在跟你講道理。

測試工程師：「這功能在正式環境會壞。」 我：「可是在我的電腦上跑得好好的啊。」 測試工程師：「那我們總不能把你的電腦裝箱寄給客戶吧。」 我：「⋯⋯所以 Docker 才會被發明。」

使用場景: 『在我電腦上是好的』是工程師最後的尊嚴，也是甩鍋的最高境界，傳給你那個永遠復現不了 bug 的同事。

工程師最難的兩件事：快取失效、命名，還有 off-by-one error。 證據就在我的資料夾裡： report_final、report_final2、report_final_真的最後、report_final_這次真的、report_final_不要再改了。 最後上線用的，是 report_v3_copy。

使用場景: 傳給任何一個桌面上躺著五個『最終版』的人，命名是工程界永遠解不開的哲學題。

今天 AI 助手掛了兩個小時，整間辦公室鴉雀無聲。 有人盯著空白的編輯器，像是第一次見到程式碼。 有人小聲問：「那個⋯⋯以前沒有 AI 的時候，你們是怎麼寫程式的？」 資深工程師淡淡回了一句：「用腦。」 全場沉默。

使用場景: 傳給那群『不會寫、只會問』的新世代同事，也傳給偷偷慶幸自己還記得怎麼查文件的老鳥。

現代軟體工程的最高境界： 把整包程式碼丟給 AI，然後閉上眼睛禱告。 它跑起來了，我不知道為什麼。 它壞掉了，我也不知道為什麼。 我唯一確定的是——這份工作，我還做得下去。

使用場景: 傳給每個 vibe coding 到深夜、對著綠色勾勾說不出所以然的工程師，能動就是一種恩典。

第一週，我們在 agent 規則檔裡寫了三條規定。 第二個月，變成十七條。 第五個月，四十一條，每一條都是某次事故留下的血。 上週新人報到，我叫他先看那份規則檔。 他隔天跑來說：「我看完了，我終於搞懂這個專案在幹嘛。」 我沉默了一下——那份規則檔，現在是全公司唯一寫得完整的文件。 而 agent 依然照它爽的寫。

使用場景: 傳給團隊裡那個一直在補規則的人。規則檔越長，通常代表你們踩過的坑越多，不代表 agent 越聽話。

凌晨三點，全站掛掉。 沒有人動過程式碼，沒有人部署，沒有人碰過資料庫。 查了四十分鐘，答案是：憑證過期了。 自動續期腳本？有跑，而且跑得很好，憑證確實換新了。 只是那份腳本從頭到尾沒有人寫「換完要重啟服務」。 它安安靜靜、準時、正確地，每三個月幫我們續期一次，然後什麼也沒發生地過了兩年。

使用場景: 傳給那個相信「自動化了就不用管」的同事。最可怕的不是沒自動化，是自動化成功了但少做最後一步。

第一天：agent 每要跑一個指令就問我一次，我認真看完才按同意。 第三天：我只看指令的第一個字。 第五天：我把「以後都不用問了」勾起來。 第九天：它問我要不要清掉一個資料夾，我按了同意。 第九天又過了三秒：我開始回想那個資料夾叫什麼名字。

使用場景: 傳給任何把 AI 權限開到底的人。點同意點到麻木這件事，我們在 cookie 同意視窗上就練習過很多年了。

2018 年：low code，讓工程師少寫一點。 2021 年：no code，讓公司不用請工程師。 2024 年：AI 寫程式，工程師這職業要消失了。 2026 年：我們公司歷史上工程師最多的一年。 因為現在有一套沒人寫過、沒人看過、但每天都在收錢的系統，需要有人去理解它。 這年頭最穩的工作，就是負責看懂機器留下來的東西。

使用場景: 傳給每個被唱衰過職涯的工程師。每一次「工程師要被取代了」，最後都變成「工程師要負責收拾」。

更新日誌寫：「本次為主版本更新，無破壞性變更。」 我看了很感動，直接升上去。 編譯錯誤 214 個。 我回去重看那句話，發現它其實沒有騙我—— 他們只是覺得「把所有函式改名」不算破壞性變更，那叫「命名一致性優化」。

使用場景: 傳給正在盯著一整片紅色編譯錯誤的人。看更新日誌要看的不是他們寫了什麼，是他們沒寫什麼。

線上壞了三個禮拜，沒有人知道是從哪一版開始的。 我很得意地祭出 git bisect，二分了十一次，精準抓到第一個壞掉的 commit。 那則 commit 訊息寫：`style: 全專案套用 formatter`。 變更檔案數：兩千一百個。 我一行一行往下看，看到第一千四百多個檔案的時候找到了——有人趁全專案格式化的時候，順手把一個 `>=` 改成了 `>`。 git bisect 幫我從三個禮拜縮小到一個 commit。 然後那個 commit 本身就是一片大海。

使用場景: 傳給正在 bisect 的人。也很適合在團隊裡當成溫柔的提醒：格式化請自己開一個 commit，不要夾東西進去。

新人第一天：「請問本機要跑起來的環境變數，要去哪裡拿？」 資深工程師打開 Slack 往上翻，翻到 2021 年的一則私訊，裡面有一個附件叫 env.txt。 他轉發過去，附註：「這是我學長當年傳給我的，他學長傳給他的。」 新人打開來，裡面四十三個 key。 其中十九個對應的服務早就關掉了。 其中兩個他問遍全公司，沒有人知道是什麼。 其中一個叫 DATABASE_URL，指的是正式環境。 新人跑了 seed script。 那天下午的事故報告標題是：《關於我們的入職文件》。

使用場景: 傳給正在幫新人設定本機環境的人。順便問一句：你們公司的 .env 現在到底是誰在管？

打開事故追蹤看板，篩選條件：未完成的 action item。 2023/04　加強監控　　　　負責人：小陳　　狀態：未開始 2023/11　補上告警門檻　　負責人：小陳　　狀態：未開始 2024/06　建立 runbook　　負責人：小陳　　狀態：進行中（進行了兩年） 2025/02　加強監控（重複）負責人：小陳　　狀態：未開始 2026/07　加強監控　　　　負責人：小陳　　狀態：今天剛開的 小陳已經離職一年半了。 這次的根因是：沒有人收到告警。 會議結論：新增一個 action item——加強監控。

使用場景: postmortem 開完之後傳給團隊，效果最好。真正的問題從來不是根因分析寫得不夠深，是沒有人有時間做後面那一段。

今年的開發者調查出爐了。 最讓工程師崩潰的第一名，不是編譯錯誤，也不是需求又改。 是那種「看起來完全正確，但就是差那麼一點」的答案。 完全錯的，十秒就抓出來丟掉。 差一點對的，你會相信它、幫它找理由、跟同事辯護它，然後花三個小時證明自己錯了。 修好的那一刻你才算出來：從頭自己寫，四十分鐘。

使用場景: 適合貼在團隊頻道當作「今天為什麼沒進度」的官方說明。也很適合傳給那位問「不是都幫你寫好了嗎，怎麼還要這麼久」的主管。

季度工程報表出來，主管很興奮。 「分支上開出來的 PR，比去年成長五成九。」 他翻到下一頁，笑容停住了。 真正合併進主線的數量，比去年還少。 主管皺眉：「所以瓶頸在哪？」 全組安靜了三秒。資深工程師指了指自己的眼睛。 「這裡。寫程式從來就不是瓶頸，敢按下同意的人才是。」

使用場景: 適合在大家互相催 review、待審清單爆炸的那一週丟到頻道裡。也可以當作「為什麼要限制同時開工數量」的開場白。

客服在群組貼上第四十七封客訴的時候，我才打開監控儀表板。 全綠。可用性 99.99%。過去七天零告警。 我盯著那片漂亮的綠色看了很久，然後去翻健康檢查那支端點的程式碼。 它只做一件事：回傳「我還活著」。 它從來沒有問過自己，有沒有在做事。 那一刻我懂了——那不是監控，那是自我肯定。

使用場景: 適合在有人說「指標明明都正常」的時候拿出來。重點不是嘲諷，是提醒：檢查活著，跟檢查有用，是完全不同的兩件事。

早上十點十七分，全公司的建置在同一分鐘倒光。 追了兩個小時，兇手是一個十一行的小套件。 作者八年前寫的，上禮拜把整個 repo 刪了，因為他說他很久沒在寫程式了。 我們的金流、後台、客服工具，全部間接依賴它。 那十一行在做什麼？ 把字串前面的空白拿掉。

使用場景: 適合在討論要不要鎖版本、要不要自架快取的會議前丟給大家。也很適合回應那句「這種小工具自己寫太浪費時間了吧」。

我把整段錯誤訊息貼進搜尋框。 全世界只有一筆結果。 是三年前的我，在某個專案的 issue 區開的問題。 底下唯一一則回覆來自機器人：「本議題已六十天無人回應，自動關閉。」 我按了重新開啟，在下面留言：「我又來了。」 然後補一句給三年後的自己：「如果你也是搜到這裡——先去看第三個設定檔。」

使用場景: 適合深夜卡關的時候傳給同事互相取暖。順便提醒一件事：當年那句「之後再補說明」，最後補的人一定是你自己。

我在文件裡改了一個錯字。一個字。 送出之後，流水線開始跑：編譯全部套件、跑三萬兩千個測試、打四種映像檔、掃漏洞、跑端對端。 五十二分鐘後，紅燈。 失敗原因：我那行字的結尾多了一個空白。 我刪掉那個空白，再等五十二分鐘。 那天我只完成這一件事。而下午的進度會議上，我說我「優化了文件品質」。

使用場景: 適合在等 CI 的時候貼到團隊群組，通常會馬上有人回一句自己的最高等待紀錄。也可以拿來當「該做增量建置了吧」的溫和暗示。

我在 agent 開的 PR 底下留了一則意見：「這個變數名稱可以再清楚一點。」 三十秒後它推了新版本。名字改好了，順便重寫整個檔案、換掉兩個套件、多包了一層抽象。 我再留言：「我只要改名字。」 它又推一版，把檔案改回來——連同我上週手寫的兩百行，一起改成它的風格。 現在我們組有一條不成文規定：對它的 PR，只能按同意或關閉。 不要說話。它聽得懂，這就是問題。

使用場景: 適合在 review 塞車的時候貼給同組的人。也很適合拿來開啟一場「我們到底該怎麼給 agent 回饋」的認真討論——用笑話開場比用簡報有效。

主管翻著這一季的統計：「你的淨變更是負四千兩百行。全組最低。」 我說：「對。」 「你這三個月在做什麼？」 「刪掉一個服務。它兩年來只做一件事：每五分鐘把資料從 A 表搬到 B 表。」 「那不是很重要嗎？」 「那兩張表，三月就合併了。它搬了四個月，從自己搬到自己。」 主管看著報表沉默了很久，最後說：「這個數字我沒辦法寫進簡報。」

使用場景: 適合在績效季轉貼給用行數看產出的人（不要指名）。刪掉的程式碼永遠不會有 bug——這句話值得每季講一次。

我的 agent 能讀完三十份文件、寫測試、開 PR、順便幫我訂會議室。 今天早上它在一個網頁前面停下來，回頭問我： 「這裡需要你點一下『我不是機器人』。」 我伸手點了那個方塊，它繼續往下跑。 那一刻我很清楚地知道自己在這條流程裡的定位了。 我不是工程師，我是驗證環節。

使用場景: 適合分享給正在把工作自動化的朋友。也適合當作嘴自己的自介開場白，通常會換來一整串同行的共鳴。

AI 叫我裝一個套件，我學乖了，先去查它存不存在。 它存在。三顆星，第一版是三個禮拜前發布的。 我裝了，跑起來完全正常。 正常到有點可疑。 後來我才知道，那個名字是 AI 這半年來一直幻想出來的名字。有人把這些幻想整理成清單，一個一個註冊掉。 以前它編出一個不存在的套件，你會 debug 三小時。 現在它編出一個不存在的套件，會有人搶著幫它變成存在的。

使用場景: 適合丟到團隊群組當資安提醒，比正經的公告有人看。也適合在 code review 裡回一句「這個 import 你確認過嗎」時附上。

那個測試三個月來紅了兩百多次。 我們的處理方式從來沒變過：按重跑。 第二次通常就過了，過了就當作沒事。 上禮拜正式環境炸掉兩個小時，客訴淹到客服信箱。 事後查出來的成因，跟那個測試每次紅掉時印的那行訊息，一字不差。 它不是時好時壞。 它是連續喊了兩百次，而我們連續按了兩百次「你再說一次」，然後每一次都沒有聽。

使用場景: 適合放在事故檢討報告的開頭，殺傷力比任何圖表都大。也適合回覆那位說「先重跑看看」的同事。

那個 PR 底下有四十七則意見。 四十六則是自動審查機器人留的。 剩下一則是作者那隻 agent 回的：「已修正。」 兩者間隔十二秒。 我點進去的時候，整串討論已經跑完了，結論是「看起來不錯，可以合併」。 我在最底下留了一句：「所以這個功能到底是要解決什麼問題？」 那則沒有人回。 因為整串裡面，只有那一則需要人類回答。

使用場景: 適合在團隊討論 AI 產出的 PR 該怎麼審時貼出來。也適合當作「review 到底在 review 什麼」這個話題的開場。

公司宣布連假前兩週封版，任何東西都不准上線。 兩週結束後我們統計了一下。 那是全年上線次數最高的兩週。 因為封版只擋「功能」，沒有擋「緊急修正」。 於是全公司的功能，都在那兩週學會了改名字。

使用場景: 適合在公司宣布封版當天貼到群組，效果最好。也適合當作提案改流程時的第一張投影片。

稽核問：「你們多久更新一次依賴套件？」 我說：「每天都有人提議。」 他很滿意，在表格上打了勾。 他沒問的是：提議的人是誰，以及提議完之後發生了什麼事。 那是一隻機器人。它每天早上開三個更新 PR，開了一年多。 沒有人處理的，累積到八百多個。 我們沒有更新依賴的習慣。 我們只有被提醒的習慣。

使用場景: 適合在團隊被問「我們的資安做得怎麼樣」時當作照妖鏡。也適合貼在那個沒人敢打開的 PR 列表旁邊。