2026年2月3日星期二

如何讓 OpenAI Codex 執行⌈長步驟⌋任務

 https://chatgpt.com/share/698283e7-a4dc-8010-8bb1-fe2de89cb968

如何讓 OpenAI Codex 執行⌈長步驟⌋任務 

 If put my tasks into a file as so call batch jobs like:
1) Read file x1 find out value x11
2) Read file x2 find out value x12
3) Read file x3 find out value x13
4) Read file x4 find out value x14
... suppose my file really have 100 lines here
100) Read file x100 find out value x1100

Will Codex do a good job to following this 100 steps strictly comply with?

 

大方向：可以做到，但唔應該期望「一次過 100 步、零偏差、完全嚴格」，尤其當每一步都要讀唔同檔案、抽唔同欄位/值、再彙總。原因唔係 Codex “唔夠智能”，而係：

  • LLM 仍然可能「漏一步／跳步／自作主張改流程」

  • token / 注意力會令長清單更易出錯

  • 其中一兩個檔案格式少少唔同，就會令後面連鎖失誤

  • 若冇機械式驗證（tests / schema / checksums），佢可能自信地交錯答案

不過你可以用設計方法令佢非常接近「嚴格執行」。

你想要「100 steps strictly comply」：用呢個心法

把「100 個自然語言步驟」變成：

  1. 結構化任務清單（machine-readable）

  2. 每步都有可驗證輸出（JSON schema / line-by-line log）

  3. 分批執行 + checkpoint（例如每 10 步一批）

  4. 失敗就停止（fail fast），唔好硬繼續

方案 A：最穩陣（推薦）— spec 檔 + JSON Schema + fail-fast

你寫一個 job.json（或 YAML）：

{
  "tasks": [
    { "id": 1, "file": "x1.csv", "extract": "x11", "type": "number" },
    { "id": 2, "file": "x2.csv", "extract": "x12", "type": "number" }
    // ...
  ]
}

然後跑：

codex exec "Execute tasks in job.json in order. 
For each task: read file, extract the required value, and append one line to results.jsonl. 
If any task fails, stop immediately and report the failing task id."

並要求輸出 JSONL（一行一個 task result），例如：

{"id":1,"file":"x1.csv","extract":"x11","value":123,"status":"ok"}
{"id":2,"file":"x2.csv","extract":"x12","value":456,"status":"ok"}

好處：

  • 你可以檢查有冇漏 id（1..100）

  • 可以寫 script 驗證 count=100、missing ids、status != ok 就 fail

如果你用 Codex 官方 non-interactive 方式，仲可以用 --output-schema 強制輸出格式（對「嚴格」好有用）。你之前問 JSON/YAML，其實 JSON schema 呢個方向就係為咗嚴格輸出。

方案 B：仍然用自然語言 100 行，但要加「執行規則」

如果你堅持寫成：

  1. Read file x1 find out value x11

  2. Read file x2 find out value x12
    …

你至少要喺檔案開頭加一段「操作規則」，例如：

  • 必須逐條執行，唔可以合併/跳步

  • 每完成一步要輸出一條 log：DONE <step#>: <value>

  • 必須產生 step 1..100 全部 log，缺一不可

  • 任一步找不到值就 STOP，唔可以猜

咁做會比「純 100 行」好好多，但仍然冇方案 A 咁穩。

方案 C：100 步拆成 10×10（最實際）

你可以將 spec 拆成 10 個檔（或同一檔分 10 段）：

  • batch_01_10.md

  • batch_11_20.md

  • …

  • batch_91_100.md

每次跑一段，產生 checkpoint。
萬一第 37 步死咗，你唔使重跑前 36 步。

結論：Codex 會唔會「好好跟足 100 steps」？

  • 如果你只係俾 100 行自然語言步驟：有一定機會漏/跳/改流程（風險偏高）

  • 如果你用結構化 task list + 每步可驗證輸出 + fail-fast + 分批 checkpoint：可以做到非常可靠，接近你講嘅「strictly comply」

如果你話我知：

  • 你啲檔係 CSV / JSON / TXT / SQL？

  • “value x11” 係指定欄位名？定係 pattern？定係要計算？

  • 最終你想要一個總表（Excel/CSV/JSON）定係單純抽值？

我可以直接幫你設計一個 job.yaml/job.json 模板（100 steps 都可自動生成）同一條 codex exec ... 指令，令你跑批次任務穩陣得多。

 

如何將我設計好的 Task ， SubTasks 結構告知 Codex ？
這樣做是否可以避免 token 太長而出現無法避免的偏差？

 

可以，而且「用結構化 task / subtasks 告知 Codex」正正係避免偏差、避免 token 太長最有效嘅方法之一——不過要明白：**唔係靠一次性長 prompt 去塞晒，而係靠「短 prompt + 外部 spec 檔 + 可驗證輸出 + 分段 checkpoint」**去做。

下面我用你嘅語境（Task / SubTasks）講一個可落地做法。

1) 最實用方法：用 repo 內的「任務規格檔」做 Source of Truth

你可以用 YAML / JSON 放 Task / SubTasks（機械可讀），例如 tasks.yaml：

