# 策展 · X (Twitter) 🔥🔥🔥

> 📖 本站完整內容索引（documentation index）：[llms.txt](/llms.txt)

> 作者：elvis (@omarsar0) · 平台：X (Twitter) · 日期：2026-06-20

> 原始來源：https://x.com/omarsar0/status/2068008743153832264

## 中文摘要

# 從 Prompting Agents 到 Loop Engineering

AI 程式開發圈流傳著一個說法：別再對你的程式開發 Agent 下 Prompt 了，開始設計能替你下 Prompt 的「迴圈（Loop）」吧。就像所有新事物一樣，這類觀點總是被反覆提及，卻鮮少有人解釋清楚。這是一篇實務指南，說明什麼是 Agent 迴圈、為什麼它很重要，以及在生產環境中它長什麼樣子。

以下是我從與學生、技術創辦人、AI 工程師及新創公司進行的實驗、研究與對談中整理出的心得（由 Claude 協助撰寫）。

你也可以將我們最近的直播課程「自主長效型程式開發 Agent（Autonomous Long-Running Coding Agents）」作為切入點，深入了解這些概念。

## 這個說法的由來

> 「你不需要再對程式開發 Agent 下 Prompt 了。你應該設計能對 Agent 下 Prompt 的迴圈。」—— Peter Steinberger (@steipete)，2026 年 6 月 7 日。220 萬次觀看。原始推文

Claude Code 的開發者 Boris Cherny 也從另一個角度提出了相同的觀點。

> 「我不再對 Claude 下 Prompt 了。我執行的是迴圈。是這些迴圈在對 Claude 下 Prompt 並決定該做什麼。我的工作是撰寫迴圈。」—— Boris Cherny (@bcherny)。原始推文

重點並非 Prompt Engineering 已死。透過 Loop Engineering，工作層級向上提升了：從撰寫程式碼轉變為撰寫「負責撰寫程式碼的系統」。在這個領域進展最快的開發者表示，他們曾有數個月的時間，在完全沒開啟 IDE 的情況下發送了數百個 PR，每一行程式碼皆由 Agent 完成。

## 什麼是迴圈（Loop）？

迴圈是一個你撰寫的小型程式，它執行四件事：

- 替你向程式開發 Agent 下 Prompt；
- 讀取 Agent 的產出；
- 判斷任務是否完成；
- 若未完成，則帶著錯誤訊息或下一步指令再次向它下 Prompt。

你不再需要坐在迴圈裡手動輸入 Prompt；你撰寫迴圈，而模型則成為該迴圈呼叫的一個子常式（subroutine）。

