WEBVTT
Kind: captions
Language: zh-TW

00:00:00.000 --> 00:00:03.079
Type Safe 這家公司出了一個模型叫做 Jev，

00:00:03.079 --> 00:00:04.680
它一個字都不會寫。

00:00:04.680 --> 00:00:06.949
你不能叫它寫文章，不能叫它寫程式，

00:00:06.949 --> 00:00:10.280
它連自己為什麼這樣判斷都不會解釋給你聽。

00:00:10.280 --> 00:00:13.446
因為 Jev 把所有力氣都花在一件事情上面：

00:00:13.446 --> 00:00:16.467
你給它一組自己定好的選項，它在裡面選一個，

00:00:16.467 --> 00:00:18.200
然後告訴你它有多確定。

00:00:18.200 --> 00:00:20.164
問一次不到一秒，而且輸出完全免費，

00:00:20.164 --> 00:00:22.080
因為它根本沒有產生文字。

00:00:22.080 --> 00:00:24.989
Jev 是什麼、為什麼可以做到這件事、背後是誰做的，

00:00:24.989 --> 00:00:27.240
我在 EP404 已經完整講過一次了。

00:00:27.240 --> 00:00:28.500
如果你還沒聽過，可以直接點過去。

00:00:28.500 --> 00:00:30.240
今天這一集不重新講那些。

00:00:30.240 --> 00:00:32.148
今天要給你的是五個最多人在做、

00:00:32.148 --> 00:00:35.328
而且實際跑起來確實有用的用法，每一個用法該怎麼做，

00:00:35.328 --> 00:00:36.346
我會直接跟你說，

00:00:36.346 --> 00:00:39.480
包括為什麼那個地方用 Jev 會比用大模型好。

00:00:39.480 --> 00:00:42.922
在講用法之前，先花一分鐘把 Jev 的形狀講清楚，

00:00:42.922 --> 00:00:45.820
因為後面五個用法全部都是這個形狀的變化。

00:00:45.820 --> 00:00:49.038
你送過去的是一份資料，加上一個具名的問題清單，

00:00:49.038 --> 00:00:52.540
每一題要標題型、要給它判斷的說明，還有選項。

00:00:52.540 --> 00:00:53.520
題型有三種。

00:00:53.520 --> 00:00:57.600
第一種是是非題，Jev 回你一個零到一之間的校準機率。

00:00:57.600 --> 00:00:59.838
這個數字本身就是它的確定程度，

00:00:59.838 --> 00:01:02.280
不會再另外給你一個信心分數。

00:01:02.280 --> 00:01:05.201
第二種是選擇題，Jev 回你選中的那一個，

00:01:05.201 --> 00:01:07.010
加上每一個選項各自的機率，

00:01:07.010 --> 00:01:10.100
然後另外給你一個 confidence。

00:01:10.100 --> 00:01:13.460
這個分佈等一下在路由那個用法會變成關鍵。

00:01:13.460 --> 00:01:15.858
第三種是評分題，回你一個分數，可以是小數，

00:01:15.858 --> 00:01:18.640
一樣另外給你一個 confidence。

00:01:18.640 --> 00:01:20.820
級距最少兩級，最多十級。

00:01:20.820 --> 00:01:22.820
還有一個數字你先知道比較好。

00:01:22.820 --> 00:01:25.784
有一份獨立評測拿 6000 多筆資料比過，

00:01:25.784 --> 00:01:29.030
Jev 跟頂級模型的判斷一致率是 91.5%，

00:01:29.030 --> 00:01:31.964
跟它同價位的那個小模型是 93.5%。

00:01:31.964 --> 00:01:35.760
所以 Jev 強的是快跟便宜，它沒有比較準。

00:01:35.760 --> 00:01:38.840
這件事很重要，因為它直接決定了下一頁那條規則。

00:01:38.840 --> 00:01:41.900
那條規則是這樣：Jev 真正適合的地方，

00:01:41.900 --> 00:01:45.920
是那些會被快速運算很多次、而且不太需要推理的判斷。

