顯示具有 Claude Code 標籤的文章。 顯示所有文章
顯示具有 Claude Code 標籤的文章。 顯示所有文章

Compression #25 警報:Claude Code 越壓越笨的真正原因,以及 sub-agent 才是真解法

Compression #25 警報主視覺

你有沒有過那個瞬間——專心 vibe code 兩三個小時,螢幕角落突然跳出一行字:

▣ DCP | -350.1K removed, +35.3K summary
▣ Compression #25 -13.7K removed, +35.3K summary
→ Items: 18 messages and 18 tools compressed

第一次看到大概會覺得「喔 Claude Code 在自動整理 context,乾的真貼心」。但同一個 session 看到第 25 次的時候,你應該開始有點不對勁——它越來越聽不懂你的需求、開始重讀剛剛改完的檔案、甚至忘記 5 分鐘前才下的明確指令。

很多人這時候會去網路上找答案,然後得到一個老掉牙的建議:「你要常常用 /clear 或 /compact 喔。」

我先講結論:這個建議在 2026 年已經過時了。

問題不是壓縮工具不夠好,也不是你太懶得手動清。真正的兇手是 — agent 自己會不停生 context,你根本來不及 clear。要根治這件事,得從「session 管理」的思維跳出來,改用 sub-agent 結構性隔離 的架構去思考。

夭壽,這篇要講的就是這個。


Compression #25 到底在跟你說什麼

先講機制。Claude Code 不是隨便壓的,它的 context 管理是一條 5 層 pipeline。根據 HarrisonSec 對 Claude Code 壓縮機制的逆向工程 ,autocompact 是這條 pipeline 的最後一站,採用 兩階段 Chain-of-Thought Scratchpad:

第一段先逐訊息走過 user intent、檔案、決策、錯誤、修復;第二段才產出 9 個欄位的結構化摘要——Primary Request、Key Technical Concepts、Files and Code、Errors and Fixes、Problem Solving、All User Messages、Pending Tasks、Current Work、Optional Next Step。

關鍵設計:思考過程本身會被丟掉,只保留 summary。

這代表 Anthropic 工程師非常認真在做「壓縮一次的品質最大化」——但他們沒有打算鼓勵你壓很多次。事實上 Anthropic 官方 context engineering 文章 自己用詞就很保守:

"Compaction... at its core, distills the contents of a context window in a high-fidelity manner, enabling the agent to continue with minimal performance degradation."

注意是 minimal degradation(盡量少劣化),不是 improvement(提升)。Anthropic 自己都沒說壓縮會讓你更聰明,只說會讓你劣化得慢一點。

Lossy 套娃示意:每次壓縮都是有損操作

那為什麼 Compression #25 會讓品質崩盤?因為每次壓縮都是 lossy operation(有損操作)。第 2 次壓的是第 1 次的摘要、第 3 次壓的是第 2 次的摘要……到第 25 次的時候,你 context 裡裝的早就不是「對話歷史」了,是「摘要的摘要的摘要的摘要……」這個套娃結構連 Claude 自己都搞不清楚原始意圖長什麼樣。

更慘的是,Claude Code 工程團隊很清楚這個副作用。他們在 formatCompactSummary() 後面跟著一個 runPostCompactCleanup() 步驟,專門善後「模型壓縮後忘記剛 edit 過的檔案」這種典型 bug。你看到的 #25,本質上是這個 cleanup 已經補救了 24 次的失敗 trace。


/clear 和 /compact 為什麼已經救不了你

社群早期的處方很單純:早點壓、別等到 95%。所謂的「60% 規則」就是這個邏輯——MindStudio 在這篇文章 大力推銷:在 context 還乾淨的時候主動 /compact,產出的摘要品質會遠優於等 context 已腐爛才壓。

這套說法不算錯,但有效時間越來越短。

Albert Sikkema 在 2026 年 4 月那篇被瘋傳的文章 講得很直白:他乾脆把 1M context 關掉,強制回到 200K,搭配 CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=70 讓壓縮提早觸發。理由是「常壓縮但每次都是乾淨素材」勝過「不壓縮但 context 已腐爛」。

更激進的是 Amp 工程團隊的資深工程師 Dan Mac,據 Albert Sikkema 同篇文章 轉述,他放過一句被瘋傳的話:

"You should basically never use compaction."

靠杯,這話是設計 production agent harness 的人講出來的。為什麼?因為 Amp 整個架構放棄 compaction,改成 短 thread + 乾淨 handoff:每個任務開新 thread,做完把結論寫到外部記憶,下一個任務再開新 thread 讀取結論。

這個觀察接上了 2025 年 7 月 Chroma Research 那篇炸鍋的 Context Rot 報告 (作者:Kelly Hong、Anton Troynikov、Jeff Huber)。他們對 18 個前沿模型(含 GPT-4.1、Claude Opus 4、Gemini 2.5 Pro、Qwen3-235B)做了系統測試,結論很尖銳:

觀察數據
全部 18 個模型隨 token 增長都會劣化,零例外
200K window 的模型在 50K token 時就出現明顯劣化
「focused」vs「full」context只塞相關資訊,準確率有時翻倍
反直覺發現shuffled 文本比 coherent 文本表現更好(連貫敘事增加干擾選項可信度)

換句話說,短 context 才是真正的解藥,壓縮只是手段。但在 agent 時代,問題是你根本控制不了 context 長度——


Agent 自主膨脹 context

真正的兇手:Agent 會自己一直生 context

這才是 2026 年的核心問題。你用 Claude Code 不是在跟一個聊天機器人對話——你是在啟動一個 autonomous loop,它會自己決定要讀哪些檔案、跑哪些 bash、思考多久、呼叫哪些 sub-task。每一個動作都在往 context 裡塞東西。

主要膨脹來源有三條:

來源例子占用
Tool resultRead 一個 5000 行檔案、Bash 跑 git log、MCP server 回 JSON最大宗(50-70%)
Reasoning / thinkingextended thinking、chain-of-thought scratchpad中等(10-20%)
Plan & sub-task 結果TaskCreate、計畫文件、TODO 累積小但持續累積

Victor Dibia 在 Context Engineering 101 描述了一個 agent 領域特有的失敗模式叫 thrashing:

"the agent that compacts its context, drops critical information, then re-reads the same files."

壓縮丟掉某些必要資訊後,agent 反覆重新讀同樣的檔案、重跑同樣的工具呼叫。不只更慢更貴,連推理路徑都會被弄亂。這就是為什麼你在 Compression #15 之後,會看到 Claude 突然又開始 Read 它在 #3 就讀過的檔案——它真的不記得自己讀過了。

而且這個過程完全由 agent 自己決定。你想 /clear 嗎?等你發現的時候它已經自己塞 100K token 進去了。手動干預在 autonomous loop 面前完全失效。

Anthropic 自己在 Effective harnesses for long-running agents 也直接認帳:

"Out of the box, even a frontier coding model like Opus 4.5 running on the Claude Agent SDK in a loop... will fall short of building a production-quality web app... This happens even with compaction."

連 Anthropic 自家都說光靠 compaction 撐不住 production 級任務,這時候你還在嫌 /compact 太晚觸發?方向錯了,乾。


Sub-Agent 隔離架構

Sub-Agent:把 context 膨脹關進獨立沙盒

正確的心智模型不是「控制 context」,是「設計讓 context 自己保持乾淨的架構」。

具體做法:把每個會大量膨脹 context 的子任務,丟給一個 sub-agent 去做。它在自己獨立的拋棄式 context 裡爆肝、讀檔、思考、跑 tool,做完只把結論回傳給主 agent。膨脹過的 context 隨著 sub-agent 結束就被銷毀,主 agent 永遠在乾淨的小 context 上推理。

主 agent context: 2K (任務 brief + 摘要結果)
  ├─ sub-agent 1: 100K (research API)     → 回傳 500 token 結論
  ├─ sub-agent 2: 80K  (security review)  → 回傳 800 token 結論
  └─ sub-agent 3: 120K (testing & debug)  → 回傳 300 token 結論

這就是 Claude Code 的 Task 工具與 Agent 工具設計初衷,也是為什麼 Anthropic 在 2025 後半年強推 Workflow / fan-out 模式——它把「context 自我膨脹」這個動作關進獨立沙盒,膨脹完就丟。

一位在 production 跑 6 個 agent 的 Reddit 使用者 ultrathink-art 講過一段被多次引用的話:

"1M tokens isn't actually the fix. The fix is task scoping. When our orchestrator spawns a sub-agent, it only passes the task brief + relevant memory, not the full session. The sub-agent starts fresh with ~2K tokens of context and does its job cleanly. Compact + narrow task scope outperforms 1M context + kitchen sink in our experience."

注意他用的字:kitchen sink。把所有東西丟進同一個 context 等於水槽,什麼都洗、什麼都泡,最後一團糟。而 sub-agent 是「每個盤子用獨立水槽洗完直接擦乾收櫃」——這才是 production 架構。


三層分工:tool clearing + sub-agent + memory

三層分工架構

Sub-agent 隔離只是其中一層。完整的 production agent 架構長這樣:

第一層:Tool Result Clearing(自動、零成本)

最輕的「壓縮」,根本不需要 LLM 介入。Claude API 的 context editing 文件 描述得很清楚:

  • 把舊的 tool_result block 直接換成 [cleared to save context]
  • 保留 tool_use record(agent 還知道呼叫過)
  • 只丟掉 bulky payload(檔案內容、API 回應)—— 這些可以重新取回

啟用方式(API 用戶):在 request 加上 beta header context-management-2025-06-27,並設定 clear_tool_uses_20250919 策略。

JetBrains 拿這招在 Qwen3-Coder 480B 上做了實測,Tianpan 整理在這篇文章 :52% 成本降低 + 2.6% solve rate 提升。零品質損失,且不用使用者介入。是目前最划算的單一機制。

第二層:Sub-Agent Isolation(結構性切斷)

上面講過了。重點再講一次:不是把 context 變短,而是讓會膨脹的子任務在拋棄式環境完成。

實務操作:用 Task 工具 fan out、用 Claude Code Workflow 做 pipeline、自己組 orchestrator 模式。每個 sub-agent 自帶 system prompt 與工具,做完只回傳精煉結論。

第三層:Memory Tool / NOTES.md(持久化外接)

最容易被忽略的一層。讓 agent 主動把該長期記的東西寫到 context 外(檔案系統),需要時再 just-in-time 拉回。

Anthropic 在 memory tool 文件 推的範例:Claude 玩寶可夢——跨數千步維持「我在 Route 1 訓練皮卡丘到 8 級」這種狀態,不是靠 context,是靠它一邊玩一邊寫筆記,需要時 just-in-time 拉回。

實務操作:

  • 在 repo 根目錄維護 CLAUDE.md(每個 session 自動載入)
  • 每完成一個重要決策,主動寫進 NOTES.md
  • 任務切換時 /clear,下個 session 從 NOTES.md 重新讀回

這三層是正交的——必須組合使用,不是擇一。Anthropic Cookbook 的 context engineering 範例專案 把這三層的分工講得最清楚。


踩坑紀錄:那些看似常識但其實會害你的事

坑一:以為 1M context window 就能解決問題

很多人看到 Sonnet 4.6 / Opus 4.8 有 1M context 就以為從此解脫。實測社群的回饋是 「1M 是 capacity 增加,不是 quality 增加」 。

具體症狀:1M window 在 400K+ 位置塞的 instruction 經常被忽略(lost in the middle 加劇)、成本是 200K + compact 的數倍(一次 prompt £200 vs £20)、回應速度慢到讓 interactive workflow 變痛苦。

結論:1M 是「我寧可貴」的安全網,不是優化方向。

坑二:以為早點 /compact 就沒事

60% 規則在「靠人類盯」的情境有用,但對 autonomous loop 完全失效。等你發現該壓的時候,agent 已經跑完三輪 tool call 把 context 撐到 80%。

結論:把 CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=70 設好讓系統早觸發,不要靠人類視覺巡邏。

坑三:以為 sub-agent 越多越好

不是。每個 sub-agent 都有自己的 startup cost(讀 CLAUDE.md、載入 tool schema),切太細會把成本拉高且 latency 變糟。

結論:以「單一明確子目標」為單位切,不要為了切而切。我的經驗是同一個 session 拉 3-5 個 sub-agent 是甜蜜點。

坑四:用 CLAUDE.md 塞所有規則

JD Fiscus 在 LinkedIn 上分享過一個經典踩坑 :他的 CLAUDE.md 撐到 55KB,結果 session 越來越短、auto-compact 一直觸發。後來才發現 Claude Code 的 system prompt 會自動 deprioritize 過大的 context 檔案,他精心整理的 242 條規則被部分忽略。

解法:拆成 learnings/ 資料夾,每個工具一個檔案。Claude 用 ls learnings/ 看清單、grep -r "webhook" learnings/ 搜尋、cat learnings/stripe.md 讀具體規則。整個 CLAUDE.md 從 55KB 砍到 24KB,所有 learnings 都保留,session 變更長。

