> Harness EngineeringHarness EngineeringHarness Engineering The engineering outside the model模型之外的工程模型之外的工程

5.9

Who decides: code, a cheap model, the main model, a person誰來判斷:程式、便宜模型、主模型、人谁来判断:代码、便宜模型、主模型、人

This chapter is about cost, not about safety. Requests and rules asks how hard a rule is enforced: a request, a command, a hook. This chapter asks something else: for each judgment in your workflow, who is the cheapest one that can make it?

這一章講的是成本,不是安全。提示裡的規則只是請求 問的是規則被執行得多硬:請求、命令、hook。這一章問的是另一件事:對工作流程裡的每一個判斷,誰是能做出它的最便宜的那個?

这一章讲的是成本,不是安全。提示里的规则只是请求问的是一条规则被执行得有多硬:请求、命令,还是 hook。这一章问的是另一件事:对你工作流里的每一个判断,能做出它的最便宜的是谁?

The Knowledge經驗分享经验分享

In one sentence

Give each judgment to the cheapest level that can make it: code first, then a cheap model, the main model, a person. Cheap models tend to be weakest at the vague calls (my rule of thumb, not measured).

一句話

每個判斷,交給能做出它的最便宜的那一層:先是程式,再來是便宜的模型、主模型、人。便宜的模型,往往在模糊的判斷上最弱(這是我的經驗法則,沒有量過)。

一句话

每个判断,交给能做出它的最便宜的一层:先是代码,再是便宜的模型,然后是主模型,最后是人。便宜的模型往往最不擅长模糊的判断(这是我的经验法则,没有测过)。

For leaders

  • The decision: assign each judgment in the workflow to the cheapest level that can make it well: code first, then a cheap model, then the main model, then a person.
  • The risk: giving everything to the main model wastes usage, gives different answers on different days and is slow. Pushing everything into code is brittle and fails with full confidence on the first case it did not foresee. A cheap model on a vague question is the worst case; this is my rule of thumb, which I have not measured.
  • The cost of doing it right: mostly setup time. Every level you add is one more thing to configure and to fail, so do not add a cheap judge for a call that happens twice a week. Levels are guesses until tested on cases where you know the answer.
  • Ask the team: "Which judgments in our workflow does a model make that a script could settle, and which does a script make that needs judgment?"

給主管

  • 要做的決定:把工作流程裡的每個判斷,交給能把它做好的最便宜的那一層:先是程式,再來是便宜的模型,然後是主模型,然後是人。
  • 風險:把一切都交給主模型,浪費用量,不同天給不同答案,也慢。把一切都推進程式,則很脆,碰到第一個它沒預料到的情況,就信心十足地錯。便宜的模型碰上模糊的問題,是最糟的情況;這是我的經驗法則,我沒有量過。
  • 做對的成本:多半是設定的時間。你每加一層,就多一樣要設定、也會壞的東西,所以不要為一週只發生兩次的判斷加一個便宜的評審。在拿你知道答案的案例測過之前,這些層級都只是猜測。
  • 可以問團隊:「我們的工作流程裡,哪些判斷是模型在做、腳本就能解決的?哪些是腳本在做、卻需要判斷的?」

写给管理者

  • 要拍板的事:把工作流里的每个判断,分给能把它做好的最便宜的一层:先代码,再便宜的模型,再主模型,最后是人。
  • 风险:什么都交给主模型,浪费用量,不同的日子给出不同的答案,还慢。什么都塞进代码,又很脆,碰到第一个没预料到的情况,就会信心十足地出错。让便宜的模型去答模糊的问题,是最糟的情形;这是我的经验法则,我没有测过。
  • 做对的代价:主要是搭建的时间。每多加一层,就多一样要配置、也会出故障的东西,所以别给一周只发生两次的判断加一个便宜的裁判。这些层在拿你知道答案的案例测过之前,都只是猜测。
  • 可以问团队:“我们工作流里,哪些判断是模型在做、其实脚本就能定?哪些是脚本在做、其实需要判断力?”

The problem

An agent workflow is full of small judgments. Is this path inside the allowed folder? Has the check passed three times? Is this Excel sheet a mapping table? Does this step go beyond the approved plan? Is this design good?