00:01:45.920 --> 00:01:48.489
因為它的單次優勢其實沒有那麼明顯，

00:01:48.489 --> 00:01:51.240
一次判斷省你幾秒鐘、省你幾分美元。

00:01:51.240 --> 00:01:53.455
可是當這個判斷要發生幾千次、

00:01:53.455 --> 00:01:55.985
或者卡在流程的每一步前面的時候，

00:01:55.985 --> 00:01:58.240
那個差距就被加成上去了。

00:01:58.240 --> 00:02:00.511
反過來說，如果一件事情只發生幾次，

00:02:00.511 --> 00:02:02.783
那用 Jev 省下來的東西很有限，

00:02:02.783 --> 00:02:04.920
你反而要擔心它答得對不對。

00:02:04.920 --> 00:02:08.060
這條規則還有另外半邊：那個判斷不能需要推理。

00:02:08.060 --> 00:02:11.579
Jev 每一次判斷都是當下的直覺，它不記得上一步，

00:02:11.579 --> 00:02:13.200
也不會替你多想一層。

00:02:13.200 --> 00:02:16.333
所以會被快速運算很多次、而且不太需要推理，

00:02:16.333 --> 00:02:19.660
兩個條件都成立的時候，它才是對的選擇。

00:02:19.660 --> 00:02:23.620
接下來五個用法，我每一個都會告訴你它在那裡要跑幾次。

00:02:23.620 --> 00:02:27.920
我們今天就來拆解 Jev 最多人用、最好用的五個用法。

00:02:27.920 --> 00:02:33.046
大量資訊需要分類、自動分流、讓它自己點瀏覽器、

00:02:33.046 --> 00:02:36.980
決策前的把關，還有指令守門員。

00:02:36.980 --> 00:02:38.882
五個我都會給你實際的做法，

00:02:38.882 --> 00:02:41.240
你聽完挑一個今天晚上就可以試。

00:02:41.240 --> 00:02:43.278
第一個用法，也是最多人在做的一個：

00:02:43.278 --> 00:02:45.460
你手上有一大疊東西要分類。

00:02:45.460 --> 00:02:49.112
Jev 在這件事上面的優勢最明顯，因為量越大，

00:02:49.112 --> 00:02:52.220
它跟大模型的差距就被加成得越開。

00:02:52.220 --> 00:02:55.160
如果你今天只想試一個，我建議從這一個開始。

00:02:55.160 --> 00:02:56.719
它不需要接進任何系統，

00:02:56.719 --> 00:02:58.986
你手上有一份現成的資料就可以跑，

00:02:58.986 --> 00:03:01.620
而且跑完你馬上看得到結果對不對。

00:03:01.620 --> 00:03:03.940
最典型的例子是問卷的開放題。

00:03:03.940 --> 00:03:07.018
選擇題 5 分鐘就統計完了，那一欄「還有什麼想說的」

00:03:07.018 --> 00:03:09.740
常常躺在那裡 3 個月沒有人看，因為那是文字，

00:03:09.740 --> 00:03:11.440
沒有人有空一筆一筆讀。

00:03:11.440 --> 00:03:14.389
把它丟給 Jev，題型選選擇題，

00:03:14.389 --> 00:03:18.075
選項就是你自己定的那幾類：這是抱怨價格、

00:03:18.075 --> 00:03:21.780
這是功能許願、這是稱讚、這是在問問題。

00:03:21.780 --> 00:03:24.020
2,000 多筆幾十秒就分完。

00:03:24.020 --> 00:03:28.300
說明就寫「這一則回覆主要在講哪一件事」，這樣就夠了。

00:03:28.300 --> 00:03:32.380
真正決定結果好壞的是選項要互相排斥。

00:03:32.380 --> 00:03:36.711
如果你放了兩個意思重疊的類別，它會在兩個中間搖擺，

00:03:36.711 --> 00:03:39.700
你就會看到一整排信心很低的結果。

00:03:39.700 --> 00:03:43.471
另外有一件事很容易漏掉：
如果你希望它能說「都不適合」，