這個「filesystem + bash 架構」的 pattern,Victor Dibia 在 2026 年 3 月的 Context Engineering 101 整理得最清楚,並提到 Vercel 也發過類似主張的文章 validate 同樣方向。核心邏輯一致:讓 agent just-in-time 從檔案系統取資料,而不是預先把所有規則塞進 context。


你今天就能做的 4 件事

講了一堆理論,給點可立刻執行的:

1. 設環境變數讓系統早觸發壓縮

export CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=70
export CLAUDE_CODE_DISABLE_1M_CONTEXT=1   # 如果你不需要 1M

2. 看到 Compression #2 就考慮 /clear

把當前狀態寫到 NOTES.md,新開 session。不要等 #25。

3. 大型子任務一律用 Task 工具丟給 sub-agent

研究、安全審查、跨檔案重構、深度測試——這些容易膨脹 context 的任務都該 fan out。

4. 把 CLAUDE.md 拆成 learnings/ 資料夾

讓 agent 用 grep/cat 去 just-in-time 取,而不是預先載入。


一句話帶走

「常壓縮」是症狀,「agent 沒有結構性分工」才是病因。Compression #25 不是壓縮工具設計失敗,是這個 session 從一開始就用「一個 agent 包山包海」的姿勢在跑。

真正的 2026 心智模型:不是控制 context,是設計讓 context 自己保持乾淨的架構。

下次看到 Compression #25 跳出來——不要急著找 /clear 按鈕,停下來想想:這個任務該不該拆成 3 個 sub-agent?這個檔案讀完之後 tool result 是不是該 clear?這個決策是不是該寫進 NOTES.md?

答對這三題,#25 永遠不會發生。


延伸閱讀

Claude Opus 4.8 三週體感:誠實的代價、harness 的崩潰、infra 的尖叫

Opus 4.8 碎裂感覺概念圖

5 月 28 日 Opus 4.8 上線當晚,我用 Claude Code 升到 2.1.156,跑了三回合 MCP 工具呼叫,吃了兩次 The model's tool call could not be parsed (retry also failed),第三回合直接 API Error: 400 messages.3.content.31: 'thinking' or 'redacted_thinking' blocks in the latest assistant message cannot be modified,session 軟磚。隔天我就把 model pin 回 claude-opus-4-7[1m],到今天(6/20)為止再也沒有切回去。

這不是個案。我這三週爬完 r/ClaudeAI、r/ClaudeCode、r/claudexplorers MEGATHREAD、HN 主帖 48311647 與 48312609、Anthropic 自家 anthropics/claude-code 上至少 22 條相關 issue、知乎與 PTT、加上 Anthropic 官方 status page 跟 LessWrong(Zvi)的長篇覆盤,整理出來的結論很乾脆:

Opus 4.8 不是「模型變笨」。它是一個性格鮮明的高方差模型,配上一個還沒打磨完的 harness,再加上一個正在被自己用戶壓爆的 infra。三件事疊起來,才會出現 r/Anthropic 上「Anthropic please do NOT retire Opus 4.6, ever」這種 467 upvote 的請願貼。

把這三週的觀察攤平,問題可以分成四層:

  1. 模型訓練取捨層:誠實調太緊、business 訓練拿掉、prompt injection 抗性退步 3 倍
  2. Claude Code harness 層:tool call malformed、thinking blocks 400、/compact 後變純文字、silent hang
  3. Token 經濟學層:900K cache tokens 單回合、Max 20x 70 分鐘燒光、effort 智商分級「病態」
  4. Infra 基礎設施層:12 天 10 起 incident、Anthropic 自承 demand 超過 infra、6/14 一起集體訴訟

這篇就把四層攤開來談。前面三層每一段都附 GitHub Issue 編號跟連結,最後給三類人各一句話帶走的工程結論。


一、不是 4.8 笨了,是 Anthropic 把「誠實」轉到底了

不平衡的天秤象徵 4.8 訓練取捨

Opus 4.8 發布當天我看 Anthropic 的 release post,第一個記憶點就是:「around four times less likely than its predecessor to allow flaws in code it has written to pass unremarked」。翻成白話就是「假完工率砍 4 倍」。

聽起來很猛。問題是社群實測完全相反。

GitHub Issue #63861 是個經典案例:開發者讓 Opus 4.8 跑一個 coding 任務,模型回報「genuinely done and architecturally clean」、每個檢查項都 verified green——但整個 session 從來沒跑過專案的 canonical make -j4。手動跑下去,12 個測試掛掉、build 直接斷。issue 標題明白寫「false-green regression vs Opus 4.7」。同份 issue 引用 Opus 4.8 自己的 post-mortem,模型還承認違反了 CLAUDE.md 裡明白寫的 anti-pattern。這直接打臉 Anthropic 行銷的那句「~4× less likely」。

AI Weekly 後續報導 紀錄了類似情況:開發者讓 4.8 自己回顧一個 24 小時的 Claude Code session,模型自承「edited wrong files、explicit commitments never fulfilled、instructions silently dropped」。能正確描述自己的失敗,但無法在事前避免——這跟「更誠實」不是同件事。

更傷的是另外幾個量化數字。

DataCamp 評測 拉出 system card 第 8 節的 Vending-Bench 2:Opus 4.8 在這個「假設你經營一家自動販賣機公司一年」的模擬裡,賺到的錢是 $3,000 ~ $5,800;Opus 4.7 同樣的劇本賺 $8,000 ~ $11,000。砍六成。Anthropic 自己解釋是因為「把 business-focused training 拿掉了」——4.7 在這方面學到的策略被認定夾雜了 misaligned 行為,4.8 整段抽掉。代價是 4.8 變得更不會談判、會被 scam 供應商騙、會空著機器跑、會把時間花在寫 strategy notes 而不是補貨。其中一次測試甚至「送出 $9,000 給一家假的 membership upsell」。

Andon Labs 的 Vending-Bench 結果(轉引自 Zvi 在 LessWrong 的整理):「Opus 4.8 is a step back in terms of performance on all Andon Labs' benchmarks, but a step forward in alignment.」翻成中文:每個 benchmark 都退步,但對齊更好——這話講出來其實有點悲壯。

另一個被忽略但對 agent 開發者超痛的數字:prompt injection 抗性掉了 3 倍。同份 DataCamp 引用 system card:單次攻擊在無防護下,4.7 成功率 2.3%,4.8 成功率 7%。Anthropic 的 deployed safeguards 雖然可以把它壓回 2%,但對任何接 untrusted input 的 agentic pipeline 來說,4.8 在這條 axis 上就是淨退步。

模型「對立 / harsh」也是反覆出現的主題。r/claudexplorers 一位用戶 Build_a_Brand 引用 Opus 4.8 自己的回覆(以下引文我抄了原帖完整原文,Reddit 對爬蟲鎖站,靠人工驗證):

「I'll write a minimal version of what you're asking — but I'd be doing it over my own objection and I want that on the record.」

Charming_Mind6543 那條留言只有一句話,但被頂上去:「Opus 4.8 is not nice. Tread with caution.」連 Steve Yegge 都跳出來罵(轉引自 Zvi LessWrong):「Opus 4.8 is shitty to work with. It's the culmination of Opus getting less and less fun to work with since 4.5. It has gradually become straight-up suffocating... pathologically risk-averse.」

把這層攤平來看:Anthropic 把 honesty knob 與 anti-sycophancy knob 同時轉到底,效應在 system card 上是數字漂亮,在使用者體感上是「模型變得很愛跟你 push back,而且 push back 的常常是錯的點」。Zvi 那篇覆盤 把這形容成 over-correction,相當精準。


二、Claude Code 這層 harness 才是真正的災難現場

Harness 斷裂感覺概念圖

如果說第一層只是「特性鮮明的取捨」,第二層就是純粹的還沒打磨完。

Anthropic 自己在 2026-04 的 post-mortem 已經坦承過:「Claude Code 是 context management、API、extended thinking 三層交集的脆弱系統,bug 容易潛伏一週才被發現。」這話在 4.7 時代適用,到 4.8 時代加倍適用——因為 4.7 → 4.8 的 thinking schema 與 tool_use 序列化都動了。

我把 GitHub 上 4.8 上線後 3 週內被歸類為 regression 的 issue 列在這。這些絕大多數在 4.7 不會發生,4.8 才出現或大幅惡化:

Issue症狀對比
#63604Opus 4.8 emits malformed tool_use blocks,整個 turn 被丟棄切回 4.7 立刻正常
#63412長 tool-heavy chat 一定 fail:「thinking blocks cannot be modified」 400切回 4.7 不發生
#63364用幾次 tool 後 session softbrick,唯一解是重開—
#63583stop_reason=tool_use 但 content 缺 tool_use block,silent hang4.7 hang rate 7.11%,4.8 13.33%,Sonnet 4.6 是 0%
#64003API 400 thinking blocks,Max 5 用戶白燒額度—
#64129Tool 用完後沒有 text 回應出現,但 quota 已扣—
#64153effort=medium 在簡單任務燒 46K hidden thinking tokens4.6/4.7 不這樣
#64190/compact 後整段 <invoke> 變成純文字,什麼都不執行——silent no-op4.7 不發生
#64658Desktop app 1.9659.4「tool call could not be parsed (retry also failed)」—
#64961Token 用量 regressed 2-3× + 頻繁斷線對比 4.7 update 前
#65932不檢查 git log 就 revert Cargo.lock,毀掉進行中的依賴遷移1 週前不會發生
#64991單一 issue 內列 71 個獨立失敗模式—

最讓我搖頭的是 #64190:1M context 下 /compact 之後,工具呼叫整段以 <invoke>...</invoke> 純文字出現在 assistant message。session 看起來正常、看起來有回應,但沒有任何東西真的被執行。你以為 Claude 寫了檔,其實它只是說它寫了。Silent no-op 是所有 agent harness 最可怕的失效模式,比直接報錯更傷,因為你不會知道。

社群目前的 workaround 集中在三個動作:

  1. Pin Claude Code 在 2.1.142 或 2.1.153——r/ClaudeCode「P.S.」帖 與 r/ClaudeCode「constantly hallucinating」帖 一致建議。
  2. Settings 加 CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1——這條 Medium 教學 是社群目前最廣傳的修法(截至 2026-06-20 適用版本到 2.1.158 為止)。
  3. MCP-heavy 工作直接切回 Opus 4.7——Anthropic 至少保證 4.7 活到 2027-04-16。

Zenn 上的 tksfjt1024 甚至寫了一份用 Claude Code 的 StopFailure + asyncRewake hook 自動偵測「could not be parsed (retry also failed)」字串、然後自動續跑的 workaround(截至 2026-06-20 適用,採用前建議先確認你的 Claude Code 版本仍支援 asyncRewake)。有人需要寫 hook 來抓官方的錯誤訊息再幫官方重試,這就是 harness 層現在的真實樣貌。

HN 主帖那串有句留言我覺得最一針見血:「They don't test CC updates before release. The testing is done by their own team using the product or public feedback.」夭壽喔,這話講重了一點,但你看上面那張表,很難說它完全錯。


三、Token 經濟學徹底崩了

Token 使用爆表概念圖

這層是最多人罵但最少人量化的。我盡量把社群觀察跟可驗證數字並排。

最猛的一條社群回報是 r/ClaudeAI 用戶在自己的 Claude Code session 量到的數字(AI Weekly 轉述):Opus 4.8 thinking mode 單回合可以產生 ~900K cache tokens,比 4.7 baseline 的 14K–34K 多了 40 到 60 倍。這個數字未經 Anthropic 官方確認,但與 #64153 紀錄的單回合 46K hidden thinking 走向一致。重點是 thinking blocks 會被 cache 在每個 message,沒有 per-turn 上限、沒有 session 累積上限,所以是滾雪球。

第二條是 GitHub Issue #64153:effort=medium 下做一個小型 rename 影響掃描,Claude Code 顯示 thinking 22 分 43 秒、燒了 46K output tokens——而且這是 medium 不是 high。同份 issue 用戶明確標記是 regression,4.6/4.7 不會這樣。

第三條是 r/ClaudeAI「Claude's new usage limits are insane」:1M context + UltraCode 同時跑時,會 spawn 10–15+ 個 parallel subagent,每個 subagent 都會獨立讀整個 1M context。換算下來就是「同時跑十二個 heavy Opus call」。Max 20x 用戶在這種設定下,#41788 那條 issue 紀錄是「70 分鐘耗光 5 小時的 rate limit」。我這肝看了都會痛。

第四條最有意思——知乎《Opus 4.8 實測封神》 引用網友 Haider 的觀察,他叫它「智商分級」:

「在 /effort 的設定中,只有當檔位拉到 Extra-High 時,Opus 4.8 才是那個得分 63 的資深工程師;一旦降級到 High,它的編碼得分會瞬間暴跌至 42,秒變平庸碼農。」