version: 1
project: extract-values
rules:
  order: strict          # 必須按順序
  fail_fast: true        # 一步失敗就停
  no_guess: true         # 唔可以估
  log: results.jsonl     # 每一步都要寫log

tasks:
  - id: 1
    name: "Extract x11"
    input: { path: "x1.csv" }
    subtasks:
      - id: "1.1"
        action: "read_csv"
      - id: "1.2"
        action: "extract"
        selector: { column: "x11" }
      - id: "1.3"
        action: "write_result"
        output:
          format: "jsonl"
          fields: ["id","subtask","file","selector","value","status"]

  - id: 2
    name: "Extract x12"
    input: { path: "x2.csv" }
    subtasks:
      - id: "2.1"
        action: "read_csv"
      - id: "2.2"
        action: "extract"
        selector: { column: "x12" }
      - id: "2.3"
        action: "write_result"

然後你用一條好短嘅命令叫 Codex 跟 spec 做：

codex exec "Open tasks.yaml and execute tasks strictly in order. Produce results.jsonl. If any subtask fails, stop and report the failing id."

好處：

  • prompt 唔再長：只有「跟 tasks.yaml 做」

  • 任務內容喺檔案（可版本管理、可 review、可重跑）

  • 你可以用 script 驗證 results.jsonl 有冇齊 1..100

2) 呢樣做「係咪可以避免 token 太長偏差」？

可以大幅降低，但唔係 100% 消失。

會改善嘅原因

  • 你唔使喺 prompt 放 100 條步驟 → token 減好多

  • 模型唔使「靠記憶」保存整個清單 → 少咗漏步/跳步

  • 每步有明確 id、明確輸出 → 更容易 self-check

仍然可能出錯嘅原因

  • 某些檔案格式唔一致／selector 唔清楚 → 會卡住

  • 模型可能誤解 selector 或「以為可以合併步驟」

  • 如果 tasks.yaml 本身太大（幾千行），讀取同樣會有 token 壓力

所以最佳做法係：

3) 真正穩陣：分段 spec + checkpoint（防止長清單注意力崩壞）

如果你有 100 個 tasks，建議拆：

  • tasks_001_020.yaml

  • tasks_021_040.yaml

  • ...

  • tasks_081_100.yaml

每次跑一段：

codex exec "Execute tasks_001_020.yaml strictly. Append to results.jsonl. Stop on failure."

咁做有幾個效果：

  • 每次上下文更短、更穩

  • 任一段出錯，唔會拖累後面 80 個

  • 你可以每段跑完就驗證 result 行數 / id 覆蓋

4) 如何將 Task / SubTasks 結構「清晰教畀 Codex」：三個關鍵

(A) 用固定 schema（最好你自己定義）

重點係一致性：

  • task.id

  • subtask.id

  • input.path

  • action

  • selector

  • expected_output

(B) 每一步有「可檢查」產物

例如每 subtask 都要寫一行：

  • results.jsonl（最推薦）

  • 或 progress.md（人睇）

  • 或同時兩份（machine + human）

(C) 加「硬規則」

例如：

  • 必須按 id 順序執行，不可跳號

  • 不可猜測，不可填估計值

  • 任何 ambiguous 就停

5) YAML 定 JSON？

  • YAML：你手寫方便、可讀性好（適合規格）

  • JSON：機械嚴格、好做 schema 驗證（適合自動化）

你可以：

  • 規格用 YAML

  • 輸出用 JSONL/JSON（方便你驗證）

如果你願意，我可以直接幫你定一個「最小但夠嚴格」嘅 task schema（YAML/JSON 二選一），再配一套 results.jsonl 格式 + 驗證規則，令你跑 100/1000 步都穩。你只要話我：你啲 input 檔係咩格式（CSV/Excel/JSON/TXT），同埋 “value x11” 係欄位名定係 pattern/計算式。

 

 如何
⌈每次跑一段：
codex exec "Execute tasks_001_020.yaml strictly. Append to results.jsonl. Stop on failure."⌋

寫個 100行的 （或自己 loop 的） *.ps1 檔案？

 

 

可以，用 PowerShell loop 直接把 100 個分段 job 跑完；重點係：

  • 每段跑 codex exec ...

  • 檢查 $LASTEXITCODE（Codex CLI 結束碼），非 0 就 Stop

  • （可選）把 stdout/stderr 同時追加到 log 檔，方便追查

  • （可選）支援「續跑」：results 裡面已有的段落就跳過

下面俾你 3 個常用版本，你照貼做 .ps1 就得。

版本 A：最簡單（假設你已經有 tasks_001_020.yaml 這種命名）

run-batches.ps1：

# run-batches.ps1
$ErrorActionPreference = "Stop"

# 你可以按需要改
$CodexCmd = "codex"
$BatchSize = 20
$Total = 100
$SpecPattern = "tasks_{0}.yaml"     # {0} 會放 "001_020" 呢種 range
$ResultsFile = "results.jsonl"
$LogFile = "codex_run.log"

function RangeLabel([int]$start, [int]$end) {
  return ("{0:D3}_{1:D3}" -f $start, $end)
}