00:03:43.471 --> 00:03:45.560
你要自己把這個選項也放進去。

00:03:45.560 --> 00:03:48.217
你不放，它一定會在你給的選項裡面硬選一個，

00:03:48.217 --> 00:03:49.640
而且信心還可能不低。

00:03:49.640 --> 00:03:52.716
同一個用法還有一個變化型，我覺得比分類更值得學：

00:03:52.716 --> 00:03:54.380
cluster。

00:03:54.380 --> 00:03:57.414
cluster 跟分類的差別是這樣：分類是你先想好類別，

00:03:57.414 --> 00:03:59.480
可是有時候你根本不知道該分成哪幾類。

00:03:59.480 --> 00:04:02.048
這時候做法反過來：不給它類別，

00:04:02.048 --> 00:04:06.841
改成兩兩成對問一題是非題「這
兩件事情是不是同一個主題」，

00:04:06.841 --> 00:04:09.520
然後讓相關的自己聚成一團。

00:04:09.520 --> 00:04:12.097
分完群之後，你再找一個便宜的語言模型，

00:04:12.097 --> 00:04:13.620
幫每一團取一個名字。

00:04:13.620 --> 00:04:18.560
Jev 負責判斷關係，語言模型負責命名，各做各最擅長的。

00:04:18.560 --> 00:04:22.078
有人拿這個做法去跑自己專案一整年的 PR，

00:04:22.078 --> 00:04:25.120
想知道團隊的力氣到底花在哪裡。

00:04:25.120 --> 00:04:27.030
100 多個 PR 花了 1.1 分美元；

00:04:27.030 --> 00:04:29.720
2,000 個 PR 花 9 分美元，跑大概 2 分鐘。

00:04:29.720 --> 00:04:31.128
這種問題以前做得到，

00:04:31.128 --> 00:04:33.944
只是做一次的代價高到讓人算一算就放棄了，

00:04:33.944 --> 00:04:36.220
所以大部分團隊從來沒真的做過。

00:04:36.220 --> 00:04:38.268
這個用法每一筆都要跑一次，

00:04:38.268 --> 00:04:40.820
所以它是五個裡面最划算的一個。

00:04:40.820 --> 00:04:43.278
同樣 2,000 筆，大模型要跑幾 10 分鐘、

00:04:43.278 --> 00:04:46.080
花你幾 10 美元，而且你八成不會真的去跑。

00:04:46.080 --> 00:04:47.000
門檻怎麼設？

00:04:47.000 --> 00:04:50.592
這裡的兩種錯代價其實差不多，一筆被歸錯類，

00:04:50.592 --> 00:04:52.680
你之後翻回來重標就好。

00:04:52.680 --> 00:04:54.762
所以門檻可以設得比較高，

00:04:54.762 --> 00:04:59.619
讓它不確定的那一小疊進一個你每天花 10 分鐘看的地方，

00:04:59.619 --> 00:05:01.740
其餘的讓它自己分完。

00:05:01.740 --> 00:05:02.874
有一個實作上的限制要知道：

00:05:02.874 --> 00:05:06.562
Jev 一次吃得下 6 萬 4000 個 token。

00:05:06.562 --> 00:05:09.604
幾千筆不能一次送過去，要自己切成好幾批。

00:05:09.604 --> 00:05:12.914
切好平行送出去，總時間會從一分多鐘掉到幾秒，

00:05:12.914 --> 00:05:14.780
而且成本完全一樣。

00:05:14.780 --> 00:05:19.040
第二個用法是路由：一件事情進來，決定它該交給誰處理。

00:05:19.040 --> 00:05:22.400
而且我要先講的那個目的地不是人，是模型。

00:05:22.400 --> 00:05:24.660
這一個適合已經有東西在線上跑的人。

00:05:24.660 --> 00:05:27.354
如果你的流程每天會被觸發幾百次以上，

00:05:27.354 --> 00:05:30.198
這裡省下來的錢通常比前面那個用法還多，