The easy habit is to give all of them to the main model, because it can answer anything. It gets answers, and it is wasteful in three ways. It costs tokens for questions code answers for free. It answers the same question differently on different days. And it is slow: a model call takes seconds, a check in code takes milliseconds.

The opposite habit is just as bad. Code is the cheapest and most reliable judge, so people push everything into code: a pattern list for "dangerous commands", a keyword match for "is this a bug report". It works until the first case the pattern did not foresee, and then it is wrong with full confidence.

So the real question is: what is the cheapest level that is still good enough for this judgment?

問題

agent 的工作流程裡,滿是小小的判斷。這個路徑在允許的資料夾裡嗎?檢查連續通過三次了嗎?這張 Excel 工作表是對照表嗎?這一步超出已批准的計畫了嗎?這個設計好不好?

最省事的習慣,是把它們全交給主模型,因為它什麼都能回答。它確實給出答案,但在三個地方浪費。程式免費就能回答的問題,它要花 token。它在不同的日子,對同一個問題給不同的答案。而且它慢:一次模型呼叫要幾秒,程式裡的檢查只要幾毫秒。

相反的習慣一樣糟。程式是最便宜、最可靠的評審,所以人們把一切都推進程式:用一份樣式清單判斷「危險指令」,用關鍵字比對判斷「這是不是 bug 報告」。這在碰到第一個樣式沒預料到的情況之前都行得通,之後它就信心十足地錯。

所以真正的問題是:對這個判斷,仍然夠好的最便宜的一層是哪一層?

问题

agent 的工作流里满是小判断。这个路径在允许的文件夹里吗?检查连续通过三次了吗?这张 Excel 表是映射表吗?这一步超出批准的计划了吗?这个设计好不好?

省事的习惯,是把它们全交给主模型,因为它什么都能答。它确实能给出答案,但在三个方面浪费。代码能免费回答的问题,它要花 token。同一个问题,它在不同的日子答得不一样。而且它慢:一次模型调用要几秒,代码里的一次检查只要几毫秒。

反过来的习惯同样糟。代码是最便宜、最可靠的裁判,于是有人把一切都塞进代码:用一张模式列表判断“危险命令”,用关键词匹配判断“这是不是缺陷报告”。它能用,直到碰上第一个模式没预料到的情况,然后它就信心十足地出错。

所以真正的问题是:对这个判断,仍然够用的最便宜的一层是哪一层?

How it works

Four levels

Level Good at Cost Weak at Example
1. Code Anything with one right answer that can be computed Nearly none, same answer every time Anything that needs meaning Count passes in a row; is the path inside the allowed folder; does the data have the required fields; has a file changed since it was read
2. A cheap model Narrow, frequent judgments with clear options Low Vague calls; long context; cases with no clear options Sort a request into one of four kinds; does this step name a file outside the plan
3. The main model Reasoning, design, reading a lot, judgments that need context High Being the same every time; being cheap What does this change mean; write the plan; decide which of two designs fits
4. A person What costs money, grants power, cannot be undone, or needs the business to decide Their time, which is the most expensive Speed; being there at night Approve the plan; decide between two readings of a requirement; accept the result

Everyday cases for level 1, where a model is often asked by habit: does this file exist, how many rows does this table have, do these two files differ. A script answers each exactly and for free.

Read the table from the top. For each judgment, ask: can code do this? If yes, stop. If not, can a narrow cheap judge? If not, the main model. If the answer has consequences nobody should delegate, a person.

Each level also has a clear failure.

  • Code used for a vague question is brittle. It passes what it has seen and misses the rest.
  • A cheap model used for a vague question is the worst case. It answers fast, in the same confident tone as for an easy question, and is wrong more often. That is why cheap models are weakest at the vague calls, and why the example for level 2 is a question with clear options. I hold this as a rule of thumb from how these models behave; I have not measured the gap on my own tasks.
  • The main model used for a code question is just a waste.
  • A person used for what code could settle wears out the person, until they approve without reading (Two approvals).

Prepare the input in code too