for ($start = 1; $start -le $Total; $start += $BatchSize) {
  $end = [Math]::Min($start + $BatchSize - 1, $Total)
  $label = RangeLabel $start $end
  $spec = $SpecPattern -f $label

  if (-not (Test-Path $spec)) {
    throw "Spec file not found: $spec"
  }

  $prompt = "Execute $spec strictly. Append to $ResultsFile. Stop on failure."
  Write-Host "=== Running batch $label ($spec) ==="

  # 將輸出追加到 log（stdout + stderr）
  & $CodexCmd exec $prompt 2>&1 | Tee-Object -FilePath $LogFile -Append

  if ($LASTEXITCODE -ne 0) {
    throw "Codex failed at batch $label (exit code $LASTEXITCODE). See $LogFile"
  }
}

Write-Host "All batches completed."

用法：

.\run-batches.ps1

版本 B：更穩（加「續跑」功能：已完成的 batch 就跳過）

如果你每段都會喺 results.jsonl 寫一個 batch marker（建議你在 prompt 要求 Codex 每段開始/結束寫一行 marker），就可以做到續跑。

例如你要求每段先寫：
{"batch":"001_020","status":"start"}
結束再寫：
{"batch":"001_020","status":"done"}

咁 .ps1 就可以用 Select-String 去檢查已 done 的 batch。

# run-batches-resume.ps1
$ErrorActionPreference = "Stop"

$CodexCmd = "codex"
$BatchSize = 20
$Total = 100
$ResultsFile = "results.jsonl"
$LogFile = "codex_run.log"

function RangeLabel([int]$start, [int]$end) {
  return ("{0:D3}_{1:D3}" -f $start, $end)
}

function IsBatchDone([string]$label, [string]$resultsFile) {
  if (-not (Test-Path $resultsFile)) { return $false }
  $pattern = '"batch"\s*:\s*"' + [Regex]::Escape($label) + '".*"status"\s*:\s*"done"'
  return (Select-String -Path $resultsFile -Pattern $pattern -Quiet)
}

for ($start = 1; $start -le $Total; $start += $BatchSize) {
  $end = [Math]::Min($start + $BatchSize - 1, $Total)
  $label = RangeLabel $start $end
  $spec = "tasks_$label.yaml"

  if (-not (Test-Path $spec)) {
    throw "Spec file not found: $spec"
  }

  if (IsBatchDone $label $ResultsFile) {
    Write-Host "=== Skipping batch $label (already done) ==="
    continue
  }

  $prompt = @"
Follow $spec strictly.
1) Append a JSONL marker line: {"batch":"$label","status":"start"}
2) Execute tasks in order, fail-fast, no guessing.
3) Append a JSONL marker line: {"batch":"$label","status":"done"}
Append everything to $ResultsFile. Stop on failure.
"@

  Write-Host "=== Running batch $label ($spec) ==="
  & $CodexCmd exec $prompt 2>&1 | Tee-Object -FilePath $LogFile -Append

  if ($LASTEXITCODE -ne 0) {
    throw "Codex failed at batch $label (exit code $LASTEXITCODE). See $LogFile"
  }
}

Write-Host "All batches completed (with resume support)."

版本 C：如果你唔想拆 100 個 YAML 檔（用一個總表，跑前先自動切割）

如果你只有一個 tasks.yaml，想用 PowerShell 自動切成 tasks_001_020.yaml…再跑：可以，但要你個 YAML 結構夠規律（例如 tasks: 下面每個 task 一行/固定格式）。一般 YAML 唔好用正則硬切，建議改用 JSON（較易程序化切割）。如果你想行呢條路，我可以按你實際 spec 格式幫你寫切割器。

小提醒（實戰必用）

  1. 確保 codex 在 PATH：PowerShell 打 codex --version 測試先。

  2. 每段都要可驗證：例如每段要求輸出 batch marker（版本 B）。

  3. fail-fast：一段失敗就停，唔好硬跑落去。

如果你而家已經有你嘅檔名規則（例如 tasks_1_20.yaml / tasks-001-020.yml）同埋你想每段係 10、20 定 25 步，我可以幫你把上面腳本改到完全貼合你命名，同時加埋「重試 1 次」、「超時終止」呢啲更工程化嘅保護。

 

 

© 2026 Danny Yeung. All rights reserved. 版权所有 不得转载

 

Disclaimer

This book is the product of a collaboration between the author and OpenAI's GPT-5.2, X's Grok language model. While every effort has been made to ensure accuracy, clarity, and insight, the content is generated with the assistance of artificial intelligence and may contain factual, interpretive, or mathematical errors. Readers are encouraged to approach the ideas with critical thinking and to consult primary scientific literature where appropriate.

This work is speculative, interdisciplinary, and exploratory in nature. It bridges metaphysics, physics, and organizational theory to propose a novel conceptual framework—not a definitive scientific theory. As such, it invites dialogue, challenge, and refinement.


I am merely a midwife of knowledge. 

 

 

 

發佈者： 於

沒有留言:

發佈留言

訂閱： 發佈留言 (Atom)