00:05:30.198 --> 00:05:32.780
因為它是每一個請求都要跑一次。

00:05:32.780 --> 00:05:35.655
你手上如果不只一個模型，有便宜的也有貴的，

00:05:35.655 --> 00:05:38.820
那「這一題要用哪一個」本身就是一個判斷。

00:05:38.820 --> 00:05:40.817
大部分人的做法是隨便選一個，

00:05:40.817 --> 00:05:42.840
或者叫一個貴的模型來決定。

00:05:42.840 --> 00:05:46.699
後面這個做法有個很明顯的問題：你光是決定要用哪一個，

00:05:46.699 --> 00:05:50.040
就已經先付了一次貴模型的錢，還要等它想完。

00:05:50.040 --> 00:05:52.211
這個判斷是擋在一堆昂貴的東西前面的，

00:05:52.211 --> 00:05:53.780
它自己不能也很昂貴。

00:05:53.780 --> 00:05:56.297
換成 Jev，題型選選擇題，

00:05:56.297 --> 00:05:59.174
選項就是你手上那幾個模型的定位：

00:05:59.174 --> 00:06:02.591
這一題是簡單的事實查詢、需要多步推理、

00:06:02.591 --> 00:06:04.620
還是需要寫長篇內容。

00:06:04.620 --> 00:06:08.160
說明裡面把每一個模型擅長什麼各寫一句。

00:06:08.160 --> 00:06:12.037
有人把面板做成底下掛兩個計數器：你實際花了多少，

00:06:12.037 --> 00:06:14.460
跟全部都送給貴模型會花多少。

00:06:14.460 --> 00:06:18.347
這一個每一個請求都要跑一次，所以請求量越大，

00:06:18.347 --> 00:06:20.500
那兩個數字差得越開。

00:06:20.500 --> 00:06:22.800
同一個做法換成派給人也成立。

00:06:22.800 --> 00:06:25.312
進來一張工單，內容是付款一直失敗，

00:06:25.312 --> 00:06:27.980
Jev 同時算出三個目的地的機率。

00:06:27.980 --> 00:06:30.627
這一題的說明要寫得比前面細一點，

00:06:30.627 --> 00:06:34.928
因為你要教它每個目的地負責什麼：帳務處理付款、發票、

00:06:34.928 --> 00:06:38.568
退費；技術處理打不開、跑不動、出現錯誤訊息；

00:06:38.568 --> 00:06:40.700
業務處理報價跟方案。

00:06:40.700 --> 00:06:43.696
可是換成另外一張工單，帳務 0.42、技術 0.39。

00:06:43.696 --> 00:06:48.442
最高的那個雖然還是帳務，但它跟第二名只差 0.03。

00:06:48.442 --> 00:06:51.460
所以這個用法你要看的東西跟前面都不一樣。

00:06:51.460 --> 00:06:54.920
你要看的是第一名跟第二名差多少，不是最高那個有多高。

00:06:54.920 --> 00:06:57.602
差距很小就代表 Jev 其實分不出來，

00:06:57.602 --> 00:06:59.014
那就讓它停下來問人，

00:06:59.014 --> 00:07:02.020
不要讓它自己猜一個然後整條流程跑錯方向。

00:07:02.020 --> 00:07:04.715
這也是為什麼選擇題會把整個分佈都回給你，

00:07:04.715 --> 00:07:06.580
而不是只回一個答案。

00:07:06.580 --> 00:07:10.240
第三個用法，是讓你的工具自己開瀏覽器去做事。

00:07:10.240 --> 00:07:13.247
現在很多工具會自己上網查資料、自己跑報表、

00:07:13.247 --> 00:07:14.480
自己填表單。

00:07:14.480 --> 00:07:15.687
它們慢的原因，

00:07:15.687 --> 00:07:20.220
是每一步要點哪裡都要先問一次那個會寫文章的大模型。

00:07:20.220 --> 00:07:22.424
這一個的門檻比前面兩個高一點，

