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

6.2

A report a person can read in five minutes一份五分鐘讀得完的報告一份五分钟读得完的报告

This chapter assumes you have used an AI coding agent. It helps to have read Record what happened, not what the agent said, but you can follow without it.

讀這一章,你需要用過 AI 寫程式的 agent。先讀過 記下發生了什麼,不是 agent 說了什麼 會有幫助,不讀也跟得上。

读这一章,你需要用过一个写代码的 AI agent。先读过记下发生了什么,而不是 agent 说了什么会有帮助,不读也跟得上。

The Knowledge經驗分享经验分享

In one sentence

Every finished task needs a report that a person can read in five minutes. When you run many tasks at once, a board is the one page that tells you which one to open.

一句話

每個完成的任務,都需要一份人五分鐘讀得完的報告。同時跑很多任務時,看板是告訴你該打開哪一個的那一頁。

一句话

每个完成的任务,都需要一份人五分钟读得完的报告。同时跑很多任务时,看板是告诉你该打开哪一个的那一页。

For leaders

  • The decision: require that every finished task has a one-page report, written by code, and decide what the page must show.
  • The risk: a log is not a report. Nobody reads thousands of lines, so the only thing a colleague or a leader reads is the agent's own summary, which is what the log exists to check. A report is also only as honest as its sources: a hole in the log is a hole in the report.
  • The cost of doing it right: one program that reads the task folder and the log. The real cost is defending the five-minute limit against requests for one more number.
  • Ask the team: "Show me the report of the last finished task. Can I read it in five minutes, and does it say who approved it and what was refused?"

給主管

  • 要做的決定:要求每個完成的任務都有一頁由程式寫的報告,並決定這一頁必須顯示什麼。
  • 風險:日誌不是報告。沒有人會讀幾千行,所以同事或主管唯一會讀的,是 agent 自己的總結,而日誌存在的目的,就是檢查這份總結。報告的誠實程度,也只和它的來源一樣:日誌有洞,報告就有洞。
  • 做對的成本:一個讀任務資料夾和日誌的程式。真正的成本,是擋住大家「再加一個數字」的要求,守住五分鐘這條線。
  • 可以問團隊:「給我看上一個完成任務的報告。我能在五分鐘內讀完嗎?它有沒有說是誰批准的、什麼被拒絕了?」

写给管理者

  • 要拍板的事:要求每个完成的任务都有一页由代码写的报告,并决定这一页必须显示什么。
  • 风险:日志不是报告。没人会读几千行,所以同事或管理者唯一会读的,是 agent 自己的总结,而日志存在的目的,恰恰是检查这份总结。报告也只和它的来源一样诚实:日志有漏洞,报告就有漏洞。
  • 做对的代价:一个读任务文件夹和日志的程序。真正的代价,是顶住大家“再加一个数字”的要求,守住五分钟这条线。
  • 可以问团队:“给我看上一个完成任务的报告。我能在五分钟内读完吗?它有没有写是谁审批的、什么被拒绝了?”

The problem

A log is not a report. After the previous chapter you may have a log with thousands of lines. Nobody reads that to answer "what did this task do?". And the agent's own summary, which is short enough to read, is the thing the log exists to check.

Who needs the answer? Three people, at three times.

  • You, the next morning. The work was yesterday. You do not remember which files changed, or why a check was done twice.
  • A colleague or a leader who did not watch. They want to know what was done and whether anyone checked it, and they will give it a few minutes.
  • You, when something goes wrong later. Someone asks "who approved this change?" and "was it checked?". You want the answer from a document, not from memory.

If the report takes an hour to read, these people will not read it. So the report is a design problem: what to put on one page, and what to leave to the log.

問題

日誌不是報告。讀完 上一章 之後,你可能有一份幾千行的日誌。沒有人會讀它來回答「這個任務做了什麼?」。而 agent 自己的總結,短到讀得完,卻正是日誌存在要檢查的東西。

誰需要這個答案?三個人,在三個時間點。

  • 你,隔天早上。工作是昨天做的。你不記得改了哪些檔案,也不記得為什麼某個檢查做了兩次。
  • 沒在旁邊看的同事或主管。他們想知道做了什麼、有沒有人檢查過,而且願意花幾分鐘。
  • 你,以後出了問題的時候。有人問「這個改動是誰批准的?」「有檢查過嗎?」。你想從文件裡找到答案,不是靠記憶。