The same idea reaches before the model. Turning a Word file or an Excel sheet into plain text is a fixed job, so a program does it, not a model: the model should not pay for cover pages, hidden sheets and comments, or take that noise for a requirement (The agent writes the requirement has the details). The model then reads the small, clean result and never sees the originals.

Word or Excel a program converts plain text model the model reads only the clean text; same result every time, no tokens spent on converting Word or Excel model reads the raw file pays for covers, hidden sheets and noise, and may guess
A fixed job such as converting a file goes to a program. The model gets only what needs judgment.

The split is the point. Converting is level 1. Deciding what the requirement means is level 3 or 4. Mixing the two makes the model do both, badly.

Make questions computable

You can move more work down to level 1 by changing the data, not the judge. If "is this knowledge still right?" is asked of a model, it reads everything, guesses, and guesses differently next time. If each card of knowledge records the version of the code it was read from, then "which cards are stale?" is a comparison a script does exactly. The rule is: where a question has one right answer that a program can compute, put the data in a fixed form and let a program compute it. The model keeps what needs judgment.

When to go up

Move a judgment up a level when:

  • The lower level is unsure, and says so. Code can be built to say "I cannot tell" and hand on. A model's own statement of confidence is a weak signal, so for a model the safer trigger is the sample you check by hand (next bullet).
  • Its answers disagree with a sample you checked by hand.
  • The cost of a wrong answer is higher than the cost of the next level. Wrong on a write-back (copying finished work into the real repository, Two gates) costs more than a call to the main model.
  • The judgment turned out to need context it does not have.

And move one down when you notice you are using a big judge on a question with a stable answer. Most judgments start at level 3 because that is the quickest way to get something working; the work is in noticing which ones can sink.

What my setup does

My harness's decisions in code include: path and command checks, counting passes, working out fingerprints, the board of task states (Ten things at once: parallel tasks), the staleness of knowledge cards (A knowledge base: an honest index of the code), scoring of fixed test tasks, and the conversion of business documents. The main model does the thinking and the writing. The independent checker is a model, because reading a result against a requirement is not a narrow call. People hold the approvals.

I have designed a place for a level 2 judge: a cheap model for judgments that are frequent and too varied for rules, such as "has this step gone beyond the approved scope?" It is not built. The first step would be to check whether code can do it, and only then add the cheap judge, with code deciding what to do with its answer, and a fallback to rules when it fails. I have not tested whether a cheap model is good enough for that call.

原理

四層

層 擅長 成本 不擅長 例子
1. 程式 任何只有一個正確答案、可以算出來的事 幾乎沒有,每次答案都一樣 任何需要理解意思的事 數連續的通過;路徑在不在允許的資料夾裡;資料有沒有必要的欄位;檔案被讀過之後有沒有變
2. 便宜的模型 窄的、頻繁的、選項清楚的判斷 低 模糊的判斷;長的上下文;沒有清楚選項的情況 把一個請求分到四類之一;這一步有沒有點名計畫以外的檔案
3. 主模型 推理、設計、讀大量內容、需要上下文的判斷 高 每次都一樣;便宜 這個改動是什麼意思;寫計畫;決定兩種設計哪一個合適
4. 人 花錢、給權力、不能反悔、或需要業務來決定的事 他們的時間,這是最貴的 速度;晚上在不在 批准計畫;在需求的兩種讀法之間決定;驗收結果

第 1 層的日常例子,這些是人們常憑習慣去問模型的:這個檔案存在嗎、這張表有幾列、這兩個檔案有沒有不同。腳本對每一個都能精確回答,而且免費。

從表的上面往下讀。對每個判斷,問:程式做得到嗎?做得到,就停。做不到,一個窄的、便宜的評審做得到嗎?不行,就主模型。如果答案的後果是誰都不該代為決定的,就交給人。

每一層也都有明確的失敗方式。

  • 用程式處理模糊的問題,會很脆。它放行見過的,漏掉其餘的。
  • 用便宜的模型處理模糊的問題,是最糟的情況。它回答得很快,語氣和回答簡單問題時一樣有把握,卻錯得更多。這就是為什麼便宜的模型在模糊的判斷上最弱,也是為什麼第 2 層的例子是選項清楚的問題。我把這當作一個經驗法則,來自這些模型的行為;我沒有在自己的任務上量過這個差距。
  • 用主模型處理程式的問題,純粹是浪費。
  • 用人處理程式就能解決的事,會把人累垮,直到他不讀就批准(兩道門:人在哪裡批准)。