00:07:22.424 --> 00:07:25.980
因為你要有一個會自己操作瀏覽器的工具才用得到。

00:07:25.980 --> 00:07:29.099
但如果你已經有了，這是感受差距最明顯的一個，

00:07:29.099 --> 00:07:31.260
因為慢是你自己在旁邊看著的。

00:07:31.260 --> 00:07:33.538
換成 Jev 以後做法不一樣：

00:07:33.538 --> 00:07:36.119
每一步都把這個畫面上可以點的東西，

00:07:36.119 --> 00:07:38.900
重新列成一份純文字的清單。

00:07:38.900 --> 00:07:42.119
然後讓 Jev 從清單裡面選一個，點下去，

00:07:42.119 --> 00:07:44.265
再從新的畫面列一份新的清單，

00:07:44.265 --> 00:07:47.660
一直重複到它判斷目標達成或者被擋住為止。

00:07:47.660 --> 00:07:50.640
需要打字的時候再交給一個小模型去填。

00:07:50.640 --> 00:07:52.180
這裡是每一步都要跑一次。

00:07:52.180 --> 00:07:54.381
一個流程十幾步，每一步差個三秒，

00:07:54.381 --> 00:07:56.180
整條流程就差了快一分鐘。

00:07:56.180 --> 00:07:58.946
而且這個判斷本質上是「從清單裡選一個」，

00:07:58.946 --> 00:08:00.760
根本不需要會寫字的能力。

00:08:00.760 --> 00:08:04.339
有一件事要講清楚：
最後判斷「這個功能到底做對了沒有」，

00:08:04.339 --> 00:08:06.100
還是要留給主要那個模型。

00:08:06.100 --> 00:08:09.240
Jev 只負責決定下一步點哪裡。

00:08:09.240 --> 00:08:12.940
這個用法我看過最實用的一個做法，是拿它來測權限。

00:08:12.940 --> 00:08:15.263
分別用管理員、主管、一般員工登入，

00:08:15.263 --> 00:08:17.177
讓它自己把每個身分該進得去、

00:08:17.177 --> 00:08:18.953
不該進得去的頁面都走一遍，

00:08:18.953 --> 00:08:22.160
看有沒有哪個人進得去他不該進去的地方。

00:08:22.160 --> 00:08:26.160
這種測試人工做很煩，所以大部分團隊根本不做。

00:08:26.160 --> 00:08:28.480
門檻在這裡是由動作本身決定的。

00:08:28.480 --> 00:08:31.031
只是讀一下、查一下，門檻可以低一點，

00:08:31.031 --> 00:08:32.620
做錯了再做一次就好。

00:08:32.620 --> 00:08:35.699
會改到資料、會送出去給別人看、會花到錢的，

00:08:35.699 --> 00:08:37.380
門檻就要高一點。

00:08:37.380 --> 00:08:40.978
第四個用法，是東西要送出去給別人看之前，

00:08:40.978 --> 00:08:42.500
先自動看一遍。

00:08:42.500 --> 00:08:46.636
你現在大概已經讓 AI 幫你擬回信、擬報價、擬產品文案、

00:08:46.636 --> 00:08:47.640
擬週報了。

00:08:47.640 --> 00:08:49.295
這些東西你不太敢直接送出去，

00:08:49.295 --> 00:08:51.080
所以你每一份都自己看過一遍。

00:08:51.080 --> 00:08:55.360
這個用法就是幫你評估 AI 生
成的文案是不是可以直接送出。

00:08:55.360 --> 00:08:58.567
這裡不是幫你省錢，但幫你省下了你的注意力，

00:08:58.567 --> 00:09:02.140
從每一份都要確認，變成只看它不確定的那幾份。

00:09:02.140 --> 00:09:05.520
做法是同一份草稿，一次問三題是非題。

00:09:05.520 --> 00:09:06.580
三題可以這樣寫。

00:09:06.580 --> 00:09:12.660
第一題寫「收件人、金額、日期這三個欄位，
內容裡都有而且都不是空的嗎」。