報告要是要讀一個小時,這些人就不會讀。所以報告是個設計問題:一頁上放什麼,什麼留給日誌。

问题

日志不是报告。读完上一章之后,你可能有一份几千行的日志。没人会读它来回答“这个任务做了什么”。而 agent 自己的总结,短到读得完,却正是日志要检查的东西。

谁需要这个答案?三个人,在三个时间点。

  • 你,第二天早上。活是昨天干的。你不记得改了哪些文件,也不记得为什么某个检查做了两次。
  • 没在旁边看的同事或管理者。他们想知道做了什么、有没有人检查过,而且愿意花几分钟。
  • 你,以后出了问题的时候。有人问“这个改动是谁审批的”“检查过吗”。你想从文档里找到答案,而不是靠记忆。

报告要是得读一个小时,这些人就不会读。所以报告是个设计问题:一页上放什么,什么留给日志。

How it works

One page per task, written by code

A task here is one piece of work with its own folder: the request, the plan, the checks and the changes (Manage tasks, not chats). When the task closes, a program reads the folder and the records, and writes one report. The agent does not write it.

That one choice carries most of the weight. A report written by the agent is a summary, and a summary is what you could not trust in the first place. A report put together by a program from the folder and the log has the same facts every time, in the same places, so a reader learns where to look.

MANY TASKS: THE BOARD A: to approve B: running C: finished D: needs you The board points; the report explains. ONE TASK: ONE PAGE 1. What was asked, what was done 2. Who approved, and when 3. What changed (files, lines) 4. Checks: how many, result 5. What was refused, and why 6. Time and usage, by stage Every line comes from a record, not from the agent.
The board shows many tasks at a glance. When one task finishes, it gets one page a person can read in five minutes.

What goes on the page

Start from the questions the three readers ask, and give each a place. In my setup the report holds:

  1. What was asked and what was done. The requirement the person confirmed, and the plan.
  2. Who approved, and when. The times of the two approvals (Two gates).
  3. What changed. Which files, how many lines added and removed, and which knowledge-base files were read (A knowledge base).
  4. The checks. How many independent checks, and the verdict of each (Make a pass count).
  5. What was refused. The calls the rules turned down, and why. This part surprises people, and it often explains why a task took longer than expected.

Here is the layout, as a template and not a real report:

  • Asked: the confirmed requirement, in one paragraph
  • Approved: plan, at (time); write-back, at (time)
  • Changed: (n) files, +(a) / -(b) lines; knowledge-base files read: (list)
  • Checks: (n) independent checks; verdict of each
  • Refused: each refused call and the rule that refused it

What is left out is the log itself. The report points at the facts and does not repeat all of them. A good test is the five minutes: if a reader cannot finish the page in that time, something on it belongs in the log instead.

Where the time and usage went

A second page next to the report answers a different question: not "what happened?" but "where did the time and the usage go?". It splits each prompt into the model thinking, tools running, subagents, and waiting for the person. Then it sums these by stage (requirement, plan, development, write-back, done; an independent check is a stage of its own).

The waiting time is the number I did not expect to matter. Suppose a task "took three days", and the page shows the agent worked for forty minutes and waited for a person the rest (the numbers are an example, not a result). Then the cost is waiting, not the agent. That is a different problem from a slow agent, and it has a different fix: fewer or cheaper gates, or someone to answer them (Ten things at once).

The numbers come from the hook log and the platform's own session record, not from the agent's word (Record what happened, not what the agent said says where usage comes from and what happens when that record cannot be read). Opening the page costs no tokens. If you want the agent to explain it to you, you ask for that on purpose, and then it reads the page.

The board: many tasks at a glance

When you have one task, you do not need a board. When you have ten, the question changes from "what did this task do?" to "which task needs me now?". A board is one page that lists every open task, what it is waiting for, and for how long. It is built from the same task folders and records as the report, so the two cannot disagree. Ten things at once: parallel tasks has the design.

Try it by hand

You do not need a program to see whether the idea works. After your next agent task, write five lines from the diff and the tool-call history: what was asked, what changed, what was run, what was refused or failed, and who said yes. Then ask yourself whether you would read that page tomorrow, and whether a colleague could use it. If it takes you more than a few minutes to write, that tells you what the program has to collect.