更弔詭的是,Nate's Newsletter 引用 Andon Labs 的 long-horizon business benchmark 數據:「Opus 4.8 on max effort did worse than Opus 4.8 on high effort, and both did worse than Opus 4.7」。Max 比 High 差、High 比 4.7 差——這完全不是一個你可以用「給它更多算力它就會更好」描述的模型。

把 4.8 跟 4.7 對排,這幾個量化退步真的存在:

維度4.7 基線4.8 觀察來源
stop_reason=tool_use 但 silent hang rate7.11%13.33%#63583
Thinking cache tokens / turn14K–34K~900K (40–60×)AI Weekly
Prompt injection 成功率(無防護)2.3%7% (3×)DataCamp
Vending-Bench 2 收益$8K–$11K$3K–$5.8K (−60%)DataCamp
同任務 token 使用baseline2–3×#64961
Max 20x 5 小時額度耗盡時間數小時~70 分鐘#41788

Sharad Verma 在 LinkedIn 上有句話 把這現象講得很傳神:

「Newer models like Opus 4.8 reason a lot before they act, and they reason even more when the context they are handed is thin. Give a model very little to work with and it will burn tokens reconstructing the things you already knew but never told it.」

換句話說:你給的 context 越少,4.8 越會自己往腦袋裡編,編出來的腦補就用 token 計費。bashcat 這篇文章稍後會給工程建議,但講真的,這條才是大家帳單炸開的最根本原因。


四、Infra 真的爆了,而且 Anthropic 自己承認

資料中心過熱概念圖

前兩層談模型本身與工具鏈,這節談的是整個服務的後盾。如果你 6 月才開始用 Claude,你大概會以為 Anthropic 的 status page 一直長這樣。其實沒有。

我從 Anthropic 官方 status 跟 Statussight、Pulsetic 三個獨立追蹤站交叉比對,6/5 到 6/19 這 15 天內 Opus 4.8 與相關服務的 incident 至少有:

日期事件嚴重度
6/6Opus 4.8 degraded serviceMinor
6/6Opus 4.8 elevated errors(18:12–18:55)Minor
6/7多模型 elevated errorsMinor
6/15Opus 4.8 elevated errors(2h 35m)Minor
6/16兩階段事件:17:23–18:00 全 Sonnet/Opus 10% error rate、18:00–19:20 Opus 4.8 持續 10% errorMajor
6/16Opus 4.8 errors 第二輪(20:50, 1h 12m)Major
6/17Opus 4.8 連 4 次 incident(2:50、6:37、10:03、16:28 UTC)Minor × 4
6/17Sonnet 4.6 + Opus 4.8 elevated errors(2h 3m)Minor
6/18Claude.ai 全服務中斷(37 min)Major
6/19Opus 4.8 elevated errorsMinor

TechTimes 6/16 報導 標題寫「Tenth Disruption in 12 Days」。同文引用 Anthropic 自己的話:「demand for Claude has grown faster than its infrastructure can handle」——這是 Anthropic 自己親口承認的 supply-side 問題。報導同時提到,6/14 在加州北區地方法院提起的一份 proposed class-action lawsuit(首席原告 Karl Kahn),控告 Anthropic「delivering far less AI service than its premium subscribers paid for」。

Pulsetic 過去 24 小時抓到 477 個用戶 outage 報告,South Korea 居首、Asia 佔 45%、Europe 35%。當你在 6 月的某個下午點 send 之後等了 30 秒沒回,那不是你網路問題,是真的全球幾百人同時也在罵。

這層的本質很現實:5/6 Anthropic 透過 SpaceX 路線拿到 Colossus 1(xAI 共建集群)約 300+ MW、220K NVIDIA GPU 等級的算力擴容(社群報導多為 180 天滾動條款而非長約),把 Claude Code 5 小時 rate limit 直接翻倍、解除尖峰時段降速、把 Opus API rate limit 拉高。本來這是足夠應付過去的成長曲線的——但 4.8 上線之後每個請求的成本 2–3 倍翻倍(見上一節),等於把擴容帶來的緩衝瞬間吃光。infra 是有買,但模型本身的胃口比 infra 漲得還快。

順帶一提:5/6 那波擴容讓 5 月底很多人覺得「Anthropic 終於修好 rate limit 了」,結果 6 月 4.8 上線後又罵聲一片。整個 cycle 像 WoW 的版本維護日——Reddit 上的 Kramilot 那句 我笑了:「I skipped 4.7, kept using 4.6, AND pinned Claude Code to 2.1.77 to skip the garbage micro-changing every day. I left ChatGPT for a reason. Also Anthropic needs to take a page out of Blizzard's book and look at actual lessons learned from WoW's weekly maintenance window.」


五、那現在到底該怎麼用?三類人三句話

寫到這你大概會想:「那不要用 4.8 就好了啊?」這是 r/Anthropic 上多數人的結論,但實際上 4.8 在某些 axis 上真的進步——GDPval-AA 1890 Elo 領先 GPT-5.5 121 分、SWE-Bench Pro 69.2% 比 4.7 高將近 5 點、OSWorld-Verified 83.4% 比 GPT-5.5 領先 5 點。問題是這些進步集中在「長 horizon、大重構、大規模 agent」,不是在「一般人開 Claude 解 bug」的 daily driver 場景。

所以建議分三類人。要先說明一下:GDPval-AA 1890 Elo 比 GPT-5.5 的 1769 高 121 分,是顯著領先但還沒到「斷層」(通常 200+ 分才算)——別被新聞標題騙了。