00:09:12.660 --> 00:09:17.340
第二題寫「這段文字的語氣，
適合寄給一個還沒成交的客戶嗎」。

00:09:17.340 --> 00:09:21.980
第三題寫「文章裡提到的數字或說法，有沒有附上出處」。

00:09:21.980 --> 00:09:24.656
這裡是一次問好幾題，而且方向跟前面相反：

00:09:24.656 --> 00:09:27.466
因為 Jev 是拿同一份資料一起判斷完的，

00:09:27.466 --> 00:09:29.080
多問幾題幾乎不會變慢。

00:09:29.080 --> 00:09:30.990
換成大模型，你要嘛問 3 次，

00:09:30.990 --> 00:09:33.580
要嘛叫它寫一段長輸出再自己拆解出來讀。

00:09:33.580 --> 00:09:35.680
三題都過就直接送出去。

00:09:35.680 --> 00:09:38.240
有一題不確定，就需要讓你先審核。

00:09:38.240 --> 00:09:41.100
有明顯不通過的，就退回去重做。

00:09:41.100 --> 00:09:43.840
要注意的是 Jev 只會說不行，不會告訴你哪裡不行。

00:09:43.840 --> 00:09:46.917
所以退回去的時候，你要自己把是哪一題沒過一起帶上，

00:09:46.917 --> 00:09:48.620
不然它不知道要改什麼。

00:09:48.620 --> 00:09:52.569
同一個位子還有一個評分題的用法，工程團隊應該都有感：

00:09:52.569 --> 00:09:55.560
bug 進來的時候先自動分嚴重程度。

00:09:55.560 --> 00:09:59.134
題型選評分題，級距就設三級或五級：這是只影響外觀的、

00:09:59.134 --> 00:10:02.040
是某個功能壞掉的、還是整個卡住不能用的。

00:10:02.040 --> 00:10:04.720
說明裡面把每一級實際長什麼樣子各寫一句。

00:10:04.720 --> 00:10:07.910
有一個原則我建議你守著：這個分數拿來排順序，

00:10:07.910 --> 00:10:09.520
不要拿來自動做處置。

00:10:09.520 --> 00:10:11.748
讓它決定今天早上誰先被看到，

00:10:11.748 --> 00:10:14.460
不要讓它決定哪一張可以直接關掉。

00:10:14.460 --> 00:10:17.692
第五個用法，如果你有在用那種會自己跑指令的工具，

00:10:17.692 --> 00:10:19.500
這一個我認為最值得先做。

00:10:19.500 --> 00:10:21.297
它擋的是那種平常不會發生，

00:10:21.297 --> 00:10:23.660
但是一旦發生就讓你很崩潰的事情。

00:10:23.660 --> 00:10:27.380
前面四個用法都是在幫你省時間跟省錢，這一個是保險。

00:10:27.380 --> 00:10:29.801
它平常毫無存在感，但是如果用到了，

00:10:29.801 --> 00:10:32.320
你會非常感謝自己有做這條保險。

00:10:32.320 --> 00:10:36.447
做法是在那個會跑指令的工具被呼叫之前，掛一道檢查，

00:10:36.447 --> 00:10:39.840
把整條指令送給 Jev，問一題是非題。

00:10:39.840 --> 00:10:42.720
你可能會想，這種事寫一份黑名單不就好了。

00:10:42.720 --> 00:10:45.840
問題是黑名單只擋得到你想得到的那幾條。

00:10:45.840 --> 00:10:50.280
通常真正出事的那次，是你從來沒想過的指令。

00:10:50.280 --> 00:10:53.086
所以那一題不要寫成「是不是這幾條指令」，

00:10:53.086 --> 00:10:56.032
要寫成「這條指令會不會造成不可逆的破壞」，

00:10:56.032 --> 00:10:58.837
然後在說明裡面給它 3 到 5 個例子，

00:10:58.837 --> 00:11:00.440
剩下的讓它自己推斷。

00:11:00.440 --> 00:11:02.203
同一套也可以拿來擋寫入，