Where the person steps in

The report and the board are where a person meets the system. Three points matter.

  • The board is for steering. You open a task from it, approve a plan, or pause a task. Approvals still go through a channel the agent cannot reach.
  • The report is for reading afterwards. It is written when the task closes, so it shows the task as it ended.
  • A saved copy is for people with no access. The task page can be saved as a single file that opens offline, for a leader who has no access to your board. It is a copy from the moment you saved it, with no buttons. Read it before you send it, and take out internal names and paths before it goes outside the group that owns the task.

What an agent writes is drawn as plain text on these pages, so a task file cannot make the page run anything (Text the agent reads can give it orders).

原理

每個任務一頁,由程式寫

這裡的任務,是有自己資料夾的一件工作:需求、計畫、檢查和改動(管任務,不管對話)。任務結束時,一個程式讀資料夾和紀錄,寫出一份報告。不是 agent 寫的。

這個選擇承擔了大部分的分量。agent 寫的報告是一份總結,而總結本來就是你一開始不能信的東西。由程式從資料夾和日誌拼出來的報告,每次都有同樣的事實、放在同樣的位置,讀的人就學會該看哪裡。

很多任務:看板 A:等批准 B:agent 在做 C:做完了 D:等你 看板指路, 報告解釋。 一個任務:一頁 1. 要求什麼、做了什麼 2. 誰批准、什麼時候 3. 改了什麼(檔案、行數) 4. 檢查:幾次、結果如何 5. 什麼被拒絕、為什麼 6. 各階段的時間和用量 每一行都來自紀錄, 不是 agent 說的。
看板讓你一眼看完很多任務。一個任務做完,就有一頁五分鐘讀得完的報告。

這一頁放什麼

從三種讀者會問的問題出發,每個問題給一個位置。在我的設定裡,報告包含:

  1. 要求了什麼、做了什麼。人確認過的需求,和計畫。
  2. 誰批准、什麼時候。兩次批准的時間(兩道門:人在哪裡批准)。
  3. 改了什麼。哪些檔案、加了多少行、刪了多少行,以及讀了哪些知識庫檔案(知識庫:程式碼的誠實索引)。
  4. 檢查。有幾次獨立檢查,每一次的結論(讓「通過」可信)。
  5. 什麼被拒絕。規則擋下的呼叫,和原因。這一塊常讓人意外,也常能解釋為什麼任務比預期花得久。

版面是這樣,這是範本,不是真的報告:

  • 要求:確認過的需求,一段
  • 批准:計畫,於(時間);寫回,於(時間)
  • 改動:(n)個檔案,+(a)/-(b)行;讀過的知識庫檔案:(清單)
  • 檢查:(n)次獨立檢查;每一次的結論
  • 拒絕:每一次被拒絕的呼叫,和拒絕它的規則

沒放進去的是日誌本身。報告指向這些事實,不會全部重複一遍。一個好用的測試就是五分鐘:讀的人在這段時間內讀不完這一頁,就是上面有東西該放回日誌。

時間和用量花在哪裡

報告旁邊有第二頁,回答另一個問題:不是「發生了什麼?」,而是「時間和用量花在哪裡?」。它把每個 prompt 拆成模型思考、工具執行、子 agent,和等人。然後依階段加總(需求、計畫、開發、寫回、完成;獨立檢查自己算一個階段)。

等待的時間,是我沒想到會這麼重要的數字。假設一個任務「花了三天」,那一頁顯示 agent 工作了四十分鐘,其餘時間都在等人(數字只是舉例,不是結果)。那麼成本是在等待,不是 agent。這和 agent 慢是不同的問題,修法也不同:少一點門,或讓門便宜一點,或找人來回答它們(同時管十件事:並行的是任務)。

數字來自 hook 日誌和平台自己的會話紀錄,不是 agent 的一面之詞(記下發生了什麼,不是 agent 說了什麼 說了用量從哪裡來,以及讀不到那份紀錄時會怎樣)。打開這一頁不花 token。如果你要 agent 解釋給你聽,你得特地要求,那時它才會去讀這一頁。

看板:一眼看完很多任務