![這是一張展示自動化工作流程循環的邏輯流程圖，描述了從目標設定到執行、驗證及錯誤反饋的過程。](https://pub-75d4fe1e4e80421b9ecb1245a7ae0d1a.r2.dev/curated/d1ec9e3a8e511756.png)

<details class="chart-data"><summary>展開畫面重點</summary><div class="me-note">該流程圖由四個主要節點組成，箭頭指示了處理順序：
1. 「goal + state」（目標與狀態）：流程的起點。
2. 「act」（執行）：包含「edit / run / tool」（編輯／執行／工具）功能。
3. 「check」（檢查）：包含「tests / verifier」（測試／驗證器）功能。
4. 「stop + report」（停止與報告）：流程的終點。

流程邏輯說明：
- 當「check」階段結果為「pass」（通過）時，流程會導向「stop + report」。
- 當「check」階段失敗時，會透過一條虛線箭頭回饋至「act」階段，標註文字為「fail: feed the error back」（失敗：將錯誤回饋）。</div></details>

其運作模式始終如一：設定目標、執行、檢查、回饋錯誤，並重複此過程，直到檢查通過或迴圈自行停止。

## 「迴圈」至少代表五種含義

許多爭論源於人們用同一個詞指代五種不同的概念。以下是從最舊到最新的演進：

![這是一張展示 AI 代理（AI Agents）自主性演進路徑的流程圖。](https://pub-75d4fe1e4e80421b9ecb1245a7ae0d1a.r2.dev/curated/3f7d1a5376974385.jpg)

<details class="chart-data"><summary>展開畫面重點</summary><div class="me-note">該圖表以階梯狀呈現 AI 代理技術的發展歷程，從左下角的「較舊」技術演進至右上角的「較新」技術，並註明「每一階層都更具自主性」。圖中包含五個階段的節點：
1. ReAct (2022, reason / act / observe)
2. AutoGPT (2023, self-prompting goal)
3. ralph loop (context reset each turn)
4. /loop and /goal (cadence + completion built in)
5. orchestration (one author, many agents)</div></details>

- **ReAct (2022)**：最初的研究模式：推理（Reason）、行動（Act）、觀察（Observe），然後重複。
- **AutoGPT (2023)**：一個自我 Prompt 的目標迴圈，以「不知道何時該停止」而聞名。
- **ralph 迴圈**：在每次迭代之間刻意重置 context，避免 Agent 淹沒在自己的歷史紀錄中。
- **/loop 與 /goal**：將節奏與完成條件內建於 Agent 中，並在不同回合間維持狀態。
- **Orchestration（編排）**：由一個主控端分派多個 Agent，讀取你的 GitHub、Slack 與聊天紀錄，並決定下一步該建構什麼。

## 你實際組裝的零件

上述演進解釋了人們口中的「迴圈」意指為何；以下是建構迴圈所需的基礎。這六個零件在每次組裝時都會出現，且現在大多數已內建於程式開發工具中，不再需要你自行維護自訂腳本。

![這張圖表列出了構建自動化迴圈系統所需的六個關鍵組成部分。](https://pub-75d4fe1e4e80421b9ecb1245a7ae0d1a.r2.dev/curated/63c67e54490b458b.png)

<details class="chart-data"><summary>展開畫面重點</summary><div class="me-note">圖片標題為「The six parts you assemble into a loop」（你組裝成迴圈的六個部分），內容包含六個編號項目：
1. Trigger（觸發器）：包含 schedule（排程）、webhook、PR label（PR 標籤）。
2. Isolation（隔離）：包含 a git worktree per agent（每個代理一個 git 工作樹）。
3. Written-down context（書面上下文）：包含 conventions it reads each run（每次執行時讀取的慣例）。
4. Tool access（工具存取）：包含 issue tracker（問題追蹤）、CI、DB（資料庫）、chat（聊天）。
5. A second agent（第二個代理）：包含 grades the work, held apart（評分工作，並保持分開）。
6. State on disk（磁碟上的狀態）：包含 markdown、board（看板）、queue（佇列）。</div></details>

- **觸發器（Trigger）**：無需你手動啟動，就能自動開始迴圈的機制：排程、webhook、檔案變更，或 PR 被貼上標籤。這是區分「真實迴圈」與「手動重複執行」的關鍵。
- **隔離（Isolation）**：每個 Agent 擁有獨立的 checkout（通常是 git worktree），確保同時執行的兩個 Agent 不會覆寫彼此的檔案。一旦你同時執行超過一個 Agent，這就不再是選項，而是必要條件。
- **書面化的 context**：將慣例、建置步驟與專案特定規則存放在 Agent 每次執行時都能讀取的地方。若忽略此點，迴圈會在每次執行時重新推導你的專案，並對缺失的部分進行猜測。
- **工具存取權（Reach into your tools）**：連接到 Issue Tracker、CI、資料庫與聊天軟體，讓迴圈能直接開啟 PR、連結 Ticket 並發布結果，而不是只列印出修正方案，還要等你手動執行後續步驟。
- **第二個 Agent 檢查**：由一個獨立的執行者評估輸出結果，且該執行者必須與產出結果的 Agent 分開，因為模型若審核自己的工作，幾乎所有內容都會通過。
- **磁碟上的狀態（State on disk）**：Markdown 檔案、看板或佇列：任何存在於對話之外、能記錄「已完成」與「下一步」的媒介。模型在執行間會遺忘，但檔案不會。

組裝好這六個零件，你就為 Loop Engineering 打下了良好的基礎。過去你必須手動打造一切；現在大多數功能已作為內建特性提供，這也是為什麼這種模式已從邊緣技術轉變為常見用法。

## 具體迴圈範例：PR 保姆

一個你今天就能建構的具體範例：

![這是一張說明「PR 保姆」自動化流程的邏輯架構圖，展示了從定時觸發到診斷與執行動作的完整循環。](https://pub-75d4fe1e4e80421b9ecb1245a7ae0d1a.r2.dev/curated/41a680cf8f628842.png)

<details class="chart-data"><summary>展開畫面重點</summary><div class="me-note">該圖表描述了一個名為「The PR babysitter, one scheduled run」的自動化工作流程，包含以下步驟與邏輯：

1. **觸發機制**：每 15 分鐘（every 15 min）進行一次排程觸發（scheduled trigger）。
2. **篩選對象**：針對標記為「agent-watch」的開啟中 PR（open PRs）。
3. **診斷階段**：進行診斷（diagnose），檢查 CI 是否失敗（CI red?）或主分支是否有變動（main moved?）。
4. **執行動作**：執行單次動作（act once），進行修復或重定基底（fix or rebase）。
5. **停止條件**：若 CI 顯示綠燈（CI green）則合併 PR；若預算耗盡（1 次修復、5 分鐘、10 個檔案）則停止並通知人類（stop and ping a human）。</div></details>

- **觸發器**：每 15 分鐘執行一次。
- **範圍**：標記為 `agent-watch` 的開放 PR。
- **行動**：若 CI 因為確定性原因失敗，嘗試一次修正。若主分支有更新，執行一次 rebase。
- **預算**：每個 PR 僅限一次修正嘗試、五分鐘時間、變更十個檔案。
- **停止條件**：CI 變為綠燈，或預算耗盡，隨後停止並通知人類。

你將面對的是已合併的 PR，而不是積壓的故障建置。同樣的邏輯適用於大多數維運工作：

- **CI 健康度**：每 30 分鐘抓取失敗的執行紀錄並按特徵分類，讓十個因相同根本原因導致失敗的 PR，變成一個需要處理的問題。
- **部署驗證**：推送後，呼叫你的 API 端點，確認回傳 200 且內容符合預期，並在使用者發現前標記回歸錯誤（regression）。
- **回饋分類**：每 30 分鐘從你的頻道抓取留言，將其分組為主題，並將每個群組對應到負責該功能的檔案或文件。

## 使用 /goal 的 Claude Code 迴圈

「保姆」是你自己接線組裝的迴圈；觀察內建於 Agent 內部的迴圈也很有幫助。在 Claude Code 中，最小的完整迴圈是 `/goal`：你給它一個可驗證的終止狀態，它會持續運作直到該狀態達成。

![這是一張展示 AI 代理（Agent）工作流程的邏輯架構圖，描述了從設定條件、執行任務到評估結果的循環過程。](https://pub-75d4fe1e4e80421b9ecb1245a7ae0d1a.r2.dev/curated/9fa1ef5ddb8e28f0.png)

<details class="chart-data"><summary>展開畫面重點</summary><div class="me-note">此圖表呈現了一個自動化代理的運作迴圈，包含以下四個主要節點：
1. **set condition**（設定條件）：作為流程起點，標註為「first turn starts」（第一回合開始）。
2. **agent works a turn**（代理執行回合）：標註為「edit / run tests」（編輯／執行測試）。
3. **evaluator checks**（評估器檢查）：標註為「fast model: met?」（快速模型：是否達成目標？）。
4. **goal clears**（達成目標）：標註為「stop + report」（停止並報告）。

流程邏輯：
- 若評估結果為「yes」（是），流程進入「goal clears」節點並結束。
- 若評估結果為「no」（否），則透過虛線箭頭回饋至「agent works a turn」，並標註「no: another turn with guidance, state carried across turns」（否：帶著指引進行下一回合，狀態會在回合間保留）。</div></details>

以下是在 Claude Code 中作為會話指令使用 `/goal` 的範例。你啟動會話，然後在內部設定目標：

```bash
$ claude  # 啟動 Claude Code
$ /goal tests in test/auth pass   # 在會話中設定目標
```

這與前面提到的「行動、檢查、重複」模式相同，且內建了驗證器。

此時很明顯，一個強大的 `/goal` 讀起來不像 Prompt，更像是一份合約。好的目標設定會明確指出四件事：你想要的終止狀態、證明已達成的證據、Agent 在達成過程中不得違反的限制，以及允許消耗的工作預算。若其中任何一項模糊不清，模型就會以最簡單的方式填補空缺：提前停止、走捷徑，或重新定義成功，導致對話紀錄看起來完成了，但實際系統卻是壞的。

- **設定條件**：輸入 `/goal` 加上可檢查的終止狀態，例如 `/goal tests in test/auth pass`。第一回合會立即開始。
- **Agent 執行回合**：它進行編輯、執行測試，並在會話中呈現結果。
- **評估器檢查**：一個快速的模型讀取對話紀錄並判斷是否達成，確保 Agent 不會自己評分自己的工作。
- **迴圈或結束**：未達成則帶著指引進入下一回合；達成則目標自動清除，執行停止。

狀態會在回合間保留，因此它不會提前退出或中途放棄限制。幾個控制項能確保其可靠性：

- **讓檢查可量化**：測試結果、結束代碼（exit code）、檔案數量或空佇列。`npm test` 結束代碼為 0 是一個目標；「把它變好」則不是。
- **限制執行次數**：加上類似「或 20 回合後停止」的條件，讓卡住的迴圈能停止，而不是浪費回合數。
- **搭配自動模式（auto mode）**：讓回合在無人看管下執行，並使用 `/goal clear` 提前放棄任務。

評估器步驟隱藏了一個有用的細節：檢查者不一定要與編碼者是同一個模型。一旦迴圈具有明確的角色（規劃者、執行者、評估者、視覺審核者），每個角色都可以執行在不同的模型上，選擇哪個模型擔任哪個角色成為了架構決策，而不是單純押注在某個「最強」的程式開發 Agent 上。有些模型擅長規劃，有些執行成本更低，有些能更準確地判斷螢幕截圖，而一個好的編排器（orchestrator）讓你能在每個角色間切換，而不必等待單一供應商在所有類別中勝出。

這對於 API 遷移（移動每個呼叫點直到編譯通過且測試成功）、重構（拆分檔案直到每個模組符合預算）、Issue 積壓處理（處理標記佇列直到清空）以及 Eval 迴圈（調整 Prompt 直到分數超過門檻）都非常有效。`/loop` 是針對沒有單一終點線工作的對應功能：它不是根據完成條件，而是按排程重新下 Prompt，這就是像 PR 保姆這類迴圈持續運作的方式。

## 無人看管地執行多個迴圈

單一 `/goal` 是一個 Agent 朝著一個終點線努力。執行多個無人看管的程序會提高風險，因為迴圈的可靠性取決於它檢查自身工作的能力。Cherny 讓 Opus 自主執行數小時的設定歸納為五個步驟：

1. **自動批准權限**：這樣 Agent 就不會因為每個工具呼叫都要詢問而停止。
2. **使用動態工作流**：將 `Ultracode` 放入 Prompt 中，以分派給多個 Agent，而不是單一序列執行緒。
3. **使用 `/goal` 或 `/loop`**：維持運作。`/goal` 設定完成條件，`/loop` 按排程重新下 Prompt，兩者皆會保留狀態，確保不會提前退出。
4. **在雲端執行（桌面或行動 App）**：確保當你關上筆電時，會話依然存活。
5. **提供端到端的自我驗證方式**：網頁版使用 Chrome 中的 Claude、行動裝置使用模擬器 MCP，後端則使用 Live Server。這是讓前四點變得安全的關鍵步驟。

完整序列：

```bash
claude --permission-mode auto                          # 1 · 無需批准 Prompt
ultracode  orchestrate sub-agents to ship the feature  # 2 · 分派任務
/goal all tests pass and the demo loads clean          # 3 · 持續運作
→ cloud / desktop app                                  # 4 · 關上筆電
→ chrome ext · sim MCP · live server                   # 5 · 自我驗證，隨後停止
```

## crabfleet：作為產品的編排

有了具體工具，編排就更容易想像。Peter Steinberger 的 `crabfleet` 是一個 OpenClaw 專案，被稱為「Agent 執行的任務控制中心」，它是一個封裝成產品的迴圈，其形狀對應了上述所有概念。

![這是一張展示工作流程看板（Kanban）概念的圖表，說明任務從待辦到完成的執行路徑。](https://pub-75d4fe1e4e80421b9ecb1245a7ae0d1a.r2.dev/curated/7aa922cad6de9500.jpg)

<details class="chart-data"><summary>展開畫面重點</summary><div class="me-note">該圖表呈現了一個四階段的工作流程看板，從左至右分別為：
1. **todo**：包含「a card」，下方註記「prompt / issue / PR」。
2. **running**：包含「executing」，下方註記「durable run, heartbeats」。
3. **human review**：包含「awaiting review」，下方註記「the stop-and-report gate」。
4. **done**：包含「merged」，下方註記「loop closed」。

圖表底部有一條虛線箭頭，從「todo」欄位指向「done」欄位，並附帶文字說明：「one run moves left to right, the board is the loop's queue and its human gate」。整體設計旨在表達自動化流程中，任務如何透過看板機制進行管理，並在特定階段加入人工審核環節。</div></details>

- **以看板上的卡片形式工作**：任務以 Prompt、GitHub Issue 或 PR 建立的卡片形式輸入，然後經過「待辦」、「執行中」、「人工審核」與「完成」階段。該看板就是迴圈的佇列及其「停止並報告」步驟的可視化呈現。
- **持久化執行，而非「射後不理」**：每次執行都是帶有心跳訊號的追蹤嘗試，因此當你移開視線時它會持續運作，且在關閉筆電後依然存活。只有當執行環境宣告支援交接時，你才介入。
- **Agent 產生 Agent**：一次執行可以啟動子會話、發送訊息、讀取對話紀錄，並在沙盒內更新自己的摘要：磁碟記憶與分派任務集於一身，一個作者與多個 Agent。

它執行在帶有瀏覽器終端的可拋棄式雲端沙盒中，這使得離開無人看管的執行變得安全。重點不在於特定工具，而在於迴圈已經硬化為基礎設施：佇列、持久化執行、分派任務與人工審核閘門，現在都是你可以設定的項目，而不是每次都要手動編寫腳本。

## 現在成本花在哪裡？

兩年來，AI 程式開發的成本問題很簡單：哪個模型，以及多少 token。在迴圈內部，這種直覺指向了錯誤的層級。支出不再是單一呼叫，而是迴圈循環的次數，因此一個在收斂前重試六次的迴圈，其成本是第一次就成功的迴圈的六倍（使用相同模型）。

這改變了優化重點：

- **迭代次數是預算項目，而非 token**。一個較便宜但需要循環兩次以上的模型並不划算，因此請追蹤「每個完成任務的成本」，而非「每次呼叫的成本」。
- **脆弱的驗證器是你可能發布的最昂貴 Bug**。如果決定「完成」的檢查標準太寬鬆，迴圈要麼在錯誤的工作上提前停止，要麼在已經沒問題的工作上持續空轉，兩者都會浪費整個迭代。在做任何事之前，先加強這一點。
- **快速失敗（Failing fast）是一種成本控制**。一個對連續失敗沒有上限的迴圈不會最終成功；它最終會耗盡帳戶，因此停止條件對帳單的保護作用，就如同對程式庫的保護一樣重要。

過去你調整 Prompt；現在你調整迴圈，因為成本就是在那裡累積的。

## 何時不該使用迴圈

迴圈在任務重複且機器能判斷何時完成時最有效。除此之外，迴圈只會自動化繁瑣工作。在以下情況請跳過它：

- **一次性編輯**：如果你能一次完成，迴圈純粹是額外負擔。
- **無範圍或探索性工作**：「找出使用者流失的原因」沒有通過條件，因此迴圈永遠無法收斂。
- **任何缺乏廉價自動化檢查的工作**：如果唯一的驗證者是你自己的眼睛，那你還是在迴圈內。先建立檢查機制，或者手動完成任務。

## 可能會出錯的地方

一個在你睡覺時執行的迴圈也會在你睡覺時犯錯，且失敗模式是可以預測的。

- **驗證負擔依然在人類身上**：迴圈寫程式的速度比你審核的速度快，所以如果你停止閱讀 diff，你並沒有消除工作，只是將其延後了。
- **理解差距擴大**：發布你沒寫過的程式碼，速度快到你無法吸收，這會侵蝕你對自身系統的模型，而這筆債務會在下次事故時連本帶利討回。
- **寬鬆檢查導致的隱性偏移**：脆弱的驗證器讓錯誤但「通過」的工作在每次迭代中溜過，因此迴圈看起來很有生產力，實際上卻在挖坑。

以上皆非反對迴圈的理由；這正是為什麼設計迴圈的工程師變得更重要，而非更不重要。

## 如何建立你自己的迴圈

![這是一張展示自動化任務執行流程的循環架構圖。](https://pub-75d4fe1e4e80421b9ecb1245a7ae0d1a.r2.dev/curated/ca3e0b2fadd5bf9e.jpg)

<details class="chart-data"><summary>展開畫面重點</summary><div class="me-note">該圖表呈現了一個自動化作業的循環流程，包含六個主要步驟，並透過箭頭指示順序：
1. pick a task（選擇任務）
2. scope tight（縮小範圍）
3. budget + stop（預算與停止條件）
4. verifier（驗證器）
5. cadence（節奏/頻率）
6. memory on disk（磁碟記憶體）

圖表底部有一條虛線箭頭，從「memory on disk」指向「pick a task」，並附註說明：「run it on a cadence, every loop reads memory and repeats」（以特定節奏執行，每個循環讀取記憶體並重複）。</div></details>

1. **選擇一個可重複的任務**：照顧 PR、修復 CI、驗證部署：從例行工作開始。
2. **嚴格限制範圍**：「修復帳單 webhook 驗證，僅限修改 `app/api/billing` 與 `lib/billing`」勝過「修復 Bug」。鬆散的迴圈會漫無目的。
3. **給予預算與停止條件**：最大嘗試次數、最大執行時間、最大檔案數、最大支出、最大連續失敗次數。無人看管執行的迴圈，也是無人看管地犯錯的迴圈。
4. **加入獨立驗證器**：由獨立的子 Agent 評分工作，因為寫程式的 Agent 是判斷工作是否完成的最差人選。
5. **按節奏執行**：使用 `/loop` 設定間隔、cron 設定排程、生命週期鉤子，或 GitHub Actions，確保它在關閉筆電後依然存活。
6. **將記憶存放在磁碟上**：模型在執行間會遺忘，因此狀態應存在 Markdown 或看板中，而非 context window 裡。

總結：現在，迴圈而非模型，才是昂貴且容易出錯的部分。建構它時，請保持身為負責輸出的工程師心態，而不僅僅是啟動執行的人。

如果你發現任何錯誤或需要進一步澄清的地方，請隨時與我聯繫。

## 其他參考資料

- Addy Osmani (@addyosmani)，關於 AI 輔助程式開發迴圈
- Matt Van Horn (@mvanhorn)，"WTF Is a Loop?"
- Peter Steinberger (@steipete)，關於設計迴圈
- Boris Cherny (@bcherny)，關於自主執行 Agent

## 標籤

Agent, Loop Engineering, 教學資源, Skills, Anthropic, Claude