00:11:02.203 --> 00:11:04.760
例如不准它去動放金鑰的那個檔案。

00:11:04.760 --> 00:11:07.620
這裡是每一次動作之前都要跑一次。

00:11:07.620 --> 00:11:11.378
這道檢查卡在每一步前面，所以它必須快到你感覺不到，

00:11:11.378 --> 00:11:13.200
不然你會自己把它拿掉。

00:11:13.200 --> 00:11:17.088
門檻在這裡要拉到很高，而且只要 Jev 不確定，

00:11:17.088 --> 00:11:19.100
就一律讓它停下來問人。

00:11:19.100 --> 00:11:22.500
理由很簡單：這裡的兩種錯代價差太多了。

00:11:22.500 --> 00:11:25.600
擋錯了，你多按一次確認；放錯了，是資料回不來。

00:11:25.600 --> 00:11:27.920
所以這裡寧可多擋，不要少擋。

00:11:27.920 --> 00:11:31.468
不過有一件事你要先知道：這個用法我看到有作者分享過，

00:11:31.468 --> 00:11:34.240
他實際跑下來有幾次成功、也有幾次失敗。

00:11:34.240 --> 00:11:37.864
所以不要把它當成最後一道防線，它是一道很便宜、

00:11:37.864 --> 00:11:39.439
可以一直開著的篩子，

00:11:39.439 --> 00:11:42.720
你原本該有的備份跟權限設定還是要有。

00:11:42.720 --> 00:11:45.676
前面每一個用法我都給了一個門檻的數字，

00:11:45.676 --> 00:11:47.700
但那些都是別人的參考值。

00:11:47.700 --> 00:11:50.140
確切來說，你自己的 threshold 要怎麼得到？

00:11:50.140 --> 00:11:51.400
我們這邊來聊一下。

00:11:51.400 --> 00:11:52.480
做法很簡單。

00:11:52.480 --> 00:11:57.080
你自己先人工判斷 100 到 200 筆，每一類都要有幾十筆。

00:11:57.080 --> 00:12:01.258
然後在幾個不同的門檻底下，分別算算看兩種錯各有幾筆：

00:12:01.258 --> 00:12:05.400
一種是該放過卻被擋下來，一種是該擋卻被放過去。

00:12:05.400 --> 00:12:07.740
這兩個數字會往相反的方向跑。

00:12:07.740 --> 00:12:11.595
門檻拉高，被擋下來的變多，你自己要看的東西就變多；

00:12:11.595 --> 00:12:14.140
門檻拉低，被放過去的錯就變多。

00:12:14.140 --> 00:12:16.920
選一個你可以接受的，那就是你的門檻。

00:12:16.920 --> 00:12:19.558
而你之後遇到第六個、第七個想法的時候，

00:12:19.558 --> 00:12:22.057
也可以自己判斷值不值得換成 Jev：

00:12:22.057 --> 00:12:24.556
就看那個判斷會不會被快速運算很多次，

00:12:24.556 --> 00:12:26.080
以及它需不需要推理。

00:12:26.080 --> 00:12:28.320
兩個都成立才是它的主場。

00:12:28.320 --> 00:12:29.700
那實際上要怎麼接起來？

00:12:29.700 --> 00:12:32.120
看你手上有沒有在寫程式，兩條路。

00:12:32.120 --> 00:12:34.736
如果你有在用那種可以自己跑程式的 AI，

00:12:34.736 --> 00:12:38.200
官方有出一個現成的 skill，兩行指令就裝好了。

00:12:38.200 --> 00:12:41.209
第一行是 claude plugin marketplace add，

00:12:41.209 --> 00:12:43.616
後面接 typesafe 槓 ai 斜線 skills；

00:12:43.616 --> 00:12:45.937
第二行是 claude plugin install，

00:12:45.937 --> 00:12:48.618
後面接 typesafe at typesafe 槓 ai。

00:12:48.618 --> 00:12:53.403
這兩行你搜 typesafe agent skill 就找得到，

00:12:53.403 --> 00:12:55.085
官方文件上有完整的。