輸入也用程式準備

同樣的想法,在模型之前就開始了。把 Word 檔或 Excel 工作表轉成純文字,是一件固定的工作,所以由程式做,不是模型:模型不該為封面、隱藏的工作表和註解付錢,也不該把這些雜訊當成需求(細節見 需求由 agent 寫,人確認)。模型接著讀的是小而乾淨的結果,永遠看不到原始檔。

Word 或 Excel 程式轉換 純文字 模型 模型只讀乾淨的文字; 每次結果相同,轉換不花 token Word 或 Excel 模型 直接讀原始檔案 要為封面、隱藏工作表和雜訊付費,還可能猜錯
轉檔這種固定的活交給程式,模型只拿到需要判斷的部分。

分工就是重點。轉換是第 1 層。決定需求是什麼意思,是第 3 層或第 4 層。把兩者混在一起,會讓模型兩件事都做,而且都做不好。

讓問題可以被計算

你可以改資料,不改評審,把更多工作移到第 1 層。如果「這份知識還對嗎?」是問模型的,它會把所有東西都讀一遍,猜一個答案,下次又猜得不一樣。如果每張知識卡片都記下它是從哪個版本的程式碼讀來的,那麼「哪些卡片過期了?」就是腳本能精確做的一個比對。規則是:只要一個問題有一個程式能算出來的正確答案,就把資料放成固定的形式,讓程式來算。需要判斷的,留給模型。

什麼時候往上移

出現以下情況,就把一個判斷往上移一層:

  • 較低的一層不確定,而且說出來了。程式可以做成說「我判斷不了」並交出去。模型自己說的把握是個弱訊號,所以對模型,比較安全的觸發條件是你用手檢查的抽樣(下一條)。
  • 它的答案和你用手檢查過的抽樣不一致。
  • 答錯的成本,高過下一層的成本。寫回出錯(把做完的工作複製到真實的倉庫,兩道門:人在哪裡批准),比呼叫一次主模型更貴。
  • 事實證明,這個判斷需要它沒有的上下文。

當你發現自己拿一個大評審去回答答案穩定的問題,就往下移一層。大多數判斷一開始都在第 3 層,因為那是讓東西動起來最快的辦法;功夫在於注意到哪些可以沉下去。

我的設定做什麼

我的 harness 裡由程式做的決定包括:路徑和指令的檢查、計算通過、算出指紋、任務狀態的看板(同時管十件事:並行的是任務)、知識卡片的過期(知識庫:程式碼的誠實索引)、固定測試任務的打分,以及商業文件的轉換。主模型負責思考和寫作。獨立的檢查者是個模型,因為拿結果去對照需求來讀,不是一個窄的判斷。批准由人掌握。

我設計過一個放第 2 層評審的位置:一個便宜的模型,處理頻繁、又多樣到規則寫不完的判斷,例如「這一步超出已批准的範圍了嗎?」它還沒做。第一步是檢查程式能不能做,之後才加便宜的評審,由程式決定怎麼處理它的答案,失敗時退回規則。便宜的模型對這個判斷夠不夠好,我沒有測過。

原理

四层

层 擅长 成本 不擅长 例子
1. 代码 只有一个正确答案、可以算出来的事 几乎没有,每次答案相同 任何需要理解含义的事 数连续通过了几次;路径在不在允许的文件夹里;数据有没有必需的字段;文件自读取之后有没有变过
2. 便宜的模型 窄的、频繁的、选项明确的判断 低 模糊的判断;很长的上下文;没有明确选项的情形 把一个请求归入四类之一;这一步有没有点名计划之外的文件
3. 主模型 推理、设计、读大量内容、需要上下文的判断 高 每次都一样;便宜 这个改动意味着什么;写计划;在两种设计里决定哪个合适
4. 人 花钱、授权、无法撤销、或需要业务来决定的事 他们的时间,这是最贵的 速度;半夜在场 审批计划;在对一条需求的两种理解里做决定;验收结果