只有一個任務時,你不需要看板。有十個時,問題從「這個任務做了什麼?」變成「現在哪個任務需要我?」。看板是一頁,列出每個還開著的任務、它在等什麼、等了多久。它用和報告相同的任務資料夾和紀錄建成,所以兩者不會不一致。設計見 同時管十件事:並行的是任務。

手動試試

不用程式,也能看這個想法行不行。下一個 agent 任務之後,從 diff 和工具呼叫的歷史寫五行:要求了什麼、改了什麼、執行了什麼、什麼被拒絕或失敗、誰說了好。然後問自己,明天你會不會讀這一頁,同事能不能用。如果你寫它要花超過幾分鐘,那就告訴你,程式要去收集什麼。

人在哪裡插手

報告和看板,是人和系統碰面的地方。有三點要緊。

  • 看板用來掌舵。你從它打開一個任務、批准計畫,或暫停一個任務。批准仍然走 agent 碰不到的管道。
  • 報告用來事後閱讀。它在任務結束時寫成,所以顯示的是任務結束時的樣子。
  • 存下來的副本,給沒有權限的人。任務頁可以存成一個離線也能打開的單一檔案,給沒有權限進你的看板的主管。它是你存下那一刻的副本,沒有按鈕。送出之前先讀過;要送到擁有這個任務的團體之外時,先拿掉內部名稱和路徑。

agent 寫的東西,在這些頁面上是以純文字畫出來的,所以任務檔案沒辦法讓頁面去執行任何東西(agent 讀到的文字可能在指揮它)。

原理

每个任务一页,由代码写

这里的任务,是有自己文件夹的一件工作:需求、计划、检查和改动(管任务,不管对话)。任务结束时,一个程序读文件夹和记录,写出一份报告。不是 agent 写的。

这个选择承担了大部分分量。agent 写的报告是一份总结,而总结本来就是你一开始不能信的东西。由程序从文件夹和日志拼出来的报告,每次都有同样的事实,放在同样的位置,读的人就知道该看哪里。

很多任务:看板 A:等审批 B:agent 在做 C:做完了 D:等你 看板指路, 报告解释。 一个任务:一页 1. 要求什么、做了什么 2. 谁审批、什么时候 3. 改了什么(文件、行数) 4. 检查:几次、结果如何 5. 什么被拒绝、为什么 6. 各阶段的时间和用量 每一行都来自记录, 不是 agent 说的。
看板让你一眼看完很多任务。一个任务做完,就有一页五分钟读得完的报告。

这一页放什么

从三种读者会问的问题出发,每个问题给一个位置。在我的配置里,报告包含:

  1. 要求了什么、做了什么。人确认过的需求,和计划。
  2. 谁审批、什么时候。两次审批的时间(两道门:人在哪里审批)。
  3. 改了什么。哪些文件、加了多少行、删了多少行,以及读过哪些知识库文件(知识库:代码的诚实索引)。
  4. 检查。有几次独立检查,每一次的结论(让“通过”可信)。
  5. 什么被拒绝。规则拦下的调用,和原因。这一块常让人意外,也常能解释为什么任务比预期花的时间长。

版面是这样的,这是模板,不是真的报告:

  • 要求:确认过的需求,一段
  • 审批:计划,于(时间);写回,于(时间)
  • 改动:(n)个文件,+(a)/-(b)行;读过的知识库文件:(清单)
  • 检查:(n)次独立检查;每一次的结论
  • 拒绝:每一次被拒绝的调用,和拒绝它的规则

没放进去的是日志本身。报告指向这些事实,不会全部重复一遍。一个好用的测试就是五分钟:读的人在这段时间内读不完这一页,就说明上面有东西该放回日志。

时间和用量花在哪里

报告旁边有第二页,回答另一个问题:不是“发生了什么”,而是“时间和用量花在哪里”。它把每个 prompt 拆成模型思考、工具运行、子 agent,和等人。然后按阶段加总(需求、计划、开发、写回、完成;独立检查自己算一个阶段)。

等待的时间,是我没想到会这么重要的数字。假设一个任务“花了三天”,那一页显示 agent 干了四十分钟,其余时间都在等人(数字只是举例,不是结果)。那么代价出在等待上,不在 agent。这和 agent 慢是不同的问题,解法也不同:少设几道关卡,或者让关卡更便宜,或者找人来回答它们(同时管十件事:并行的是任务)。