00:12:55.085 --> 00:12:58.420
裝完把你的 key 放進專案的 `.env` 檔案裡面。

00:12:58.420 --> 00:12:59.832
有一件事很多人會誤會：

00:12:59.832 --> 00:13:03.500
這個 skill 本身不執行任何東西，它是一本規則書。

00:13:03.500 --> 00:13:07.594
你用白話描述你要判斷什麼，你的 AI 讀那本規則書，

00:13:07.594 --> 00:13:09.798
幫你把題目跟判斷標準寫出來，

00:13:09.798 --> 00:13:13.960
再寫一小段程式把資料送過去，最後把結果讀回來給你。

00:13:13.960 --> 00:13:15.596
如果你完全不想碰程式碼，

00:13:15.596 --> 00:13:19.686
市面上的自動化平台已經可以把
Jev 當成流程裡的一個步驟，

00:13:19.686 --> 00:13:23.400
前面接你的信箱、表單或者試算表，後面接它的判斷結果。

00:13:23.400 --> 00:13:25.720
今天晚上你可以先做三件事情。

00:13:25.720 --> 00:13:29.080
第一，從第一個用法開始，因為它最划算也最不會出事。

00:13:29.080 --> 00:13:32.470
找一疊你早就知道該看、可是一直沒時間看的東西，

00:13:32.470 --> 00:13:37.000
可能是問卷、可能是客訴、可能是你專案裡一整年的紀錄。

00:13:37.000 --> 00:13:40.009
第二，把你想分的類別寫成互相排斥的選項，

00:13:40.009 --> 00:13:42.580
然後自己加一個「都不適合」進去。

00:13:42.580 --> 00:13:44.387
如果你連該分成哪幾類都還不確定，

00:13:44.387 --> 00:13:47.920
那就用 cluster 那個做法，兩兩問它相不相關。

00:13:47.920 --> 00:13:50.220
第三，第 1 個禮拜先不要讓它真的動手。

00:13:50.220 --> 00:13:52.960
先讓它判斷，結果印在旁邊，你自己對一遍。

00:13:52.960 --> 00:13:56.020
對完那一輪，你就順便把門檻量出來了。

00:13:56.020 --> 00:13:58.515
今天講的五個用法，我幫你整理一次，

00:13:58.515 --> 00:14:00.900
順便把每一個要跑幾次再講一遍。

00:14:00.900 --> 00:14:04.246
大量資訊需要分類，每一筆都要跑一次，量越大越划算，

00:14:04.246 --> 00:14:07.500
而且不知道該分幾類的時候可以改成兩兩問相關。

00:14:07.500 --> 00:14:09.473
自動分流，每一個請求都要跑一次，

00:14:09.473 --> 00:14:12.060
而且你要看的是第一名跟第二名的差距。

00:14:12.060 --> 00:14:14.833
讓它自己點瀏覽器，每一步都要跑一次，

00:14:14.833 --> 00:14:17.900
最後那個做對了沒有還是留給大模型。

00:14:17.900 --> 00:14:20.820
決策前的把關，一次問三題幾乎不變慢。

00:14:20.820 --> 00:14:23.985
指令守門員，每一次動作之前都要跑一次，

00:14:23.985 --> 00:14:26.280
所以門檻要拉到很高。

00:14:26.280 --> 00:14:29.363
所以整支片你如果只帶走一句話，我希望是這一句：

00:14:29.363 --> 00:14:32.177
一個判斷值不值得換成 Jev，就看兩件事，

00:14:32.177 --> 00:14:35.920
它會不會被快速運算很多次，以及它需不需要推理。

00:14:35.920 --> 00:14:39.722
這五個裡面如果有一個你等一下就想試，幫我按個訂閱、

00:14:39.722 --> 00:14:40.800
開個小鈴鐺。

00:14:40.800 --> 00:14:43.604
所有平台都叫 AI 懶人報，習慣用聽的就搜 Podcast。

00:14:43.604 --> 00:14:45.370
我們下一集見。