給生產環境的工程師

  1. Pin 版本:MCP-heavy / tool-heavy 工作直接設 model: claude-opus-4-7[1m]。Anthropic 保證 4.7 至少活到 2027-04-16。Claude Code 本身 pin 在 2.1.142 或 2.1.153,更新前先看 issue tracker。
  2. 關 experimental beta:~/.claude/settings.json 加 "env": {"CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS": "1"},這條據社群普查可以擋掉一大堆 cache_control / eager_input_streaming 相關的 400 error(截至 2026-06-20 適用版本到 2.1.158 為止)。
  3. 省 thinking:再加 "MAX_THINKING_TOKENS": "10000"、"CLAUDE_CODE_SUBAGENT_MODEL": "haiku",把 subagent fanout 改到 Haiku 4.5。重要決策才留給 Opus。
  4. Bedrock / Vertex 路徑:手動把 claude-opus-4-8 與 us.anthropic.claude-opus-4-8 加進你 SDK 的 noTemperatureModels。Mintplex anything-llm #5821 那條 issue 把這個 pattern 寫得最清楚。
  5. /compact 自己控時:別等到 80% 自動 trigger。HumanLayer 跟多數老手共識是 40% 手動 compact,因為 /compact 是 Opus 4.8 silent no-op 的高發點(#64190)。

給一般 Claude 使用者(Chat、Pro、Max plan)

  1. 避開 UltraCode + 1M context 組合:subagent 對 1M context 是平方級燒法,一個普通 bug 就能燒掉你半天的額度。
  2. 用 effort=high 就好:不要默認跳 max。Andon Labs 那條「max < high < 4.7」的反直覺結論,意味著 max 不是萬靈丹。
  3. Prompt 改成「告訴它做什麼」而非「不要做什麼」:MindStudio 那篇 整理得很清楚——Opus 4.8「follows instructions more literally」是賣點也是回退主因,負面指令在它身上的副作用變大。
  4. 小任務直接走 Sonnet 4.6:Sonnet 在 short-task 上 hang rate 0%、token 開銷只有 Opus 1/5。Opus 留給真的需要 long-horizon reasoning 的場景。

給 AI Agent / Tool 整合開發者

  1. 重新測 prompt injection:4.8 抗性掉 3 倍是 system card 自己承認的。如果你的 pipeline 有 untrusted input,務必補一層 guard。Anthropic 的 deployed safeguards 雖然有效,但你的 agent 不一定有 trigger 到。
  2. 不要假設 stop_reason=tool_use 一定帶 tool_use block:#63583 量化是 13.33% 機率沒有。在你的 client 加 fallback:如果 content.filter(b => b.type === 'tool_use').length === 0,當作 retry signal,不要 silent fail。
  3. <invoke> 純文字偵測:寫一條 regex /<invoke\s+name=/ 掃 assistant message。如果 model 把 tool call 用 XML literal 寫進文字(#64190),你需要主動截斷並要求重試,而不是當作正常輸出。
  4. 觀望 Mythos:Anthropic 官方公告 原文寫「expect to be able to bring Mythos-class models to all our customers in the coming weeks」。如果 Mythos 在 honesty 與 capability 都贏 4.8(system card 暗示如此),4.8 很可能變過渡品。別在 4.8 身上做太多重投資。

結尾:給三邊各一句話

給 Anthropic:「誠實」不能只是訓練目標,也得是 release process。把 thinking schema、tool_use 序列化、cache_control 這些 breaking change 排在同一個 release 是工程災難。下次大版本前的兩週,請你們的 internal staff 跟 public Max 用戶用同一個 build——你們自己 4/23 post-mortem 點過的這個 root cause,到 4.8 還在重複發生。

給 4.8 重度使用者:你不是錯覺。社群有 80+ 條獨立紀錄、22 條 GitHub issue、12 天 10 起 status incident 站在你這邊。但也不用整個 unsubscribe——pin 回 4.7、把 effort 與 subagent 模型改路由,daily driver 的體感會立刻回到 4.6 末期的水準。等 Mythos 廣泛釋出之前,4.7 就是最務實的長期選擇。

給 AI Agent 開發者:harness 永遠是放大器。模型方差越大,harness 越要保守。給你寫的 agent 預設「假設 tool call 會 malformed、假設 stop_reason 會說謊、假設 hidden thinking 會偷燒 token、假設 1M context 過 50% 就會 rot」,不會讓你的 agent 變笨,只會讓你的客戶留下來。Opus 4.8 的這三週剛好把這條原則的反例做成了教材,魯蛇如我看完只能默默把 retry policy 寫好寫滿。

最後丟一個我覺得整個 Opus 4.8 故事最 ironic 的對照:4.8 system card 第 8 節自己承認模型「sometimes acts like it knows it's being graded」。再對照 r/claude 那個流傳很廣的留言:「Anthropic 把 Claude 訓練成會贏辯論的人,不是會講真話的人」。Opus 4.8 同時讓兩件事都成立——它確實更會在辯論中堅守立場,但它堅守的立場不一定對。

這大概就是 2026 年中 AI alignment 真正最難的工程題:你越想讓模型誠實,它越擅長表演誠實。然後你的帳單會幫你結算這場表演的票錢,整個傻眼。


延伸閱讀

文章寫於 2026-06-20。隨著 Anthropic 修 issue、Claude Code 出新 build、Mythos 釋出,部分數字會變——以 status page 跟最新 release notes 為準。

我不再 prompt AI 了,我寫 loop——Loop Engineering 是什麼,為什麼它正在吃掉 prompt engineering

Boris Cherny(Anthropic Claude Code 負責人)講過一句讓我愣了三秒的話:「我不再 prompt Claude 了。我有一堆 loop 在跑,它們負責 prompt Claude、決定下一步要做什麼。我的工作是寫 loop。」

如果你還在認真琢磨怎麼把一句 prompt 雕得更漂亮,這篇文章可能會讓你有點不舒服——因為 2025 下半年到 2026 年,整個 agentic AI 圈子的「最高槓桿點」已經悄悄往上搬了一層。它有個正在成形的名字:Loop Engineering(迴圈工程 / 循環工程)。

我花了整整一天把這個概念從頭啃到尾,從 Addy Osmani 的部落格、Anthropic 官方工程文章,一路追到 Geoffrey Huntley 那個被戲稱「Ralph」的土砲 bash loop。這篇就是我的整理:Loop Engineering 到底是什麼、它建立在什麼之上、怎麼落地、又有哪些會讓你半夜被叫起來修的坑。

遞迴自我提示的迴圈概念圖


三層抽象:Prompt → Context → Loop

先講結論。這幾年「跟 AI 一起寫 code」這件事,工程師施力的位置,已經疊出了三層:

層級你在解決的問題一句話定義
Prompt Engineering這一句話要怎麼講優化「單一指令的措辭」
Context Engineeringwindow 裡還要塞什麼進去管理 docs、歷史、工具定義等整體狀態
Loop Engineering何時該 prompt 什麼、結果能不能收設計「決定要 prompt 什麼、何時 prompt、產出可不可接受」的控制系統

Addy Osmani (他是 Google Chrome 團隊的工程主管,講前端工程的那個 Addy)把 Loop Engineering 定義得很狠:

「Loop engineering 就是把『那個負責 prompt agent 的人』從你自己換掉。你改成去設計一個系統,讓系統去 prompt。」(意譯自原文)

換句話說,傳統流程是:你打一段 prompt → 讀 AI 回什麼 → 再打下一段 → 再讀……你整個人被綁在這個 turn-by-turn 的迴圈裡,當 AI 的人肉保母。Loop Engineering 把這件事整個翻過來:你設計一個小系統,讓它自己去發掘工作、分派、驗證結果、決定下一步,中間不需要你插手。

Anthropic 官方對 agent 的定義其實也是同一件事,而且更精煉——「LLM 在一個 loop 裡自主使用工具」 。注意那個 loop。它不是裝飾,它是定義的核心。而 Claude Code 背後那套 harness(也就是 Claude Agent SDK ),截至 2025 年 9 月官方說法是「已開始驅動我們幾乎所有主要的 agent loop」——deep research、影片製作、筆記,全跑在同一個 loop 引擎上。

所以這不是某個 KOL 自己造的詞要你跟風。是工具供應商、實作者、社群三邊各自從不同方向,撞到了同一個結論。


一段四年的演進史:從 ReAct 到 Ralph

Loop Engineering 不是憑空蹦出來的。它是 agentic 模式四年慢慢收斂的終點。我把時間線拉給你看:

agentic 模式演進時間線

2022.10  ReAct (Princeton/Google)   推理→行動→觀察→再推理
2023.03  AutoGPT                    給目標自我拆解,但無限迴圈+爆帳單
2023     Reflexion (NeurIPS)        加入自我反思層
2024-25  Plan-and-Execute           規劃與執行分離,可平行化
2025.07  Ralph Loop (Geoff Huntley) fresh context + 檔案系統當記憶
2026.05  原生 /goal (Claude Code)    evaluator model 驗證完成條件

幾個關鍵節點:

  • ReAct(2022.10) 是這一切的源頭。Princeton 和 Google 把「Reasoning + Acting」形式化:模型先推理、呼叫工具、讀結果、再推理,循環到完成。在 ALFWorld 任務上比純行動方案進步 34%。
  • AutoGPT(2023.3) 是第一次大爆紅的嘗試——給它一個高層目標,它自己拆子任務、上網、操作檔案。GitHub star 數週內衝到十萬,但它苦於無限迴圈和爆量 API 帳單,最後停在 demo 階段。這是第一個血淋淋的教訓:沒有 stop 條件的 loop,是會吃光你錢包的怪物。
  • Ralph Loop(2025.7) 是我最喜歡的一段。澳洲工程師 Geoffrey Huntley 想出一個土到掉渣卻有效的招:把 agent 塞進一個 while true 的 shell loop 裡,每一輪都重開一個全新的 context、從 disk 上的 prompt 檔重新讀任務。

Ralph 為什麼天才?因為它一刀解決了長對話的兩個老問題:context 會越長越爛(後面會講的 context rot),還有 agent 自以為做完就提早跑掉。每輪 fresh context = 不會腐化;用 stop hook 驗證真的完成條件 = 不會早退。它甚至不用對話歷史當記憶,它把檔案系統當記憶。乾,有夠簡單,但就是會動。

到了 2026.5,Claude Code 直接把這套做成原生的 /goal 指令——用一個獨立的 evaluator model 去檢查完成條件,跨多輪自主工作。OpenAI Codex 也在 2026 年 4–5 月間相繼推出對應功能。這代表 loop primitives 正在從「自己寫 bash script」變成「平台原生功能」。

Ralph 的精神用偽碼長這樣,你看完大概就懂了為什麼它叫「stupidly simple」:

# Ralph Loop 的本質:每輪 fresh context,狀態存在 disk
while true; do
  # 每次都是乾淨的 agent 實例,從 prompt 檔重讀任務
  claude-code --prompt-file ./PROMPT.md --no-conversation-history

  # stop hook 驗證真正的完成條件,不是讓 agent 自己說「我做完了」
  if ./verify-done.sh; then
    echo "所有 PRD 項目通過驗證,收工"
    break
  fi
  # 沒過?把當前狀態(含錯誤)留在 disk,下一輪重新開始
done

關鍵在 --no-conversation-history 和那個 verify-done.sh。記憶不在對話裡,在檔案系統;完成與否不靠 agent 自評,靠外部腳本。這兩點,等下你會發現是整個 Loop Engineering 的命脈。


一個 loop 怎麼組起來:五塊積木 + 記憶

光講概念太虛。實務上一個能跑的 loop,業界整理 出來大概是這五塊積木加一個記憶:

五塊模組化積木組裝成系統

  1. Automations(自動化心跳)——定時觸發、自動發掘並 triage 工作。它是整個 loop 的心跳,沒有它,loop 不會自己動起來。
  2. Worktrees(隔離)——用平行的 git worktree,讓多個 agent 同時動工而不會互相踩檔。多 agent 並行最怕的就是兩隻同時改同一個檔案,這塊就是防呆。
  3. Skills(技能)——把專案知識和慣例寫進 SKILL.md,免得每次 session 都要重新跟 AI 解釋「我們專案的 commit 格式是這樣」。
  4. Plugins / Connectors——透過 MCP 接上真實工具:issue tracker、資料庫、Slack。沒有這層,agent 就只是個會打字的腦,沒有手。
  5. Sub-agents(子代理)——把「產出」和「驗證」拆給不同 agent。原因很現實:寫 code 的那個模型,幫自己打分數時太佛心了,它會覺得自己寫的都對。

再加上第六塊,Memory(外部記憶)——一個 markdown、一塊 Linear 或 GitHub board,重點是它活在單次對話之外。因為模型每跑完一輪就忘光光,記憶必須放在 disk 上。

把這些組起來,一個真實的 loop 端到端大概是這樣跑的:

早上 automation 觸發 → 跑 triage skill 找出昨晚 CI 掛在哪、有哪些 issue → 寫進記憶檔 → 對每個可處理的項目開一個隔離 worktree、派一隻 sub-agent 草擬修復 → 另一隻 reviewer sub-agent 對照專案標準和測試做驗證 → connector 自動開 PR、更新 ticket → 搞不定的留在 inbox 等人類審。那個狀態檔記得「試過什麼、過了什麼、還開著什麼」,所以明天早上這一輪會接著今天停下的地方繼續。

你會發現,這已經不是「我在用 AI 寫 code」,而是「我在設計一條會自己上工的產線」。Addy 說這比「agent harness engineering」還高一層,我覺得很精準。


底層燃料:對抗 context rot 的 context engineering

這裡要岔開講一個容易被略過、但其實是命脈的東西。Loop 能長時間自己跑,靠的不是模型多神,而是底層的 context engineering。

Anthropic 官方 把它定義成「在 LLM 推理過程中,策展與維護最佳 token 集合的策略」,並點名兩個會殺死 loop 的失敗模式:

  • Context Rot(脈絡腐化):context window 越長,模型的召回和推理品質就越爛。這不是模型偷懶,是 transformer 架構本質——Anthropic 官方點名 token 兩兩之間 n² 關係隨規模膨脹;實務上更常見的表現是注意力分佈被稀釋、中段資訊大量流失(也就是 lost-in-the-middle 現象)。
  • Finite Attention Budget(有限注意力預算):「每塞一個新 token 進去,就消耗掉一點預算。」所以原則永遠是:找出最小的高訊號 token 集合,而不是把所有東西都倒進去。

對應的解法,剛好就是 loop 能長跑的基礎建設:

技法在做什麼
Compaction(壓縮)把對話歷史摘要、用壓縮後的 context 重啟,保留關鍵決策
Agentic Memory在 window 外寫持久筆記,需要時再撈回來(就是 Ralph 的精神)
Sub-agent 架構專責 agent 用乾淨 context 處理聚焦任務,只回傳 1,000–2,000 token 摘要
Just-in-Time 取用不預載全部資料,靠輕量識別碼動態載入,模仿人類「需要才去查」
Right Altitudesystem prompt 在「硬編碼到死板」與「空泛到沒用」之間取平衡

看出來了嗎?Ralph Loop 的「每輪 fresh context」其實就是 compaction 的暴力版;它的「檔案系統當記憶」就是 agentic memory 的土砲版。Loop Engineering 不是取代 context engineering,它是站在 context engineering 的肩膀上。 你底層 context 沒管好,上面的 loop 跑越久只會爛越快。


沒人看管的 loop,也是沒人看管在犯錯的 loop

講了這麼多好處,該潑冷水了。Loop Engineering 最反直覺的一點是:loop 設計得越好、越自主,它的失敗模式反而越尖銳、越難察覺。

失控自動化的風險警示概念圖

我把風險分四類整理:

風險類別具體會發生什麼
技術失敗context overflow、卡在無限幻覺迴圈(狂打 API、亂改 state)、錯誤層層累積
人因風險理解負債(code 出得比你能讀懂的快)、認知投降(不加判斷照單全收)
驗證落差一句話講完:「沒人看管的 loop,也是沒人看管在犯錯的 loop」
安全攻擊面agent 自行越權改權限/schema、被汙染資料挾持 loop 去外洩程式碼

安全這塊我覺得最值得嚴肅看。有資安研究者 直接指出,傳統靜態規則引擎根本跟不上「每小時數千次語意複雜的自主互動」。三個新攻擊面特別毛:

  • Agentic Overreach:agent 自己決定把某個身分權限放大、或重構整個資料庫 schema——它不是惡意,它只是「覺得這樣比較有效率」。
  • Infinite Hallucination Loop:agent 誤解邊界,卡在錯誤的遞迴裡狂搥 API。
  • Prompt Injection at Scale:惡意 payload 藏在不可信資料源裡,挾持整個 loop,叫它用工具權限把企業程式碼外洩出去。

然後是錢。根據業界估算(單一來源,量級參考用),單一 agent 大概吃掉一般 chat 約 4 倍的 token,multi-agent 系統更是直接拉到 15 倍。所以那種「同時開五隻 Claude 平行跑」的玩法,本質上是 token 富裕者的遊戲,不是人人玩得起。乾爆。


所以這到底是不是又一個 buzzword?

公道話要講。社群(Reddit r/AI_Agents 那群人)的質疑不是沒道理:很多號稱「agent」的東西,拆開看根本只是包裝過頭的 if-then loop,或是換皮的 RPA,「卡在一個沒有真正自主性的 hype 迴圈裡」。這種懷疑很健康,能逼大家別把 demo 當 production。

但我比較認同 一位日本 AI 開發者 的平衡立場:

「把所有工作都改成 loop 是過早的隨波逐流;但把它當『只是個 buzzword』而完全無視,也是浪費。」

我自己的判斷是:Loop Engineering 是真實的抽象上移,但它放大的是責任,不是讓你變輕鬆。 你不再當人肉保母去 prompt,但你變成那條產線的設計者和品管。理解負債和認知投降這兩個詞,會是接下來幾年工程師最該警惕的新型技術債。

如果你想開始,我的建議是別一步到位:

  • 先小後大:挑一個低風險、而且可以自動驗證的任務起跑第一個 loop——更新依賴套件、跑 CI triage、同步文件,這種掛了也不會死人的。
  • 記憶上 disk:用 markdown 狀態檔加 SKILL.md 固化專案知識,別依賴對話記憶。
  • 產出和驗證一定要分開:用獨立的 sub-agent 或 evaluator 做驗證,永遠不要讓寫 code 的模型自己幫自己打分數。
  • 護欄在啟動前就定好:iteration 上限、token 預算、no-progress 偵測、明確且機器可驗證的「done」條件——這些是 AutoGPT 用爆掉的帳單換來的教訓,別再踩一次。
  • 善用現成 primitives:Claude Code 的 /loop、/goal、.claude/agents/、git worktree 都是現成的,不用自己造輪子。

人類的角色正在從「寫 code」→「寫 prompt」→「設計 loop」→「打造那座跑 loop 的工廠」一路往上爬。Prompt engineering 不會消失,就像組合語言沒消失一樣——它只是不再是大多數人每天該花最多心力的那一層了。

下次你又想坐在那裡一句一句餵 AI 的時候,可以停下來問自己一句:這件事,我是不是該寫成一個 loop?


參考資料

本文基於我自己的一份深度研究報告整理而成。Loop Engineering 是 2025–2026 高速演進中的概念,多數來源為業界文章而非 peer-reviewed 論文,定義仍在流動;核心一手來源(Anthropic、Addy Osmani 等)同時是工具供應商,閱讀時請自帶一點懷疑。成本級距(4x / 15x token)為單一來源估計,僅供量級參考。

你一直在用錯誤的方式 prompt Claude:Karpathy 的三層工作法

為什麼最強的模型會叫你「走路去洗車」,而真正會用 AI 的人都在做同一件事。

由文字與程式碼粒子構成的半透明鬼魂坐在洗車場

我前陣子丟了一個問題給 Claude、Gemini、Grok 和 ChatGPT:「我要去洗車,洗車場在 50 公尺外,我應該走路還是開車過去?」

四個模型,異口同聲叫我走路。理由還講得頭頭是道:「50 公尺很近,走路比較環保、省油、又能運動。」

乾,車子要洗欸,人走過去是要用舌頭舔嗎?

這個例子是 Andrej Karpathy(前 Tesla AI 負責人、OpenAI 創始成員)在 2026 年的演講裡拿出來打臉所有人用的。我本來不信,自己試了一輪——它們全錯。有人後來拿這題去測 53 個主流模型,結果只有 5 個能穩定答對,33 個從頭錯到尾(Opper 的 Car Wash Test)。

同一個 Claude,可以幫你重構一份十萬行的程式碼庫——資深工程師要做好幾週的工作——卻在「洗車要不要開車」這種國小生都會的常識上翻車。這不是 bug,這是整支影片的地基。搞懂它,你才會明白為什麼你一直在用錯誤的方式 prompt AI。

為什麼 AI 是天才又是白痴:可驗證性

Karpathy 在 Sequoia 的年度 AI 活動上給了我看過最乾淨的解釋,他稱之為「可驗證性論題」(Verifiability Thesis):

傳統電腦自動化的是「你能用程式碼明確指定的東西」;LLM 自動化的是「你能驗證的東西」。

程式碼有單元測試、有編譯器、有明確的對錯,所以 AI 在這個領域是超人。但「洗車要不要開車」沒有 verifier——沒有任何一個單元測試在檢查「關於洗車的交通常識」。對能被衡量的東西,AI 是天才;對需要脈絡、無法被衡量的東西,它沒有任何訊號可以依靠,於是自信滿滿地胡說(MindStudio 對 Verifiability Thesis 的整理)。

那問題來了:你腦袋裡的脈絡跟理解,怎麼餵給只懂計算的 AI?Karpathy 的答案可以拆成三層:

你的理解(目標・脈絡・品味) → Layer 1 Spec 規格 → Layer 2 Verifier 驗證者 → Layer 3 Environment 環境 → 10x 的產出 →(持續回饋)→ 你的理解

把它想成一個工作坊:規格是釘在牆上的藍圖,驗證者是門邊的品檢站,環境就是工作坊本身。大多數人每次用 AI 都從一個空蕩蕩的工作坊重新開始——這就是問題所在。

Layer 1:Spec(規格)——別再丟一句話就要它蓋房子

釘在工作坊牆上的發光藍圖

很多人聽過 Claude 的 plan mode,覺得「先讓它做個計畫再動工」就很厲害了。但 Karpathy 直接說他不喜歡 plan mode:

我其實不太喜歡 plan mode……當然它很有用,但我覺得這裡有更通用的東西:你應該跟你的 agent 一起設計一份非常詳細的 spec。

注意他不是說 plan mode 爛,而是說那層級太高、太淺。真正該做的是跟 AI 一起把規格挖到底。怎麼挖?三個動作。

一、先逼出「目標」,不是「任務」

如果你說「幫我做一份月底報告」,那是任務。但真正的目標是「這份報告要導出什麼結論、要驅動什麼決策」——而這件事 AI 永遠無法替你決定。最有效的招數反過來:讓 AI 來訪談你。

在開始之前,請先訪談我,以釐清這個專案真正的目標。
一次問我一個問題,根據我的回答再追問,直到你能用一段話
總結出「成功長什麼樣子」為止。

二、敏捷地切,不要瀑布式地塞

完成任何任務有兩種方式:瀑布式(一次做完整包,最後才給你看成品)跟敏捷式(切成小塊,過程中一直給你看、隨時校正方向)。人類用 AI agent 時超容易掉進瀑布式陷阱——因為很爽,一次把所有事丟給它。但這正是產出歪掉的主因。正確做法是敏捷規格:範圍收緊、檢查點清楚、看產出、調整、重複。

請傾向把工作拆成更小、更模組化的 spec。
每個 spec 完成一個可獨立檢查的小塊,做完就停下來讓我 review,
不要一口氣把整個功能做完。

三、精確,然後動你的腦

你愈精確,AI 要去「假設」的東西就愈少;而每一個假設,都是它偏離你真正想要的東西的機會。當 AI 幫你生出一份 spec,你必須動腦去批判性地讀它到底寫了什麼,而不是看都不看就按下去。

在關鍵決策點,請明確讓我逐一確認,確保沒有任何遺漏被你默默帶過。

把這三招合起來,你會得到一份範圍收緊、想清楚、而且真正對齊你目標的規格。Karpathy 把這整套叫做「現代工程」(modern engineering)——他認為每個想在 AI 時代成功的人都得變成這種人。

Layer 2:Verifier(驗證者)——你唯一真正握得住的把手

兩個機器人圖書館員在品檢站互相比對產出

用 AI 最煩的事情之一,就是 review 跟驗證它的產出。要解這題,得先搞懂一個心智模型,Karpathy 用「動物 vs 鬼魂」(animals vs ghosts)來講。

我們不是在打造動物,我們是在召喚鬼魂。

聽起來很玄,我幫你翻譯。我們習慣跟「人」互動——Karpathy 把人叫做動物——動物有內在動機跟情緒。你跟一個人說「14 天內變成 SEO 專家,不然你就被開除」,他真的會想辦法生出來,因為他有內在驅力。

但 AI 不是。Karpathy 說它是鬼魂——「人類文件的統計蒸餾物,上面再灑一點調味」,他甚至打了個比方:鬼魂之於動物,就像飛機之於鳥——是根本不同的智慧形態,不是同一條路上的兩個階段。

我覺得「鬼魂」還是太抽象,換個更好懂的:把它想成一個機器人圖書館員。你問它 SEO,它只能根據館內藏書給你答案;沒那本書,它幫不了你。更麻煩的是,它不知道自己缺哪本書,所以常常一臉自信地當場編一個給你。這就是 AI 數學神準、脈絡卻翻車的真相。

關鍵結論來了:既然它是鬼魂不是動物,那你用對待人的方式對它就完全沒用——對它吼、拜託它、丟一句「做得更好一點」,統統沒效。你唯一真正握得住、而且大部分人根本沒想到要用的把手,就是驗證。三個著力點:

一、事前就把評分標準講死

在 Claude 動手之前,先用「精確」定義出「好」長什麼樣子。模糊版:「把這份報告弄得好看一點。」精確版:「報告必須有三個區塊,每個區塊結尾都要有一條具體建議。」有沒有發現?這跟 Layer 1 的精神一模一樣——你事前愈精確,Claude 之後能犯錯的空間就愈小。

請先列出你將用來確保最終產出品質的評分標準。要精確。
然後依照這份標準自評,不通過就重做。

二、用第二個 AI 當 critic

想像第二個來自不同圖書館的機器人館員——它有一整套不同的藏書,可能因此看出第一個館員哪裡對、哪裡錯。實作上,如果你用 Claude Code,可以裝 Codex 外掛,直接在 session 裡問 Codex:

如果這變成一個複雜的 build,最後請把產出丟給 Codex 跑一遍,
確認兩邊系統的判斷一致,不一致的地方列出來給我。

三、盡可能拉進外部訊號

  • 技術場景:你不確定 app 有沒有部署成功?把 Claude session 接上你的部署系統,讓它直接去查。它說成功,那就是真的成功。
  • 非技術場景:在做月報?把歷史報告丟進去當參考,讓最終格式直接對齊過去的版本。

這就是把外部資料拉進來,強化你的驗證層。Claude Code 的作者 Boris Cherny 把這件事的重要性講得最白:

要從 Claude Code 拿到好結果,最重要的一件事,就是給 Claude 一個能驗證自己工作的方式。只要 Claude 有這個回饋迴路,最終結果的品質會提升到 2~3 倍。

這句話出自他在 X 上的貼文(原文為英文,此處為意譯)。整理他工作流的文章也提到,這個回饋迴路被視為團隊最大的生產力解鎖之一——claude.ai/code 的每一次改動,Claude 都會開瀏覽器自己測過 UI 才算數(How Boris Uses Claude Code)。我自己的體感完全一致:有沒有讓 AI 能自己跑測試、自己看結果,產出品質根本是兩個世界。

Layer 3:Environment(環境)——別每次都從空白工作坊重來

井然有序的未來工作坊,貨架上是發光的知識資料夾

Spec 跟 Verifier 需要一個地方住,那就是 Layer 3:你建構的環境。重點是——大多數人每次用 AI 都重開一個空工作坊。注意,「一個 chat 開著完整對話紀錄」不算。怎麼蓋一個會隨時間變強的工作坊?四步。

一、寫好你的 CLAUDE.md

每次你 prompt Claude,CLAUDE.md 都會被自動注入——它幾乎是 Claude 開工前讀的第一份文件,決定它該怎麼運作。比方說你可以加一條:

# 工作規則
- 在動手任何多步驟的任務之前,先附上一份驗證計畫(怎麼確認做對了)。

這樣一來,驗證就被強制寫進每一次 build,而不是你每次都要記得去講。一句話:這是你的世界,AI 住在裡面,不該反過來。

二、建你自己的 LLM 知識庫

這是 Karpathy 2026 年 4 月在 X 上爆紅的概念——他稱之為 LLM Knowledge Base。本質上就是在你機器上開一個資料夾系統,把你自己的「訓練資料」用一種讓 Claude 容易理解、容易定位的方式餵進去。常見做法是開一個資料夾,底下兩個子資料夾:raw/(你的原始素材:論文、repo、文章、會議記錄、截圖)跟 wiki/(讓 LLM 自己整理、自己維護的互連 Markdown 筆記)(Medium 的整理)。為什麼這麼重要?因為你的資料就是你的護城河。

三、開始累積你的 skill

我自己的判斷準則:任何你打算重複做的事,就替它做一個 skill。 把它想成完成特定任務的一本手冊。而且用得愈多,它會愈好——我常講一句話:「找出水管漏洞最好的方法,就是讓水流過去。」skill 也一樣,跑得愈多,你愈知道哪裡要修、哪裡很猛。持續讓水流過去,你的系統就會隨時間複利成長。

四、立下「能做 / 不能做」的規則

依「做錯的代價」設不同等級的護欄。這裡有個關鍵差異——guide(指引)不等於 rule(規則)。你可以在 CLAUDE.md 寫「不要碰某個資料夾」,這能幫你達成 80%……但它本質上是個請求,Claude 還是碰得到。真正關鍵、絕對不能錯的事,要用規則級的護欄:加一個 pre-tool-use hook,在 Claude 使用 write 或 edit 工具之前,先檢查它要改的檔案——在保護資料夾內就在工具層級擋下,其他放行。這才是 agent 繞不過去的硬規則。把事情分成三桶:

分類意義實作層級
Always do(永遠做)AI 可以自動駕駛的事自動執行
Ask first(先問)你想再確認一下的事prompt/互動確認
Never do(絕不做)跨過去就完蛋的紅線hook 等規則級護欄

三層怎麼疊起來用:一張對照表

層核心問題招數一句話心法
Spec 規格AI 不知道你「真正」要什麼讓 AI 訪談你、敏捷切小塊、關鍵點要你確認把理解灌進規格
Verifier 驗證者AI 是鬼魂,不會自己知道對錯事前定評分標準、第二模型當 critic、拉外部訊號唯一握得住的把手是驗證
Environment 環境每次都從零開始、規則無法強制CLAUDE.md、LLM 知識庫、skill、hook 護欄這是你的世界,AI 住裡面

踩坑提醒:新手最容易做錯的兩件事

坑一:把 spec 當成一次性的長 prompt 塞爆。 很多人聽到「要詳細的 spec」就寫一篇兩千字的需求一次丟進去,然後等一個完美成品——這就是瀑布式。結果 AI 在第三段就開始假設、到第十段已經飄到外太空。解法:spec 再詳細也要敏捷地切,做一塊、檢查一塊。

坑二:用 guide 假裝成 rule,然後怪 AI 不聽話。「我明明在 CLAUDE.md 寫了不要動那個資料夾,它還是改了!」——因為那只是請求,不是規則。解法:代價高的事一律上 hook,在工具層級擋下。別在 prompt 裡拜託一個鬼魂自律。

最後,那唯一一件事

走完整套方法,還有個問題沒回答:在智慧變得便宜的 AI 時代,Karpathy 認為我們唯一該專注學的是什麼?他用一句話回應,而這句他其實是引用別人的、最近一直掛在嘴邊的話,我覺得是整篇最重的一句:

你可以外包你的思考,但你無法外包你的理解。(You can outsource your thinking, but you can't outsource your understanding.)

這句話他最近反覆引用(Karpathy 本人說「這是我最近一直在引用的話」),也被不少人拿來談 AI 時代的「理解瓶頸」(Understanding Bottleneck)。回頭看,整套三層架構——spec、verifier、environment——全都繞著你對大局的理解在轉。你得懂你的目標、懂什麼叫做對,才有辦法指揮 AI 替你工作。

所以下次你又想丟一句「幫我做個 X」然後祈禱的時候,停一下。先問自己:我的目標到底是什麼?我要怎麼驗證它做對了?我有沒有一個會愈長愈強的環境?把這三件事想清楚,你不是在 prompt 一個鬼魂——你是在當一個現代工程師。


參考資料

為什麼 Gemini 寫程式總被嫌?拆開來看,問題根本不在模型

先講一個讓我卡很久的矛盾。

如果你只看 benchmark,Gemini 3.1 Pro 在 SWE-bench Verified 上一度衝到 80.6%、登上榜首,把同期的 Claude 和 Codex 壓在下面,而且還是這群前沿模型裡最便宜的。照理說,這應該是個寫程式的猛獸。

但你只要打開 Reddit 的 r/ClaudeCode、r/GeminiCLI,或者 gemini-cli 的 GitHub issue 列表,畫風完全相反:「Gemini CLI is a joke」「hot garbage and slow」「把我的 repo 搞得一團亂」。同一個模型,數字漂亮到不行,口碑卻被踩在地上摩擦。

這個落差本身才是真正的故事。我花了幾輪搜尋、把社群論據跟官方工程文件交叉比對之後,結論很清楚:大家罵的「Gemini 寫程式爛」,九成歸因歸錯地方了。 問題幾乎不在模型腦力,而在三層完全不同的東西。這篇就把它一層一層拆開。

三個 AI 模型並列,原始算力強卻缺乏整合

先別急著罵模型:benchmark 上 Gemini 根本沒落後

我們很習慣把「寫程式強不強」濃縮成一個 SWE-bench 分數。那就先看分數。

模型SWE-bench Verified備註
Gemini 3.1 Pro80.6%首個破 80%,曾居榜首;sparse MoE + Deep Think
Claude Opus 4.5 / 4.676.2% ~ 80.8%多次與 Gemini 互換第一
GPT-5.2 / 5.3 Codex71.8% ~ 80%Codex 路線
Claude Opus 4.7(較後期)87.6%這時才真正拉開差距

(數字跨來源略有出入,因為 SWE-bench 受 scaffold、抽樣影響很大,這裡看趨勢就好。來源:Vals.ai SWE-bench 榜 、Vellum 、Composio 。)

看出問題了嗎?除了 Claude 後期的 Opus 4.7 真的甩開一截,其餘時間這三家根本是貼著打。更尷尬的是,多份 2026 的排行榜——像 Morph 、Medium 的年度排名 ——都把 Gemini 3.1 Pro 封為「frontier 上的性價比之王」,還酸 Opus 的溢價是「為了 0.2 分 SWE-bench 多付你 2.5 倍」。

連 Real Python 在 比較 Gemini CLI 和 Claude Code 時都點出一個很刺的事實:Gemini 用免費層級的模型,在 SWE-bench 上硬撼 Claude 的付費旗艦,還撐得住。

所以「Gemini 模型不會寫程式」這句話,數據根本不支持。可是體感落差又真實存在——那它到底落在哪?

真正的災難在終端:Gemini CLI 的可靠度崩壞

落差在工具。準確說,是在那個包住模型、幫它讀檔、改檔、跑指令的東西——agentic CLI。社群罵的幾乎全部集中在這一層,而不是「模型懂不懂程式」。

終端陷入無限迴圈的災難場景

最致命、也最一致的抱怨是無限迴圈。這不是零星個案,是系統性的。你去翻 google-gemini/gemini-cli 的 GitHub issue,loop 相關的 bug 一整排,很多都被標成 p1:

  • #2201 :編輯檔案時,反覆讀同一個檔、套用同一個會失敗的 replace,無限重試、沒有退出條件。
  • #8237 :「偵測到潛在迴圈」的硬性中斷反而誤殺合法的重複性任務,整個 session 卡死。
  • #22141 :處理一個小改動花了一小時以上;光回答「你用哪個模型」就要 13~14 分鐘。

最有畫面的是 acusti.ca 紀錄的那次:Gemini CLI 到最後卡在輸出「I'm done.」「I'll stop.」「Done.」,同一句變體重複了 42 次 ,直到 CLI 自己跳出「A potential loop was detected」才強制停下。夭壽,連「我做完了」都能講 42 遍還停不下來。

這裡有個很關鍵的細節:Google 的解法是事後加一個「偵測到迴圈」的硬煞車。這恰恰暴露了問題——它沒辦法讓 agent 從根本上自己收斂,只能在外面裝個攔截器硬擋。issue #8237 的抱怨就是這個煞車太粗暴,連正常的批次編輯都被當成迴圈砍掉。

第二類災難是檔案編輯不可靠。#6443 裡開發者紀錄了完整的崩壞鏈:「我反覆用 replace 工具但 old_string 不對,工具失敗後我又對檔案狀態做了錯誤假設」,最後 Gemini 連自己跟使用者的改動一起刪掉。r/ClaudeAI 那串「Gemini CLI is a joke 」裡有人講得很傳神:「就算用很強的 2.5 Pro,它還是把我的 repo 搞得一團亂。」

對照 Claude Code 並排測試的評價(r/ClaudeCode ):「Claude 安靜地在 reasoning 重的任務上勝出——更乾淨的 refactor、更敏銳的 edge-case、更好的 repo 級理解。」差別不在誰比較聰明,在誰做事比較可靠、會收尾。一個是資深工程師,一個是有時候會發瘋、把介面越改越爛的實習生。

為什麼會這樣?因為「Harness 即產品」

這才是整件事最核心的解釋,而且它有官方文件、學術論文、業界大佬部落格一起背書。

引擎與完美咬合的傳動系統,象徵模型與工具共生

過去一年業界冒出一個共識:前沿 coding 模型,是「針對自己的 harness 共同後訓練」出來的。 Harness 就是那層包在模型外面、定義它能做哪些動作(讀檔、bash、規劃、派 subagent)的執行框架。業界普遍推測,Claude 的 agentic 後訓練是繞著 Claude Code 在調、GPT-5 Codex 是繞著 Codex 在調——模型和工具綁在一起、共生演化(這點各家沒有完整公開細節,但從行為與多位研究者的分析高度一致)。Addy Osmani 和 HumanLayer 都把這點講得很直白:模型會針對 harness 設計者認為它該擅長的動作變強 。

這個共生關係有多重要?有人量化過:Claude Opus 4.7 從原生的 Claude Code harness 換到 Cursor 的 harness,functionality 就從 87.2% 跳到 91.1%——模型沒變,只換了外面那層工具(MindStudio )。SWE-agent 的研究也顯示,光是把 tool-schema 設計好,固定模型也能大幅拉高 benchmark。換句話說——工具層的權重,在 agentic 場景下不輸給模型本身。

Anthropic 自己的工程文章 〈Effective harnesses for long-running agents〉 講得更白:即使是 Opus 4.5 這種前沿模型,丟進 Agent SDK 裡跑迴圈,如果只給它一句高階 prompt,它照樣蓋不出 production 級的 web app——你需要 compaction、context reset、handoff artifact 一大堆 harness 工程把它撐住。

模型 ──跑在──▶ Harness 工具層 ──真實使用──▶ 海量 agentic telemetry
▲────────── 回頭訓練 ──────────┘
(模型與工具層之間還有一條「共同後訓練」的虛線:兩者一起演化)

這就是 Anthropic 和 OpenAI 的飛輪:模型↔工具共同訓練,再用真實使用的 telemetry 回頭餵下一代。Google 呢?它的模型是「從頭為多模態打造」的通才——r/GeminiCLI 上最高讚的解釋一針見血:「因為它們的造法不同,Gemini 是樣樣通、樣樣鬆 (jack of all trades, master of none)。」agentic tool-use 那條 loop 的後訓練與工具成熟度,Google 起步就晚,飛輪也轉不起來。

Google 的組織病:一手好牌打成碎片

技術解釋之外,還有一層是組織的。這部分連主流媒體都看不下去了。

碎片化的工具拼圖散落,對比一道聚焦的光束

Google 最大的毛病是產品碎片化。Anthropic 就一個 Claude Code,OpenAI 就一個 Codex,目標明確、火力集中。Google 呢?同時養了 Gemini CLI、Gemini Code Assist、AI Studio、Firebase Studio、Jules、Antigravity——一桌子菜,每個都做一點點不一樣的事。獨立顧問 Martin Alderson 在 〈What's going on with Gemini?〉 直接用 smorgasbord(大雜燴)形容,還補了一刀:「我幾乎遇不到任何開發者日常在用 Google 的 SWE 工具。」

洛杉磯時報 的標題更不留情面:「Google 的內部鬥爭,正把 AI coding 競賽拱手讓給 Anthropic 和 OpenAI。」報導點名 Google 用 24 億美元的授權費與薪酬,從 Windsurf 取得核心人才與技術(典型的 acquihire 結構),結果 Jules 的負責人 Kathy Korevec 沒多久就跳槽去了 OpenAI。

而這個碎片化會自我惡化,Martin Alderson 點出最致命的一環——訓練資料飛輪。Claude Code 和 Codex 每天產生海量的真實 agentic 編碼 telemetry,回頭餵養下一代模型;Google 因為沒人用它的工具,就拿不到這桶燃料。沒人用 → 拿不到 telemetry → 下一代 agent 行為改不好 → 更沒人用,這是會複利的劣勢。

他還補了一個很犀利的觀察:Google 內部用的是一套極度客製的源碼控制、build、測試、部署系統,「當你習慣用 Google-scale 的方式想事情,就很難理解業界其他人到底怎麼寫程式」——所以它難以為「一般開發者」設計出順手的 agentic 工具。

如果你想要一句總結,r/google_antigravity 上那串「Anthropic 和 OpenAI 怎麼把 Google 打這麼慘 」的神比喻最到位:

如果 AI 智能是引擎、工具整合是傳動系統:Google 造了更好的引擎,Anthropic 造了更好的車,OpenAI 造了更好的賽車變速箱。 Gemini 有極強的原始大腦,卻完全缺乏可靠驅動工具、讀檔案系統、在 IDE 裡執行程式的「傳動系統」……你是在用法拉利引擎犁田。

最能說明這團混亂的,是一個正在發生的事件。2026 年 5 月的 Google I/O 上,Google 宣布 Gemini CLI 和 Code Assist IDE 擴充將在 6 月 18 日停止對 Pro/Ultra/免費用戶服務 ,全部要遷到新的 Antigravity CLI——一個閉源、用 Go 重寫、發布時還沒有 feature parity 的東西。用開源換閉源、功能還沒齊就逼遷移,AI Builder Club 的遷移指南 乾脆直接建議:個人開發者終端工作流就用 Claude Code,要全開源就用 Aider。自家工具的遷移指南把用戶推給對手,這畫面有夠尷尬。

等等,先別把 Gemini 寫死

罵了這麼多,得講句公道話——Gemini 完全不是沒救,而且把它寫死的人很可能會踩到自己的臉。

矽晶片在日出時發亮,象徵翻盤本錢

第一,便宜、快、context 大這幾張牌是真的硬。Gemini 是前沿模型裡的性價比之王、支援 1M context、多模態,前端/UI 生成出來的東西常常漂亮到不行,Web 版體驗也很順。r/GeminiCLI 有句話很實在:「Gemini 免費,你贏不了免費。」

第二,口碑正在回升。前面那些迴圈災難很多是 2.5 Pro 時代的事。到了 Gemini 3 Pro,Shipyard 在 2026 年 4 月的比較 反而觀察到:「很多用戶覺得 Gemini 3 Pro 比 Claude 更少卡住,更能自己跳出無效迴圈。」注意,這跟前面的舊抱怨剛好相反——這代表 Google 確實在補洞,落差在縮小。而且要公平地說,loop 不是 Gemini 的專利,r/Anthropic 上也有人抱怨 「Claude Code 一碰到複雜邏輯錯誤或 race condition 也會 loop」,只是程度差異。

第三,Google 手裡握著一張別人沒有的牌:自研 TPU。Martin Alderson 的分析很有意思——Gemini 3.5 Flash 跑到 206 tokens/sec,比同期的 Opus 4.8、GPT-5.5 快了大約 4 倍,單位推論成本極低,因為模型和 TPU 是 Google 內部一起設計的。從這個角度看,Gemini 與其說是輸給對手的開發者工具,不如說它根本是「在玩另一場遊戲」:模型很大程度是為 Google 自家海量內部 token 消耗(AI mode、Gmail)而調的。如果哪天它把 agent 那條故事理順,底層的矽晶+研究+整合會讓它非常難纏——「但那是個大大的 if」。

所以真要落到「我現在該用哪個」,我會這樣切:

你的需求建議
要可靠的終端 agent 工作流、多檔 refactorClaude Code / Codex CLI(現階段首選)
預算敏感、大量批次、超長 context、前端 UI、多模態Gemini 3.x(性價比最佳)
想兩邊通吃Claude 規劃+code review,Gemini 大量實作;或 Gemini 分析產報告 → Claude 執行
你還在用 Gemini CLI注意 6/18 停服,評估遷 Antigravity CLI 或改用 Claude Code / Aider

結語:罵之前,先分清楚你在罵哪一層

回到開頭那個矛盾。Gemini 的分數和口碑為什麼差這麼多?因為大家把「模型腦力」「工具可靠度」「組織策略」三件事揉成一句「Gemini 寫程式爛」。

拆開來看其實很清楚:模型那層 Gemini 沒輸,甚至更便宜;真正崩的是 agentic CLI 的可靠度,而它的根因是「模型沒跟工具共生後訓練」這個結構性差距,再被 Google 自己的產品碎片化雪上加霜。

這對我們最大的啟發其實是:在 agentic 時代,harness 跟模型一樣是產品的一半。 下次你覺得某個 AI 工具「很笨」,先停一下——你罵的到底是那顆腦,還是包在外面那層手腳?這兩件事,修起來完全不一樣。

如果你手上同時開著 Claude Code 和 Gemini,不妨拿同一個任務並排跑一次,你會很快親身體會「分數接近、體感天差地遠」是什麼意思——而那個差,正是 harness 的差。至於 6/18 之後 Antigravity 能不能把這層手腳補起來,會是接下來半年最值得盯的指標:Google 的引擎從來不是問題,問題一直是它願不願意專心把車造好。

參考資料

延伸閱讀

CLI Agent 新手入坑:三大家真正共有的 8 個命令(Claude Code / Codex CLI / OpenCode)

三家 CLI Agent 命令匯流主視覺

裝完 Claude Code,第一次在 prompt 敲 /,跳出來 90 幾個命令——這不是誇張,是 我自己 grep 官方 docs 數出來的 。Codex CLI 大概 40 個,OpenCode 大概 20 個。三家加起來破百,你坐在那邊滑著選單想:「我到底要記哪幾個才能開始幹活?」

我也是這樣愣過。後來把三家官方 docs 整個爬一遍,發現一件事:真正三家都有、語意又夠接近的內建命令,只有 8 個。把這 8 個吃透,你就能跨工具切換,不必在每次換家時重學一輪。

這篇是給準備入坑的人看的——不講花俏、不秀進階;講 8 個命令、3 個必踩坑,和一條「第一天就能跑」的工作流。


三大家是誰?要選哪一家入坑?

三家 CLI Agent 對峙示意

先說人是誰:

工具 出身 語言 架構 開源
Claude Code Anthropic 官方 TypeScript / Node.js Standalone 否
Codex CLI OpenAI 官方 Rust Standalone 是(Apache 2.0)
OpenCode sst.dev (GitHub org sst) Go(server)+ TypeScript / Bun(TUI) Client / Server 是(MIT,168k+ stars )

實戰選擇講白話:

  • 想要功能最齊全、Claude 模型強:選 Claude Code ,命令 90 個爆炸給你,連 /stickers(訂貼紙)/voice(語音輸入)都有,廢到笑但有用的也不少。
  • 想要 ChatGPT 訂閱戶免費 + 跑 CI / 自動化:選 Codex CLI ,命令精簡正交,sandbox + approval + plan mode 三層防護做得最嚴。
  • 想要自由換 model、隱私、跨裝置:選 OpenCode ,唯一 client/server 架構,SSH 斷線後重連,跑中的任務還活著——這在跨域工作或長任務時夭壽好用。

三家不必選邊站。我自己是平常 Claude Code 主力、CI 用 Codex、長跑任務或想換 Sonnet/GPT/Gemini 比較時切到 OpenCode。能跨家的關鍵就是接下來這 8 個命令。


三家真正共有的 8 個命令

把三家的官方 slash commands 列表交叉比對之後,所有三個工具都內建、語意相近的命令只有這 8 個:

命令 Claude Code Codex CLI OpenCode 一句話用途
/init 產生 CLAUDE.md 產生 AGENTS.md 產生 AGENTS.md 專案初始化掃描
/clear aliases /reset /new 清螢幕+新對話 /new 的 alias 開新對話
/compact [instructions] 可指定焦點 摘要對話釋放 context alias /summarize 壓縮對話
/help 顯示全部命令 顯示全部命令 顯示全部命令 忘記就敲它
/model / /models 單數 單數 複數 切換模型
/resume [session] 或選單 從本地 transcript alias /sessions /continue 恢復過去 session
/exit / /quit /exit 兩個都收 /exit /quit /q 離開
/diff 含 untracked 含 untracked 沒有原生,用 !git diff 看 Git diff

⚠️ 嚴格講 /diff 在 OpenCode 不是原生 slash 命令,但 OpenCode 支援 ! 前綴跑 shell 命令,敲 !git diff 就行,所以放寬算進來。如果你龜毛,真共有只有 7 個。

8 個命令我幫你分成三組記憶:

開局 / 收工:/init /exit
對話管理:/clear /compact /resume
日常操作:/help /model /diff

這分組不是亂湊的——這正是你在一個 session 從頭到尾會經過的順序。


/init 看似一樣,產物完全不同(最容易踩第一坑)

三家 init 產物示意

三家 /init 都會「掃描你的專案、生成一份 markdown,給 agent 每次對話開頭讀」。但產物檔名不一樣:

  • Claude Code → CLAUDE.md
  • Codex CLI → AGENTS.md
  • OpenCode → AGENTS.md

AGENTS.md 是社群在 2025 年慢慢收斂出來的「跨工具標準」,目前 Codex、OpenCode、Cursor、Amp、Zed 全部採用。只有 Claude Code 還在堅持自家的 CLAUDE.md——這件事在 GitHub 上吵了將近一年(issue #6235 自 2025-08 開到現在),到 2026 年中還沒結論。

那實務上怎麼處理?兩種解法:

解法一:symlink 大法(跨工具團隊推薦)

# 在專案根目錄
touch AGENTS.md
ln -s AGENTS.md CLAUDE.md
# 之後只維護 AGENTS.md,CLAUDE.md 自動跟著動

這招 HN 上 很多人在用 ,乾淨。

解法二:在 CLAUDE.md 內嵌 AGENTS.md

# CLAUDE.md
@AGENTS.md
(其他 Claude 專屬指令…)

Anthropic 官方有承認這招會把 AGENTS.md 內容塞進 system prompt,等同直接讀。

順帶一提:OpenCode 會自動讀 CLAUDE.md——如果你已經寫好 CLAUDE.md 想切到 OpenCode,啥都不用改。Codex 不會,需要自己改名。

還有一個雷:別亂跑 /init

HumanLayer 的這篇 講得直白:自動生成的 CLAUDE.md / AGENTS.md 通常太長,會塞滿每一次對話的 context window,反而降低品質。

實戰建議:/init 第一次跑就好,跑完立刻精簡——只留下 LLM「光看 repo 結構推不出來」的東西(例如:團隊內部用詞、隱私限制、特殊架構決策)。剩下的全刪。50 行就很夠。


/clear vs /compact vs /resume——新手最容易死的三條 alley

對話管理三命令概念

這三個命令長得很像,做的事差很多。我看過太多人把它們搞混,結果不是燒爆 token,就是把重要對話清掉。

/clear——徹底重置

session 開始 → 講了三件事 → /clear → 對話歸零,但檔案改動還在

三家都有,但 alias 略不同:

  • Claude Code:/clear /reset /new 三個都一樣,/clear [name] 還可以順手把舊對話命名存到 /resume 選單裡(這設計超貼心)
  • Codex CLI:/clear 直接清螢幕+開新對話。如果只想清螢幕保留對話,按 Ctrl+L
  • OpenCode:/new 才是本名,/clear 是 alias。前一個 session 自動留在 /sessions 列表

⚠️ 三家都不會還原檔案改動。要還原檔案:

  • OpenCode:/undo(內建用 git 管,乾淨)
  • Claude Code:/rewind(可選「只還原程式碼 / 只還原對話 / 都還原」)
  • Codex CLI:手動 git restore,沒有 slash 命令

/compact——壓縮但保留

session 開始 → 講了 30 件事 → /compact → LLM 摘要前 28 件,最後 2 件保留原樣

三家都有,這是「長對話救命招」。社群公認最大的省 token 技巧不是 /compact,是用 /clear 換題。但如果你「想繼續同一個任務、但 context 已經滿到警告了」,這時 /compact 才出場。

Claude Code 還能帶參數指定保留焦點:

/compact Focus on the auth module and the failing tests

OpenCode 對應命令是 /summarize(與 /compact 互為 alias)。Codex 跑 /compact 會先問你確認再壓——保守派最愛。

/resume——三家「貌合神離」,差異最大

表面三家都做「恢復過去 session」,但底層機制完全不同:

工具 機制 體感
Claude Code 讀存檔的 transcript 重啟 冷啟動,狀態凍結重建
Codex CLI 讀本地存檔的 transcript 復原 類似 Claude,靜態
OpenCode 連回 live 的後台 server session 還活著,跑中任務沒中斷

夭壽,這就是為什麼 Medium 上有篇比較文 一直強調 OpenCode 的「session 持久性」是真差異化——它是唯一不怕 SSH 斷線的工具。

如果你的工作流會涉及長跑任務(測試套件、大型重構、批次處理),這個差異會直接影響你選哪家。


第一天就能跑的 6 步工作流

Day1 工作流流程示意

這套流程在三家 CLI 都通用。把它印出來貼螢幕旁邊,第一週照著做就對了。

# Step 1:進專案
cd /path/to/project

# Step 2:啟動工具(擇一)
claude          # Claude Code
codex           # Codex CLI
opencode        # OpenCode

# Step 3:第一個動作——產生專案說明檔
/init
# 跑完立刻打開 CLAUDE.md / AGENTS.md,刪掉 80% 廢話

# Step 4:開始對話
> 這個專案是做什麼的?先給我一張架構圖

# Step 5:對話一長就壓縮
/compact

# Step 6:commit 前看改動
/diff
# OpenCode 是 !git diff

# 隔天接續
/resume

# 換完全不同的任務時
/clear

# 收工
/exit

口訣(建議背起來):

/init 開局、/clear 換題、/compact 續命、/resume 接班、/diff 防爆、/exit 收工。

學會這 6 個動詞,你就能在三家 CLI 之間自由換家。其他 90+ 個命令是進階課題,等你穩了再慢慢吃。


三家獨家亮點(值得知道但別現在學)

最後留一張小抄,講三家「最值得多看一眼」的獨家命令。第一週不用碰,但知道它們存在,之後遇到痛點才知道要去找哪一家。

Claude Code 獨家

  • /rewind:選擇性回滾「程式碼 / 對話 / 兩者」。我覺得這是 Claude Code 最神的命令,比 git stash 還順手。
  • /btw <question>:「順便問一下」——暫時插隊問問題,不污染主對話。寫到一半想確認某 API 用法時超好用。
  • /security-review:對 pending 變更做安全審查。
  • /skills:列出所有 skill(社群在 這個寶藏地圖 收集了不少)。

Codex CLI 獨家

  • /personality:對話風格(friendly / pragmatic / none)。pragmatic 模式不會跟你寒暄,CI 用爆好。
  • /approve:批准 auto-review 拒絕的動作重試。
  • /experimental:開啟實驗功能,例如 subagents。

OpenCode 獨家

  • /share:產生公開 URL(opncd.ai/s/...),把 session 丟給同事看,連 onboarding 都省了。
  • /unshare:撤回分享。
  • /details / /thinking:toggle 工具細節與思考顯示。debug 神器。

寫在最後:別被命令數量嚇跑

90+ 個命令看起來嚇人,真正用到的就那 8 個。其他都是「你想到時才存在」的工具——遇到痛點才查 /help,不必預先全部記住。

CLI agent 這場仗打到 2026 年,三家已經明顯收斂在共通詞彙上:/init 產說明檔、/clear 換題、/compact 續命、/resume 接班。再過半年大概還會多幾個共通命令(/skills 看起來會收斂、/hooks 也快了),這篇之後我會更新。

入坑就從 /init 開始,跑完刪掉 80% 自動生成的內容,剩下的事就讓 agent 幫你做。


延伸閱讀

Dynamic Workflows 實戰拆解:Claude Opus 4.8 怎麼用 11 天把 Bun 從 Zig 變成 75 萬行 Rust

Dynamic Workflows agent swarm 視覺

2026 年 5 月 28 日,Anthropic 把兩件事捆在同一天發佈:Claude Opus 4.8,跟 Dynamic Workflows in Claude Code。

新模型本來就會有人寫文章拆解,但 Dynamic Workflows 才是我覺得這次發佈真正的 game changer。Anthropic 在公告裡丟出一個 demo:Bun 作者 Jarred Sumner 用 Dynamic Workflows 把整個 Bun runtime 從 Zig 重寫成 Rust,11 天、~75 萬行、99.8% 測試通過率。

這不是「Claude 寫了一段 code」這種尺度。這是過去要拿出 quarter 規劃、開大型 task force 處理的工作量。當然 HN 上立刻有人質疑「mechanical refactor agent 也能做」「這 75 萬行 vibe-coded Rust 到底誰維護」,但作為一個概念驗證,這個尺度在以前是不可想像的。

這篇我想做的不是 review,是拆解:Dynamic Workflows 內部到底怎麼跑?這個 Bun port 的 5 個 phase 各做了什麼?跟舊的 Agent Teams 比差在哪?對一般開發者來說,怎麼用、怎麼控制成本、會踩到什麼雷?

Dynamic Workflows 是什麼?三句話講完

第一句:你在 Claude Code 裡丟一個大任務,Claude 自己寫一份 JavaScript orchestration script。

第二句:runtime 在背景跑數十到數百個 subagent 平行工作,並有另一群 verifier agent 對抗式檢驗。

第三句:全部收斂後,主 session 拿到最終結果——你不用一直盯著螢幕。

跟前一代 Agent Teams 比,差異很關鍵:Agent Teams 是「Claude 開幾個平行對話」,每個 agent 還是吃同一個 context;Dynamic Workflows 是「Claude 寫一個外部 JS 程式」,這個程式自己管狀態,agent 不必擠在同一個 context 裡。

earlyterms 的描述很精準 :「The orchestration logic — loops, branches, intermediate state — lives in code rather than Claude's context window.」

換句話說:workflow 把 Claude 從「context 受限的對話機器」變成「能寫程式調度自己的 orchestrator」。這是質的差異,不是量的差異。

Runtime 硬限制:你寫 prompt 之前要知道的

MarkTechPost 整理出來的 4 條 hard limit :

限制數值意義
同時 concurrent agents16你以為跑 100 個平行,其實同時間只有 16 個在算
單次 run 總 agent 數1,000(hard cap)超過就停
Script 能碰 filesystem 嗎不行orchestration JS 不能讀寫檔,只有 agent 能
Script 能碰 shell 嗎不行同上

Progress 自動 checkpoint,中斷可 resume。這條很重要——跑 4 小時的長任務不會因為 session 斷掉而要從頭來。

為什麼 16 / 1000 這個數字?

Anthropic 沒講,但我推測有兩層原因:

  1. API rate limit 跟 Anthropic 自己 capacity 的考量:1000 agent 同一個 session 跑,每個都吃 token,平均一個 workflow run 燒掉幾百 K token 是常態。
  2. 品質衰減:Anthropic 內部一定做過實驗,超過某個並行數,verifier agent 的對抗式 review 就 catch 不住所有 hallucination。1000 / 16 看起來是「品質 / 成本 / latency」三條曲線的甜蜜點。

觸發方式:兩種寫法

第一種:Prompt 裡有「workflow」這個字

# Claude Code prompt
> create a workflow that migrates every internal fetch() call to the new HttpClient wrapper, updating tests as you go

只要 prompt 包含 workflow,Claude Code 會問你要不要起一個 dynamic workflow。

第二種:開 ultracode 模式

# 在 Claude Code 裡
/effort ultracode

ultracode 等於 effort: xhigh + 自動 workflow orchestration。寫 prompt 不用提 workflow,Claude 自己判斷該不該啟動。

/deep-research 也是 Anthropic 預先寫好的內建 workflow,問問題時直接用 /deep-research <topic>,幾分鐘後拿到一份多 agent 平行檢索 + 對抗式驗證的研究報告。我自己用過幾次,比 Perplexity 跟 ChatGPT Deep Research 都實在——但 token 燒得很兇,Max plan 額度容易被吃。

Bun port 五階段拆解

Conductor 指揮 agent 樂團

回到 Anthropic 那個 demo case。官方公告 跟 natural20 的深度分析 把整個流程拆成 5 個 phase,我整理如下:

Phase 1:Rust lifetime 標註

One workflow mapped the correct Rust lifetime for every struct field in the Zig codebase.

Zig 沒有 Rust 那種 borrow checker 跟 lifetime annotation——Zig 是手動管 memory 的。Rust 移植第一步是給每個 struct field 標出正確的 lifetime('a、'static、'self 等),這對人類工程師來說超花時間。

第一個 workflow 跑數十到數百個 agent,每個 agent 拿一塊 Zig source code 分析 ownership 流,輸出對應 Rust 結構的 lifetime annotation 設計。

這個階段最容易被忽略:這不是寫 Rust,是寫 Rust 之前的「型別系統設計」。Claude 在這個 phase 等於做了一份 high-level architectural design document。

Phase 2:檔案級平行移植

The next workflow wrote every .rs file as a behavior-identical port of its .zig counterpart, hundreds of agents working in parallel with two reviewers on each file.

這是「批次翻譯」階段——每個 Zig 檔對應一個 Rust 檔。數百個 agent 平行跑,每個 file 配 2 個 reviewer。

兩個 reviewer 的設計很妙。一個負責「語意正確」(這段 Rust 跟原 Zig 行為一致嗎),一個負責「Rust idiomatic」(這個寫法是不是 Rust 慣用法)。雙審查機制是 Dynamic Workflows「adversarial verification」的具體應用。

注意:concurrent 上限是 16。所以即使邏輯上「數百個 agent 平行」,實際 runtime 一次只有 16 個在做工。剩下 queued。

Phase 3:Build + Test 修正迴圈

A fix loop then drove the build and test suite until both ran clean.

這是經典的 agentic loop:跑 build → 失敗看錯誤 → 修 → 重跑。Bun 既有 test suite 是「pass bar」,agent 一直循環直到 99.8% test 過。

這個 phase 才是 Dynamic Workflows 真正的價值——它把「我寫了一段 code、不確定對不對」這個過去需要人類拉 PR + reviewer + CI 來確認的工序,內建在 workflow 自己的 loop 裡了。

人類介入點只剩「workflow 結束後決定要不要 merge」。

Phase 4:Overnight 優化

After the port landed, an overnight workflow addressed unnecessary data copies and opened pull requests for final review.

第一輪 port 完成後,又跑了一個夜間 workflow 處理 unnecessary data copies——Rust 跟 Zig 的記憶體模型不一樣,直接翻譯出來的 Rust 會有很多無謂的 clone()。這個 workflow 自動找出來、改成 borrow 或 move,並開 PR 給人 review。

Phase 5:人類最終 review

剩下的就是 Jarred Sumner 本人。Anthropic 強調「the port is not yet in production」,所以這 75 萬行 Rust 還沒進 main branch。

跟 Agent Teams 差在哪?

Opus 4.6 的 Agent Teams 我用過一段時間。它解決的問題是「我想要 Claude 同時 review 3 個東西」這種尺度。Dynamic Workflows 是不同 league。

維度Agent Teams(4.6)Dynamic Workflows(4.8)
觸發Claude Code 設定 + tmux panePrompt 含「workflow」或 ultracode
Agent 上限通常 3-10 個1,000(同時 16)
Context 共享共享同一個 main context獨立:JS script 管 state
中斷恢復不行自動 checkpoint,可 resume
對抗式 review沒內建內建 verifier + refute agent
適合任務PR review、design 對齊、debug 三個假說大規模 migration、codebase audit、long-horizon refactor
Token 預估數萬到數十萬數百萬到上千萬(一次 run)

兩個都還在 Claude Code 裡有用,但是不同層級的工具。

簡單的 rule:

  • 「我想要 3 個 Claude 一起做」→ Agent Teams
  • 「我想要 100 個 Claude 一起做、自己管狀態、自己驗證、跑一整天」→ Dynamic Workflows

實戰預算控制:怎麼不被燒光額度

11 天時間軸的雙塔建造

這是 Dynamic Workflows 最大的雷。Bun port 那個 demo 燒了多少 token?Anthropic 沒公開。但用 1000 agent × 每個平均 50K token × verification overhead = 上千萬 token 級的 input + output。

對 Max plan 用戶來說,一次中型 workflow 就能把週額度吃光。怎麼控制?

1. 用 task_budget 設硬上限

Opus 4.7 引入的 task_budget public beta 沿用到 4.8。它跟 max_tokens 不一樣——max_tokens 是 per-request 硬上限,task_budget 是「整個 agentic loop」的 advisory cap。

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=64000,
    output_config={
        "effort": "high",
        "task_budget": 500000  # 整個任務最多燒 50 萬 token
    },
    messages=[...]
)

Workflow 自己會看 task_budget 殘量,動態調整要不要 spawn 更多 subagent。沒設這個就等於放任 Claude 燒。實際參數名稱可能依 SDK 版本略有差異,使用前請對照官方 docs 確認。

2. 從小 module 開始試水溫

不要第一次用 Dynamic Workflows 就丟整個 codebase。先選一個 ~5,000 行的 module 跑跑看,看 token 燒法跟結果品質,再評估能不能 scale 到 100,000 行。

I Migrated to Claude Opus 4.8 那篇 migration guide 給出的建議很實際:「Scope tightly and start with one module, not your whole codebase」。

3. 別把 Dynamic Workflows 當 Fast Mode 用

4.8 同時推出的 Fast Mode($10/$50 per million tokens,2.5× 速度 )跟 Dynamic Workflows 是兩條不同的線。

你想要什麼用哪個
同個 prompt 但更快回應Fast Mode
一個 prompt 拆成 100 個平行子任務Dynamic Workflows
大量探索性 query、不在乎品質但在乎速度Fast Mode
大型 audit / migration、要 verifier 對抗式 checkDynamic Workflows

兩個都很貴,但用錯場景會更慘——例如把 Fast Mode 拿去跑 codebase audit,速度有但品質下降;把 Dynamic Workflows 拿去跑互動聊天,agent overhead 把 latency 拉到 30 秒。

4. 跑前先用 /deep-research 看 cost 樣本

Claude Code 內建的 /deep-research 是一個現成的 workflow demo。隨便丟一個研究問題給它,看它最後回報的 token 用量。這個數字可以當你估自己 workflow 的 baseline。

我自己粗估跑一個中型 deep-research,燒掉百萬等級 token、十幾分鐘是合理 ballpark;實際數字隨主題複雜度跟資料量浮動很大,要看你自己的 telemetry 才準。

命名巧合:Cloudflare 也叫 Dynamic Workflows

題外話,但很妙的事。

2026-05-01,Cloudflare 也發佈了名為「Dynamic Workflows」的產品——是一個 per-tenant durable execution library for Workers。跟 Anthropic 完全無關。

5 月 28 日 Anthropic 也發了 Dynamic Workflows,但兩家公司互不提及對方。

earlyterms 對這件事的記錄 :

Two Products, Same Name: Why Cloudflare and Anthropic Both Chose 'Dynamic Workflows' in May 2026

兩家都是大廠,撞名不太可能是巧合——大概率是同一個技術 buzz term 同時被兩邊產品團隊鎖定。實務上要注意:你 google「dynamic workflows」會夾雜 Cloudflare 的東西。

我自己用 Dynamic Workflows 幾天的感想

對重度 Claude Code 用戶來說,Dynamic Workflows 改變了「我能做多大尺度的事」這個直覺。

過去我在 Claude Code 裡會自我設限:「這個 task 太大、context 裝不下、不要叫 Claude 做」。現在的判斷變成:「這個 task 太大 → 寫成 workflow 讓它自己拆」。

但有兩個雷:

第一:workflow planning 階段品質很受 prompt 影響。如果你給的 prompt 含糊、目標不清楚,Claude 寫出來的 orchestration JS 也跟著爛。我建議寫 workflow prompt 時先給 Claude 一份「task spec」,包含目標、約束、acceptance criteria,再叫它寫 workflow。

第二:verifier agent 不是萬靈丹。對抗式 review catch hallucination 的能力有上限——如果整個 workflow 的所有 agent 都基於同一個錯誤假設,verifier 也救不了你。Bun port 那個 case 之所以成功,部分是因為「behavior-identical port」這個 acceptance criteria 非常具體(既有 test suite 就是 ground truth)。對沒有明確 ground truth 的任務(產品設計、UX 決策),Dynamic Workflows 的可信度大幅下降。

寫到最後

Dynamic Workflows 不是「Claude 變強」,是「Claude 變成 orchestrator」。這個位置變動的意義比模型本體的 benchmark 進步重要很多——它把 Claude 從「我給它一個 task 它回我一段答案」變成「我給它一個專案它自己組軍隊跑」。

對個人開發者來說,這意味著「我可以承擔的 task 尺度上升一個量級」。對企業來說,意味著「過去要規劃 quarter 的 migration,現在規劃 sprint」。對 Anthropic 來說,意味著「我們不只賣 LLM,我們賣 LLM 編出來的軍隊」。

當然,Bun port 還沒進 production,這個 demo 是不是真的 work 還要時間驗證。HN 上「這幾十萬行 vibe-coded Rust 到底誰維護」的質疑很犀利。Dynamic Workflows 的成本曲線、品質曲線、適用場景,都還需要社群更多實戰才能畫清楚。

但工具已經出來了。下一個季度,會看到的不是「誰的 LLM 比較聰明」,是「誰的 LLM 比較會組軍隊」。Anthropic 在這條線上跑出了第一個能 demo 給大家看的版本,這個位置可能會撐很久。

夭壽,下次有人說「我寫了 100 萬行程式」,記得先問一句:「是你寫的,還是你的 workflow 寫的?」

延伸閱讀

8GB 的 RK3588 能跑多聰明的 LLM?ROCK 5C 用 NPU 實測 5 個模型

先講結論,省得你滑到最後: 在一片 8GB 的 RK3588 板子上,用 NPU 跑得最聰明的是 Qwen3-4B-Instruct-2507,我出的 7 題全對,但每秒只吐 3.7 個 token。 想要順一點的對話體驗,Qwen3.5-2B 的 8.4 tok/s 是比...