第 1 层的日常例子,也是常常出于习惯去问模型的:这个文件存在吗,这张表有多少行,这两个文件有没有差别。脚本对每一个都答得精确,而且免费。

从表的上面往下读。对每个判断,问:代码能做吗?能,就到此为止。不能,一个窄的便宜裁判能做吗?不能,就用主模型。如果答案的后果没人应该代为承担,就交给人。

每一层也有各自明显的失败。

  • 用代码答模糊的问题,很脆。见过的它能处理,没见过的它就漏掉。
  • 用便宜的模型答模糊的问题,是最糟的情形。它答得快,语气和答简单问题时一样自信,却错得更多。这就是便宜的模型最不擅长模糊判断的原因,也是第 2 层的例子都是选项明确的问题的原因。这是我从这些模型的表现得出的经验法则;这个差距在我自己的任务上我没有测过。
  • 用主模型答代码就能答的问题,纯属浪费。
  • 用人去定代码能定的事,会把人磨累,直到他不看就批(见两道门:人在哪里审批)。

输入也用代码准备

同样的想法,也延伸到模型之前。把一个 Word 文件或 Excel 表转成纯文本,是固定的活,所以由程序来做,不由模型来做:模型不该为封面、隐藏的工作表和批注付费,也不该把那些噪声当成需求(细节见需求由 agent 写,人确认)。这样模型读到的是小而干净的结果,永远看不到原件。

Word 或 Excel 程序转换 纯文本 模型 模型只读干净的文本; 每次结果相同,转换不花 token Word 或 Excel 模型 直接读原始文件 要为封面、隐藏工作表和噪声付费,还可能猜错
转文件这种固定的活交给程序,模型只拿到需要判断的部分。

分开,才是关键。转换是第 1 层。判断需求是什么意思,是第 3 层或第 4 层。把两件事混在一起,就让模型两件都做,还做不好。

让问题能被算出来

你可以通过改数据,而不是改裁判,把更多的活下移到第 1 层。如果拿“这条知识还对不对”去问模型,它要把一切读一遍,猜一个答案,下次又猜成另一个。如果每张知识卡片都记着它读的是哪个版本的代码,那么“哪些卡片过期了”就是脚本能精确做的一次比较。规则是:只要一个问题有程序能算出的唯一正确答案,就把数据放成固定的形式,让程序去算。需要判断的,留给模型。

什么时候往上升一层

遇到下面的情况,把判断上升一层:

  • 下面那一层没把握,而且说了出来。代码可以做成说“我判断不了”并往上交。模型自己说的信心是个弱信号,所以对模型,更稳妥的触发条件是你手工检查的那个样本(见下一条)。
  • 它的答案和你手工检查过的样本对不上。
  • 答错的代价,比再往上一层的成本高。写回(把做完的工作复制进真正的仓库,见两道门:人在哪里审批)答错了,比调一次主模型花得多。
  • 这个判断后来发现需要它没有的上下文。

反过来,发现自己用大裁判去答一个答案稳定的问题时,就下移一层。大多数判断一开始都在第 3 层,因为那是让东西最快跑起来的办法;真正要做的功夫,是留意哪些可以往下沉。

我的配置怎么做

我的 harness 里,由代码做的决定包括:路径和命令的检查、计数通过次数、算指纹、任务状态的看板(见同时管十件事:并行的是任务)、知识卡片的过期判断(见知识库:代码的诚实索引)、固定测试任务的打分,以及业务文档的转换。主模型负责思考和写作。独立检查者是模型,因为对照需求读一个结果,不是窄的判断。审批由人来做。

我为第 2 层的裁判设计了位置:用便宜的模型处理频繁、又太多样而无法用规则覆盖的判断,比如“这一步是不是超出了批准的范围”。它还没有做。第一步应该是看代码能不能做,然后才加便宜的裁判,由代码决定怎么处理它的答案,失败时退回到规则。便宜的模型对这个判断够不够用,我没有测过。

Costs and traps

Levels are guesses until you test. Whether a judgment fits level 2 depends on the model you use this month. Measure it on cases where you know the answer (Eval tasks).