这些数字来自 hook 日志和平台自己的会话记录,不是 agent 的一面之词(用量从哪里来,记录读不到时会怎样,见记下发生了什么,而不是 agent 说了什么)。打开这一页不花 token。如果你想让 agent 给你讲解,要专门提出来,那时它才会去读这一页。

看板:一眼看完很多任务

只有一个任务时,不需要看板。有十个时,问题就从“这个任务做了什么”变成“哪个任务现在需要我”。看板是一页纸,列出每个未完成的任务、它在等什么、等了多久。它用的任务文件夹和记录,和报告是同一份,所以两者不会互相矛盾。设计见同时管十件事:并行的是任务。

手动试一次

不用写程序,也能看出这个想法行不行。下次 agent 做完一个任务后,根据 diff 和工具调用历史写五行:要求了什么、改了什么、跑了什么、什么被拒绝或失败了、谁点了头。然后问问自己,明天你会不会读这一页,同事用不用得上。如果写起来要好几分钟以上,这就告诉你程序要去收集什么。

人在哪里介入

报告和看板,是人和这套系统见面的地方。有三点要紧。

  • 看板用来掌舵。你从它打开一个任务、审批一份计划,或者暂停一个任务。审批仍然走 agent 够不着的渠道。
  • 报告用来事后阅读。它在任务结束时写成,所以展示的是任务结束时的样子。
  • 保存的副本给没有权限的人。任务页可以存成一个能离线打开的单文件,给没有权限访问你看板的管理者。它是你保存那一刻的副本,没有按钮。发出去之前先读一遍,并且在它离开负责这个任务的小组之前,去掉内部名称和路径。

agent 写的内容在这些页面上都按纯文本显示,所以任务文件没法让页面运行任何东西(agent 读到的文字可能在指挥它)。

Costs and traps

A report is only as honest as its sources. It is built from the log and the folder. If the log has a hole (Record what happened), the report has the same hole and does not say so.

Five minutes is a limit you have to defend. Everyone wants one more number on the page. Move it to the log or the analysis page; keep the report short.

A report says what happened, not whether it was good. It can show that the task went through the two approvals and that its checks passed. It cannot show that the work was better than last week's, because nothing scores quality across tasks; I have no such score. To get one you would run fixed tasks before and after a change (the next chapters), which are not real work, or have a person read a sample of finished tasks.

A report is a record, not a signature. Whether it counts as evidence for approving a change, how long it is kept, and who may edit it are decisions for the team (Roll out and govern a harness). The report itself is written once, by code, at close.

Nobody reads a report that nobody asks for. If no one ever opens the reports, ask why before you improve them.

代價和陷阱

報告的誠實程度,只和它的來源一樣。它由日誌和資料夾建成。日誌有洞(記下發生了什麼,不是 agent 說了什麼),報告就有一樣的洞,而且不會說出來。

五分鐘是一條要守的線。每個人都想在頁面上多加一個數字。把它移到日誌或分析頁,讓報告保持簡短。

報告說的是發生了什麼,不是做得好不好。它能顯示任務經過了兩道批准、檢查都通過。它不能顯示這次的工作比上週好,因為沒有東西在跨任務為品質打分;我沒有這樣的分數。要有的話,你得在改動前後跑固定的任務(固定的任務,用腳本打分),那不是真實的工作,或者讓人讀一批完成任務的樣本。

報告是紀錄,不是簽名。它算不算批准一項改動的證據、保留多久、誰可以編輯,是團隊要決定的事(落地與治理)。報告本身只在結束時,由程式寫一次。

沒人要的報告,沒人會讀。如果從來沒有人打開報告,先問為什麼,再去改進它們。

代价和坑

报告只和它的来源一样诚实。它是从日志和文件夹拼出来的。日志里有漏洞(记下发生了什么),报告里就有同样的漏洞,而且不会说出来。

五分钟是一条要靠你去守的线。每个人都想在页面上再加一个数字。把它移到日志或分析页,让报告保持简短。

报告说的是发生了什么,不是做得好不好。它能显示任务走过了两次审批、检查都通过了。它没法显示这份活比上周的更好,因为没有东西能跨任务给质量打分;我没有这样的分数。要得到这样的分数,你得在改动前后各跑一遍固定任务(后面几章),这些不是真正的工作;或者让人抽样读一些完成的任务。