More levels, more parts. Each level you add is something to configure and to fail. Do not add a cheap judge for a call that happens twice a week.

Code can be confidently wrong. A pattern that blocks "dangerous commands" will not see a dangerous command in a form it has not met. For safety, how hard the rule is enforced is the question, and Requests and rules is the chapter.

Cost per call is not the whole bill. Input the provider has cached is read at about a tenth of the base price, so a repeated long prefix is cheaper than it looks (Models and cost). I have not checked how Copilot applies this, so measure on your own setup before you decide that moving a judgment saves money.

Moving down saves money but can hide errors. Cheaper judgments are less often looked at. Keep a sample you read by eye.

代價和陷阱

層級在測過之前都是猜測。一個判斷適不適合第 2 層,取決於你這個月用的模型。拿你知道答案的案例去量(固定的任務,用腳本打分)。

層越多,零件越多。你每加一層,就多一樣要設定、也會壞的東西。不要為一週只發生兩次的判斷加一個便宜的評審。

程式可能信心十足地錯。擋「危險指令」的樣式,看不出它沒見過的形式的危險指令。談安全,問題是規則被執行得多硬,那是 提示裡的規則只是請求 的內容。

每次呼叫的成本不是整張帳單。供應商快取過的輸入,讀取的價格大約是基本價格的十分之一,所以重複的長前綴比看起來便宜(選模型:算的是每次成功的成本)。Copilot 怎麼套用這點,我沒有檢查過,所以在你決定移動一個判斷能省錢之前,先在你自己的設定上量。

往下移省錢,但可能藏住錯誤。越便宜的判斷,越少有人去看。保留一份你用眼睛讀的抽樣。

代价和坑

这些层在你测之前都是猜测。一个判断适不适合第 2 层,取决于你这个月用的模型。拿你知道答案的案例去测(见固定的任务,用脚本打分)。

层越多,零件越多。每加一层,就多一样要配置、也会出故障的东西。别给一周只发生两次的判断加一个便宜的裁判。

代码可能信心十足地出错。拦“危险命令”的模式,看不出一条以它没见过的形式出现的危险命令。对安全来说,问题是规则被执行得有多硬,那是提示里的规则只是请求这一章的内容。

单次调用的成本不是全部账单。服务商已缓存的输入,读取价格约是基础价格的十分之一,所以反复出现的长前缀,比看上去便宜(见选模型:看每次成功的成本)。Copilot 怎么用这一点,我没有查过,所以在断定把某个判断下移能省钱之前,先在你自己的环境里测。

往下移省钱,但可能藏住错误。越便宜的判断,被看的次数越少。留一个你亲眼读的样本。

When to delete it

The levels stay; the line between them moves. As cheap models get better at vague calls, level 2 will take more. As the main model gets cheaper, level 3 will matter less as a cost and more as a reliability question. Re-run your own test of each judgment when the model changes (After a model upgrade).

什麼時候可以刪掉

層級會留著;它們之間的線會移動。便宜的模型在模糊的判斷上越來越好,第 2 層會接下更多。主模型越來越便宜,第 3 層就越不是成本問題,更像是可靠性的問題。模型換了,就對每個判斷重做你自己的測試(模型升級了,就要刪)。

什么时候可以删掉

这些层会留下来;它们之间的界线会移动。便宜的模型越来越会做模糊的判断,第 2 层就会接更多。主模型越来越便宜,第 3 层就更少是成本问题,更多是可靠性问题。模型一换,就把你自己对每个判断的测试重跑一遍(见模型升级了,就要删)。

Try it on your own setup

No harness needed. Open your agent in your own repository and paste:

List the judgments in this project's agent workflow: what the instruction files, skills, hooks, scripts and review steps each decide (for example, is this path allowed, did the check pass, is this change in scope, is this design good). For each, name who decides today: code, a cheap model, the main model, or a person. Then mark the ones where a model decides something a script could settle, and the ones where a script or pattern decides something that needs meaning. Do not change any files.

在你自己的環境試試

不用裝 harness。在你自己的倉庫裡打開 agent,貼上:

列出這個專案的 agent 工作流程裡的判斷:指令檔、skill、hook、腳本和審查步驟各自決定什麼(例如:這個路徑允許嗎、檢查通過了嗎、這個改動在範圍內嗎、這個設計好不好)。對每一個,說出今天是誰決定:程式、便宜的模型、主模型,還是人。然後標出:模型在決定、腳本就能解決的那些,以及腳本或樣式在決定、卻需要理解意思的那些。不要改任何檔案。

在你自己的环境里试试

不用装 harness。在你自己的仓库里打开 agent,粘贴:

列出这个项目的 agent 工作流里的各个判断:指令文件、skill、hook、脚本和审查步骤各自在决定什么(比如:这个路径允许吗,检查通过了吗,这个改动在范围内吗,这个设计好不好)。对每一个,说出现在由谁来决定:代码、便宜的模型、主模型,还是人。然后标出两类:模型在决定、脚本其实就能定的;脚本或模式在决定、其实需要理解含义的。不要修改任何文件。

Go deeper

延伸閱讀

延伸阅读

You can stop here: that is the whole idea. The next part shows where it runs, so you can look inside.讀到這裡就夠了,這就是整個想法。下一部分告訴你它在哪裡運行,可以進去看看。读到这里就够了,核心思路就是这些。下一部分告诉你它在哪里跑,可以进去看看。

In my practice (Copilot Harness)實作实战

Copilot Harness is my open-source harness for VS Code Copilot.

Repository: https://github.com/Smars-Bin-Hu/copilot-agentic-harness

Get started: clone it, open it in VS Code, and type /harness-rookie-get-me-ready in Copilot Chat. You need Python 3.9 or later and git.

Copilot Harness 是我開源的 VS Code Copilot harness。

倉庫: https://github.com/Smars-Bin-Hu/copilot-agentic-harness

開始:clone 下來,用 VS Code 打開,在 Copilot Chat 裡輸入 /harness-rookie-get-me-ready。需要 Python 3.9 以上和 git。

Copilot Harness 是我开源的 VS Code Copilot harness。

仓库: https://github.com/Smars-Bin-Hu/copilot-agentic-harness

上手:把仓库 clone 下来,用 VS Code 打开,在 Copilot Chat 里输入 /harness-rookie-get-me-ready。需要 Python 3.9 及以上版本和 git。

Explore it in the harness

The code-first judgments, the conversion of business files, and the places where a person decides all run in Copilot Harness. The cheap-model level is not built. The harness can teach what exists from the inside, with the real files. After the setup above, type:

/harness-rookie-wondering I have read the chapter "Who decides". Teach me which judgments this harness gives to code, which to the model and which to a person (topic 15), and how it converts business documents before the model reads them. Open the real files with me and draw how the pieces fit together.

It teaches one small piece at a time, stops to ask if you are following, and opens the files with you.

在 harness 裡探索

先交給程式的判斷、商業檔案的轉換,以及由人決定的地方,都在 Copilot Harness 裡執行。便宜模型那一層還沒做。harness 可以從裡面教你現有的部分,附上真實的檔案。照上面的說明準備好之後,輸入:

/harness-rookie-wondering 我讀完了「誰來判斷」這一章。請教我這個 harness 把哪些判斷交給程式、哪些交給模型、哪些交給人(主題 15),以及它在模型讀之前,怎麼轉換商業文件。帶我打開真實的檔案,並畫出這些部分怎麼組合在一起。

它一次教一小塊,停下來確認你跟得上,然後和你一起打開檔案。

在 harness 里探索

代码优先的判断、业务文件的转换,以及由人来决定的地方,都在 Copilot Harness 里跑着。便宜模型这一层还没有做。已有的部分,harness 可以从内部教你,配上真实的文件。按上面的说明准备好之后,输入:

/harness-rookie-wondering 我读完了“谁来判断”这一章。请教我这个 harness 把哪些判断交给代码、哪些交给模型、哪些交给人(主题 15),以及它在模型读业务文档之前是怎么转换这些文档的。和我一起打开真实的文件,并画出各部分是怎么拼在一起的。

它一次只教一小块,停下来确认你跟上了,再和你一起打开文件。