报告是记录,不是签字。它算不算批准一项改动的证据、保存多久、谁能编辑它,这些是团队要定的事(落地与治理)。报告本身只在结束时由代码写一次。

没人要的报告,就没人读。如果从来没人打开这些报告,先问为什么,再去改进它们。

When to delete it Industry practice

My report and board exist because the platform shows a chat, not a task. If the platform gives you tasks with their own history, approvals and usage per task, use that and drop the page you built. If it can show a leader a read-only view with the same facts, drop the saved copy too.

The reasoning stays. A person who did not watch needs to know what was done, who approved it, what was checked and what it cost, in a form that takes minutes. I would look again at the board if I found that I never run more than two tasks at once.

什麼時候可以刪掉 業界做法

我的報告和看板存在,是因為平台顯示的是對話,不是任務。如果平台提供任務,並且有各自的歷史、批准和每個任務的用量,就用那個,把你建的頁面丟掉。如果它能給主管一個唯讀的檢視、事實相同,存下來的副本也可以丟掉。

道理會留著。沒在旁邊看的人,需要知道做了什麼、誰批准、檢查了什麼、花了多少,而且形式要是幾分鐘就讀完。如果我發現自己從來不會同時跑超過兩個任務,我會重新檢視看板。

什么时候可以删掉 业界做法

我的报告和看板之所以存在,是因为平台显示的是对话,不是任务。如果平台给你的是任务,每个任务有自己的历史、审批和用量,就用它的,把你自己搭的那一页丢掉。如果它能给管理者一个只读视图,展示同样的事实,保存的副本也可以丢掉。

背后的道理不变。没在旁边看的人,需要在几分钟内知道做了什么、谁审批的、检查了什么、花了多少。如果我发现自己同时从来不会跑超过两个任务,我会重新考虑看板。

Try it on your own setup

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

Take the last three merged changes in this repository. For each one, write a five-line report from git history and any linked review or task notes only: what was asked, what changed (files, lines), what was run or checked, what was refused or failed, and who said yes. Where a fact cannot be found in the repository, write "not recorded". Then tell me which of the five facts are missing most often. Do not change any files.

在你自己的環境試試

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

拿這個倉庫最近三個合併的改動。對每一個,只用 git 歷史和任何連結的審查或任務筆記,寫一份五行的報告:要求了什麼、改了什麼(檔案、行數)、執行或檢查了什麼、什麼被拒絕或失敗、誰說了好。倉庫裡找不到的事實,寫「沒有記錄」。然後告訴我,這五件事裡,哪幾件最常缺。不要改任何檔案。

在你自己的环境里试试

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

取这个仓库最近合并的三个改动。对每一个,只根据 git 历史和关联的 review 或任务笔记,写一份五行的报告:要求了什么、改了什么(文件、行数)、跑了或检查了什么、什么被拒绝或失败了、谁点了头。仓库里找不到的事实,写“未记录”。然后告诉我,这五项事实里哪几项最常缺。不要改任何文件。

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

Copilot Harness writes a report and an analysis page for every task it closes, and has a board of all open tasks. The harness can show you the real pages. After the setup above, type:

/harness-rookie-wondering I have read the chapter "A report a person can read in five minutes". Teach me how this harness reports on a task (topic 12): what the task report holds, how the analysis page gets its time and usage, and what the board shows. Open a real report with me and point out where each part comes from.

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 怎麼為任務出報告(主題 12):任務報告放什麼、分析頁的時間和用量從哪裡來、看板顯示什麼。帶我打開一份真的報告,並指出每一部分是從哪裡來的。

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

在 harness 里探索

Copilot Harness 会给每个它收尾的任务写一份报告和一页分析,还有一块看板列出所有未完成的任务。harness 能给你看真实的页面。完成上面的配置后,输入:

/harness-rookie-wondering 我读过“一份五分钟读得完的报告”这一章。请教我这个 harness 怎么给一个任务出报告(主题 12):任务报告里有什么,分析页的时间和用量从哪里来,看板显示什么。和我一起打开一份真实的报告,指出每一部分是从哪里来的。

它一次只教一小块,会停下来问你跟不跟得上,并和你一起打开文件。