WEBVTT
Kind: captions
Language: zh-TW

00:00:00.000 --> 00:00:04.414
歡迎大家來到我們這個 Claude Code 的一個快速入門的教學

00:00:04.414 --> 00:00:09.258
那基本上這個教學它是一個不管你是今天已經在使用 Claude Code

00:00:09.258 --> 00:00:14.500
還是說你今天是一個準備要把 Claude Code 導入到你日常開發的工作流

00:00:14.500 --> 00:00:19.000
這個教學都很適合你們來看過一遍然後學習這裡面的一個知識

00:00:20.500 --> 00:00:24.348
那首先我們先來看一下今天要教的內容有哪些部分

00:00:24.348 --> 00:00:30.085
那首先第一個是我會先去介紹這個 Claude Code 裡面比較常用的14個指令

00:00:30.085 --> 00:00:35.000
那基本上這個整個教學裡面我們都會去根據這14個指令去做展開

00:00:35.000 --> 00:00:39.396
然後這裡面你會去了解很多跟 Claude Code 有關的一些基礎知識

00:00:39.396 --> 00:00:45.370
還有這個底層的一些原理然後再來就是說第二個部分是這個規則跟這個記憶的區別是什麼

00:00:45.370 --> 00:00:49.000
我們要怎麼樣讓我們的 Claude Code 去記得一些事情

00:00:49.000 --> 00:00:53.389
然後我們要怎麼樣去做分類然後去做一些自定義的一些規則

00:00:53.389 --> 00:00:59.913
然後第三個部分就是說我們要怎麼樣去理解 什麼是 MCP 什麼是 skills 什麼是 plugin

00:00:59.913 --> 00:01:05.500
還有就是說我們去比較就是說 skills 跟這個記憶之間的一個區別會是什麼

00:01:05.500 --> 00:01:10.264
然後第四個部分就是說我們要怎麼樣去定義一個 subagents

00:01:10.264 --> 00:01:15.769
這個 subagents 的意思就是說我們今天 Claude Code 它本身是一個

00:01:15.769 --> 00:01:21.500
agent 那它可以去指派或說調用底下的更多 agent 去做各自專精的事情

00:01:22.500 --> 00:01:26.959
那第五個部分就是這個 context 的一個基本概念 基本上我們今天在使用

00:01:26.959 --> 00:01:29.227
Claude Code 這樣的一個工具的時候

00:01:29.227 --> 00:01:35.773
這個 context 的一個基本概念是非常重要的 就是說我們今天要去學習怎麼樣去管理我們這樣的一個上下文

00:01:35.773 --> 00:01:38.000
然後讓我們的開發變得更有效率一點

00:01:38.000 --> 00:01:41.559
那這裡面也會去教學怎麼樣去使用這個 compact 指令

00:01:41.559 --> 00:01:44.968
還有這個 Clear 跟這個 dump to file 的一個策略

00:01:44.968 --> 00:01:52.500
然後也會對他們這些策略做一個比較 跟大家去講解怎麼樣去使用會是比較好去維護我們這個 context 的一個部分

00:01:54.000 --> 00:02:00.758
然後在開始我們今天的教學之前我先快速的工商一下 這個我另外的其他課程的部分

00:02:00.758 --> 00:02:04.471
這個這兩個課程是我跟Hahow在合作的一個課程

00:02:04.471 --> 00:02:08.500
基本上左邊這個它也是 Claude Code 的一個教學

00:02:08.500 --> 00:02:14.856
只是說它是比較偏向實戰跟 MCP 還有就是說更多一些 skills 工具的一個教學

00:02:14.856 --> 00:02:20.688
那基本上它是比較偏向像進階一點的一個 Claude Code 的一個教學課程

00:02:20.688 --> 00:02:24.000
那右邊的話它是一個前端面試的一個課程

00:02:24.000 --> 00:02:28.000
所以基本上它就是一個如果你有在準備前端面試可以考慮的一個課程

00:02:30.000 --> 00:02:35.410
那這個部分的連結我都會放在簡介欄裡面大家可以去如果有興趣的話

00:02:35.410 --> 00:02:40.171
可以去看一下 然後我會附上優惠券的部分在這個簡介欄這邊

00:02:40.171 --> 00:02:46.500
那我們回到這一個終端機這邊 那我們回到這個 Claude Code 的一個教學的部分

00:02:46.500 --> 00:02:52.014
那基本上我們先來到終端機這個地方你可以去輸入這個 Claude Code 的一個指令

00:02:52.014 --> 00:02:55.760
那這個 Claude Code 的指令基本上你按下 Enter 之後

00:02:55.760 --> 00:02:59.374
它會先教你怎麼樣去選擇這個樣式的部分 那這個地方

00:02:59.374 --> 00:03:02.000
你就選擇一個自己喜歡的樣式就可以了

00:03:02.000 --> 00:03:06.552
那基本上只要你選擇樣式之後你會進到第二個部分 這個部分

00:03:06.552 --> 00:03:12.259
就是你可以選擇看你要用訂閱的方式去做登錄還是說去使用官方的 API key

00:03:12.259 --> 00:03:16.000
然後來做使用 Claude Code 的一個額度這個樣子

00:03:16.000 --> 00:03:22.084
然後第三個部分是如果你有去買這個 Amazon 或者說這個 Microsoft 平台的一些方案

00:03:22.084 --> 00:03:27.500
它會提供額度給你那你可以用第三種方式來做使用這個 Claude Code 的工具

00:03:27.500 --> 00:03:34.395
那我自己的話基本上因為我自己有去搭建一個這個跟 API key 有關的一個平台

00:03:34.395 --> 00:03:41.500
那這個平台基本上它的好處就是可以幫我自己去節省滿多的一個 token 的使用量

00:03:41.500 --> 00:03:47.227
還有就是說它的一個因為我今天如果用訂閱帳戶它可能會有五小時或者說七天的限制

00:03:47.227 --> 00:03:51.251
那我用這種方式來做處理的話就不會有受到這樣的一個限制

00:03:51.251 --> 00:03:55.012
那我就會用我這個自己的方式來開啟這個 Claude Code

00:03:55.012 --> 00:03:59.500
那如果大家對這個方式有興趣的話可以去底下的這個簡介欄看一下

00:03:59.500 --> 00:04:05.000
我也會把這個相關資訊放在底下但這邊我們就不對這個地方做過多的介紹

00:04:07.000 --> 00:04:12.125
那這邊我進到 Claude Code 裡面一樣我先選擇一個我喜歡的主題

00:04:12.125 --> 00:04:18.571
然後這邊就繼續好在這個地方 那這樣我們就進來這個 Claude Code 的一個部分了

00:04:18.571 --> 00:04:22.500
那首先第一個我們先來看一下我們要學習哪些指令

00:04:22.500 --> 00:04:27.616
基本上我們今天會教到這個裡面所有的這個十四個常用的一個指令

00:04:27.616 --> 00:04:32.988
首先我們先來看一下左邊這邊這四個第一個我們先來看 Permissions

00:04:32.988 --> 00:04:38.500
這個部分 基本上如果你今天去使用這個 Permissions 的一個用途的話

00:04:38.500 --> 00:04:43.197
它的一個用意就是說我們今天在使用 Claude Code 工具的時候

00:04:43.197 --> 00:04:47.487
Claude Code 這個工具的時候它基本上它是對你整個電腦

00:04:47.487 --> 00:04:52.642
它有非常高的一個存取權限 那你可以選擇就是說你想要允許這個工具

00:04:52.642 --> 00:04:54.000
去做什麼樣的事情

00:04:54.000 --> 00:04:56.989
那可以去執行什麼樣的指令然後做

00:04:56.989 --> 00:05:05.717
比如說編輯檔案或者說寫入檔案 或者說去執行一些跟命令行有關的一些指令的時候 是可以直接執行

00:05:05.717 --> 00:05:10.500
還是說要通過你的允許才去做執行都會在這裡面做設定

00:05:10.500 --> 00:05:16.310
那我自己平常因為我會稍微比較懶多一點所以我可能就是會用下面這種方式

00:05:16.310 --> 00:05:20.386
就是我直接寫一個 Bash 或者說 Read 跟這個 Write

00:05:20.386 --> 00:05:26.091
就是我基本上是同意它可以去使用這些工具 然後去幫我的這個在工作上面

00:05:26.091 --> 00:05:27.500
如果去修改程式碼

00:05:27.500 --> 00:05:34.825
或說讀程式碼或是要去運行一些命令行的指令的時候它都會透過這樣的方式直接去執行

00:05:34.825 --> 00:05:37.717
這個就是我給它的一個權限的控制

00:05:37.717 --> 00:05:43.500
那如果你今天想要特別去指定說它只能去使用特定的哪一些指令的話

00:05:43.500 --> 00:05:49.746
那你可能要去特別寫說就是說像這個 Bash 指令你可能就會寫說花括號

00:05:49.746 --> 00:05:55.478
它只能用哪一個指令譬如說 npm 的指令那如果今天是 Read 的話

00:05:55.478 --> 00:05:58.500
你想要指定說它只能去讀哪些檔案

00:05:58.500 --> 00:06:02.500
那你可能也是用花括號的方式去做讀取這些特定的檔案

00:06:03.500 --> 00:06:06.208
但如果是偏向比較方便的方式的話

00:06:06.208 --> 00:06:11.804
可以像我一樣就是說把每一個它可以使用到的工具都直接寫在這個地方

00:06:11.804 --> 00:06:17.500
然後讓我們這個 agent 在使用的時候它基本上還是會問我們說要不要去

00:06:17.500 --> 00:06:22.827
可不可以去執行這個指令跟這個工具然後譬如說讀檔案或是寫檔案

00:06:22.827 --> 00:06:29.439
那用這樣的方式可能就會在你的開發上面會比較方便一點就是說不用每次它去執行

00:06:29.439 --> 00:06:35.500
對應的工具跟指令的時候都要問你一次然後你還要手動去點過一次這個樣子

00:06:35.500 --> 00:06:40.024
那這個是 Permissions 的部分 然後再來就是說我們來看一下 Model

00:06:40.024 --> 00:06:46.118
這個地方 Model 這個地方其實就顧名思義是讓你選擇模型的 那基本上就是你可以在這個地方

00:06:46.118 --> 00:06:48.500
去選擇就是說你想要用什麼樣的模型

00:06:48.500 --> 00:06:57.500
像我這邊去使用的就是這個 Opus 的一個模型那最近就是說你也可以選擇像這個 這個 Sonnet 5 的一個模型去做選擇

00:06:59.500 --> 00:07:03.171
然後再來就是說這一個 Effort 的指令我們來看一下

00:07:03.171 --> 00:07:07.303
前面這兩個指令都有比較簡單一點就是說一個是直接給權限

00:07:07.303 --> 00:07:10.958
然後第二個是你直接去使用對應的模型這樣就可以了

00:07:10.958 --> 00:07:13.500
那第三個指令我們會稍微來講解一下

00:07:13.500 --> 00:07:19.075
它的一個裡面的內容會是什麼首先這個 Effort 它的一個意思

00:07:19.075 --> 00:07:25.864
顧名思義就是說它希望就是說你希望這個模型去付出怎樣的一個努力的程度

00:07:25.864 --> 00:07:31.500
然後來執行你的任務 那它的一個區別就是從左邊排到最右邊去

00:07:31.500 --> 00:07:33.162
基本上左邊這個地方

00:07:33.162 --> 00:07:41.156
它是最快的但是也是最不聰明的 可是相對來說也是最省成本的 因為你今天如果去不讓你的這個 AI

00:07:41.156 --> 00:07:46.500
去思考這麼多東西的話 那它所消耗的 token 也會變得比較少一點

00:07:46.500 --> 00:07:52.108
但是相對於你的來說就是它的一個工作的一個能力可能就會變得比較有落差一點

00:07:52.108 --> 00:07:57.572
然後再來就是說你如果去使用 Medium 跟 High 的話它是我們在日常工作上面

00:07:57.572 --> 00:08:03.500
可能會比較常去用到這兩個模式我們可以分別來看一下它的區別是什麼再來這個地方

00:08:03.500 --> 00:08:08.172
首先如果你今天是去使用我們剛才提到的最左邊這個 Low 部分

00:08:08.172 --> 00:08:11.653
這個 Low 的部分它是基本上都不去做任何思考

00:08:11.653 --> 00:08:17.849
就是說很快速的幫你去完成一些比較簡單的一些任務 那再來就是說如果你去使用像

00:08:17.849 --> 00:08:19.500
Medium 這個部分的話

00:08:19.500 --> 00:08:23.668
它其實就是你一般的一個日常工作你可以做正常的開發

00:08:23.668 --> 00:08:28.947
比如說開發一些比較簡單一些需求 然後這些需求是有比較明確的規則

00:08:28.947 --> 00:08:33.132
那這部分你就可以用這個 Medium 的一個方式去做開發

00:08:33.132 --> 00:08:37.500
那這也會相對來說比下面這幾種方式都還要去更省 token

00:08:37.500 --> 00:08:42.231
那第三種方式是我自己個人也比較常去使用的一個方式 就是說你用

00:08:42.231 --> 00:08:46.672
High 的模式去做處理那什麼樣的情況我需要去使用到 High 呢

00:08:46.672 --> 00:08:51.500
這個 High 的部分就是說如果你今天需要去計畫一些比較複雜的功能

00:08:51.500 --> 00:08:57.728
比如說我今天可能設計了好幾個組件然後同一個頁面上面要去做不同的一個狀態管理

00:08:57.728 --> 00:09:01.094
那這部分我可能就會用 High 的方式來做處理

00:09:01.094 --> 00:09:05.958
它就是說你今天發現你的專案上面有一些 Bug 那這個 Bug 的部分

00:09:05.958 --> 00:09:08.500
可能已經用 Medium 來做處理的話

00:09:08.500 --> 00:09:12.380
它可能比較不會抓得那麼準確 可能最後也會抓到 Bug

00:09:12.380 --> 00:09:17.319
但是可能你要跟它溝通好幾輪之後 它最後才去找到這個 Bug 是什麼

00:09:17.319 --> 00:09:23.010
但是如果你用 High 的話它可能會多想一點 那多想一點多去看多一點檔案的話

00:09:23.010 --> 00:09:25.500
它會比較快的去修一些普通的 Bug

00:09:25.500 --> 00:09:29.789
那定位到這個問題之後它所消耗的一個 token 跟時間會變得比較少一點

00:09:29.789 --> 00:09:34.500
但整體來說這個 High 去消耗的 token 還是會比這個 Medium 還要來得多一點

00:09:36.500 --> 00:09:41.468
那基本上它在遇到一些問題的時候它會去問你說要怎麼樣去做處理 像

00:09:41.468 --> 00:09:46.599
比如說我今天如果是在計畫一些比較複雜的功能的時候 它可能會問你說

00:09:46.599 --> 00:09:49.271
我今天覺得 A 方案可以選擇三個選項

00:09:49.271 --> 00:09:54.500
那你覺得第一個選項比較好還是第二個選項比較好還是第三個選項比較好

00:09:54.500 --> 00:09:58.500
同時它還會告訴你就是說它今天推薦你選擇哪一個選項會比較好

00:10:00.500 --> 00:10:07.328
那下面這個 xHigh 的部分我這邊多打一個 T 我把它刪掉 這個 xHigh 的部分

00:10:07.328 --> 00:10:14.500
就是說如果你今天是你的工作是需要去 需要涉及到比較大量的一個工具的呼叫

00:10:14.500 --> 00:10:19.752
或者說需要去做比較深層的一個搜尋跟探索一些解決方案的話

00:10:19.752 --> 00:10:22.670
就是說這個可能你的你在開發之前

00:10:22.670 --> 00:10:28.000
可能對這個解決方案也不是那麼的 熟悉或者說去理解這個樣子

00:10:28.000 --> 00:10:31.500
那這部分你可以用 xHigh 的方式去做處理

00:10:31.500 --> 00:10:37.142
那基本上它所消耗的 token 可能也會比前面這幾種來的高很多

00:10:37.142 --> 00:10:46.500
但是它是很接近 Max 的一個性能 只是說它跟 Max 的一個區別就是會比它還要便宜一點 那這部分就是說

00:10:46.500 --> 00:10:51.548
你可以去斟酌就是你想要去使用這個 xHigh 來做處理 還是你要用 High

00:10:51.548 --> 00:10:54.544
來處理這個日常的工作就可以了 那基本上

00:10:54.544 --> 00:11:00.308
如果你遇到一些需要去探索解決方案的一個功能的話 那這部分你可以去考慮使用

00:11:00.308 --> 00:11:03.500
xHigh 的方式來做處理可能會比較省時間一點

00:11:03.500 --> 00:11:08.271
那再來就是你去使用 Max 的部分 這個 Max 的部分其實

00:11:08.271 --> 00:11:12.787
基本上它就是一個非常非常貴的一個使用的一個方式

00:11:12.787 --> 00:11:17.500
基本上就是說如果你有一些功能它是這個如果有錯的話

00:11:17.500 --> 00:11:24.308
是不可以接受的那譬如說一些比較敏感像金流部分的一些功能 或者說跟用戶

00:11:24.308 --> 00:11:27.569
比如說我今天有個系統是要儲值點數

00:11:27.569 --> 00:11:34.500
那它被扣點或者說扣掉一些額度莫名其妙被扣掉一些額度這是它沒辦法接受的

00:11:34.500 --> 00:11:40.900
這部分的話你就可以使用 Max 的這樣的一個部分去做處理那它會想的比較久一點

00:11:40.900 --> 00:11:46.153
然後去幫你 review 一些計畫幫你提出一些比較好的一些解決方案

00:11:46.153 --> 00:11:48.500
去處理這個想要去實作的功能

00:11:49.500 --> 00:11:54.098
然後最後這個就是這個 Ultra Code 它是一個新的一個模式

00:11:54.098 --> 00:12:00.076
那這個模式你可以看到它這個紫色的一個特效就代表說它非常的準確度的部分

00:12:00.076 --> 00:12:05.500
它非常的貴 那它貴它的道理是什麼就是說它除了有這個 Max 功能之外

00:12:05.500 --> 00:12:07.699
它還會自動幫你去拆 workflow

00:12:07.699 --> 00:12:12.424
這個 workflow 的意思就是說 它可能會幫你去開好幾個平行的 sub

00:12:12.424 --> 00:12:17.611
agent 幫你做事情 比如說你今天有一個非常大型的重構需要去做處理的話

00:12:17.611 --> 00:12:21.500
它可能會幫你把這個任務 確實拆成好幾個不同的子任務

00:12:21.500 --> 00:12:28.590
然後這個子任務在同時在開好幾個 sub agent 幫你去 各自完成他們獨立要完成的任務

00:12:28.590 --> 00:12:34.075
然後最後再做幫你做測試 或是說做一些跨任務的一些處理像比如說

00:12:34.075 --> 00:12:36.500
你今天除了要寫前端的程式碼

00:12:36.500 --> 00:12:42.531
你可能還需要去規劃後端的一些 API 這個部分的話你可以用這個模式來做處理

00:12:42.531 --> 00:12:47.634
但是它就是有一個缺點就是說非常的貴因為它非常的消耗的 token

00:12:47.634 --> 00:12:52.500
它會自動拆 workflow 然後開好幾個 sub agent 幫你去做事情

00:12:52.500 --> 00:12:58.849
所以這個地方大家可以去考慮它就是說如果你今天有一個大型重構的一個專案

00:12:58.849 --> 00:13:06.393
那同時它裡面有一些設計比如說金流或者說一些比較敏感的一些 用戶資訊的一些重構的時候

00:13:06.393 --> 00:13:10.500
這個部分你可以就考慮用比較高級的模式來做處理

00:13:10.500 --> 00:13:16.177
但是缺點就是它會特別貴因為我們今天在使用這個 AI 開發的時候

00:13:16.177 --> 00:13:22.375
最重要的事情就是我們的 token 的消耗那基本上如果你在日常開發裡面

00:13:22.375 --> 00:13:26.500
你可以選擇你對應的一些任務比如說比較簡單的

00:13:26.500 --> 00:13:30.641
我們就用 Medium 的方式來做處理就好了那如果今天真的比較複雜

00:13:30.641 --> 00:13:35.500
我們再花比較多的 token 去用這個 max 或者說 Ultra Code 的方式來做處理

00:13:37.500 --> 00:13:43.756
那以上這個部分就是我們這個 effort 的一個重點 就是說你當你選擇了這樣的一個

00:13:43.756 --> 00:13:48.761
effort 之後 你的模型就會根據你所選擇 effort 去做對應的努力

00:13:48.761 --> 00:13:50.500
然後消耗對應的 token

00:13:51.500 --> 00:13:57.537
然後接下來我們來看一下下一個指令 就是這個我認為是整個 Claude Code

00:13:57.537 --> 00:14:01.857
開發裡面相當重要的一個指令 這個 plan 的一個指令

00:14:01.857 --> 00:14:06.177
這個 plan 的指令它是 就是說你今天可以在這個地方

00:14:06.177 --> 00:14:09.500
去下一個命令這個命令就是說如果我今天

00:14:09.500 --> 00:14:14.290
如果沒有下這個 plan 的一個命令的時候它的一個區別是什麼

00:14:14.290 --> 00:14:18.645
就是說如果你今天想要去讓你的 agent 去計畫一個功能

00:14:18.645 --> 00:14:24.500
比如說我現在已經開了一個前端專案然後我希望他去實做一個計算機的功能

00:14:24.500 --> 00:14:29.423
可是我希望他在實做之前告訴我就是說他這個計算機的功能會長什麼樣子

00:14:29.423 --> 00:14:33.423
那不是說就是說他理解之後就馬上去執行然後幫我修改檔案

00:14:33.423 --> 00:14:38.500
這樣有時候就會遇到一個問題就是其實我根本不想要他去修改這麼多的檔案

00:14:38.500 --> 00:14:42.934
但他已經幫我修了那我反而還要花時間來看他修的哪些檔案

00:14:42.934 --> 00:14:48.630
然後還要去一個一個把它還原 那這時候可能就會變得比起你今天如果去使用

00:14:48.630 --> 00:14:53.158
agent 來講的話 你可能花費的心力跟時間都會變得更多一點

00:14:53.158 --> 00:14:56.500
那今天用這個 plan mode 的一個好處就是說

00:14:56.500 --> 00:15:02.162
你可以先讓你的 agent 提計畫給你那你先去 review 去審核這個計畫

00:15:02.162 --> 00:15:07.251
它可不可行就是符合你的需求之後你再讓你的 agent 去做執行

00:15:07.251 --> 00:15:11.500
所以我們這邊可以去很簡單的去打這個 plan 的指令

00:15:11.500 --> 00:15:19.042
那這個 plan 指令你後面就可以打出什麼比如說我要你設計一個

00:15:19.042 --> 00:15:27.500
設計一個計算機的功能 那這邊我就讓他執行一下那我們就稍微等他一下

00:15:27.500 --> 00:15:29.366
那他剛才跑了一下子

00:15:29.366 --> 00:15:37.451
然後我們現在看到他所問的第一個問題就是說他我們想要去設計什麼樣的一個計算機功能

00:15:37.451 --> 00:15:44.500
基本上這個地方你可以去告訴他就是說你是要基本的四則運算還是進階的計算

00:15:44.500 --> 00:15:49.693
或者說你想要客製一些自己想要的一些功能你可以打在第四點這個地方

00:15:49.693 --> 00:15:54.643
你可以打自己的這個打自己的一些註解在這個地方 告訴這個 agent

00:15:54.643 --> 00:15:59.568
說你想要怎麼樣做那基本上我們這個地方先選擇第一個 這個功能就

00:15:59.568 --> 00:16:02.500
ok 的那再就是說第二個他要問你就是說

00:16:02.500 --> 00:16:06.651
我希望是目前的頁面去開始做這個計算機的功能

00:16:06.651 --> 00:16:11.593
還是說要去把整個前端的一個結構先掃過一遍再去做處理

00:16:11.593 --> 00:16:16.930
那基本上這兩個時候你就可以去想一下如果只是目前頁面的話

00:16:16.930 --> 00:16:19.500
那是不是他所看的檔案比較少

00:16:19.500 --> 00:16:23.552
對吧那這個地方的話他所消耗的 token 你就會比較少一點

00:16:23.552 --> 00:16:28.531
然後第二個部分就是說 如果是整個前端他去掃更多的檔案讀更多的東西

00:16:28.531 --> 00:16:35.500
那這裡面消耗的一個 token 就會是更多的像這個樣子那我們一樣也選擇第一個就好 然後我們把這個

00:16:35.500 --> 00:16:41.161
選擇的結果給送出去然後再等他一下子然後我們可以來看到 這一個

00:16:41.161 --> 00:16:47.650
Claude Code 已經給我這個對應的一個實作計畫 就是他跑了大概幾分鐘之後

00:16:47.650 --> 00:16:51.500
出現了這個計畫那基本上這個計畫我們可以去

00:16:51.500 --> 00:16:56.231
review 一下審核一下然後來看一下他是滿足我們的需求

00:16:56.231 --> 00:17:02.628
然後再來就是說 他這裡會提供三個選項首先第一個是你可以選擇用自動模式

00:17:02.628 --> 00:17:05.500
去做處理那第二個就是說你希望他

00:17:06.500 --> 00:17:10.200
如果想要執行一些跟編輯有關的一個指令的時候

00:17:10.200 --> 00:17:15.733
去一個一個問你 然後你可以用手動的方式來去做同意跟不同意這件事情

00:17:15.733 --> 00:17:22.500
然後第三個就是說 如果你今天舉了這個計畫有些地方不符合你的需求你想要做修改的話

00:17:22.500 --> 00:17:27.292
那你可以在這個第三個部分然後告訴他說你想要怎麼樣做

00:17:27.292 --> 00:17:32.353
然後讓他去重新把這個計畫給 重新的再寫過一遍然後有時候

00:17:32.353 --> 00:17:37.030
如果是一些比較嚴謹的計畫 我自己個人我會在這個地方

00:17:37.030 --> 00:17:40.500
可能就告訴他就是說去 review 一下一下

00:17:40.500 --> 00:17:46.740
然後確保不要有 bug 然後我覺得另外一個比較重要的就是說你可以跟他說

00:17:46.740 --> 00:17:54.163
去多想一些這個邊緣條件就是這個 edge case 就是說如果我今天在設計一個功能的時候

00:17:54.163 --> 00:17:56.500
肯定是希望我們這個 agent

00:17:56.500 --> 00:18:01.268
他去多想一些比較邊緣的一些 case 那這些 case 去多想一點的話

00:18:01.268 --> 00:18:05.518
基本上可以 也不是說保證完全不會有 bug 但是至少這個出

00:18:05.518 --> 00:18:07.500
bug 的機率會變得更低一點

00:18:08.500 --> 00:18:14.744
那這邊的話基本上我也來介紹一下就是說這兩個模式他的一個區別是什麼

00:18:14.744 --> 00:18:19.232
首先我們來看一下就是基本上如果你去讓他執行之後

00:18:19.232 --> 00:18:24.500
你會有三種方式來讓他去做決定要不要執行首先第一個就是說

00:18:24.500 --> 00:18:34.047
你可以選擇用手動的方式就是說他如果有今天有那問題就是先問你可不可以改 或者說可不可以去做一些執行一些指令這個地方

00:18:34.047 --> 00:18:36.460
就是我們用手動的方式來做處理

00:18:36.460 --> 00:18:41.500
那第二個部分就是說如果你今天是用這個自動去接受這個 editors

00:18:41.500 --> 00:18:47.483
這個意思就在這個地方假設我今天先選的第一個那你可以看到我自己有一個什麼

00:18:47.483 --> 00:18:52.175
auto mode on 但是你可以用這個 Shift+Tab 的按鍵去做切換

00:18:52.175 --> 00:18:58.500
那這個手動模式就是我剛才提到這個地方任何問題都是先去問過你一遍然後去做執行

00:18:58.500 --> 00:19:04.440
那這個好處就是說你可以一步一步地去做審核基本上不會有太大的一個錯誤

00:19:04.440 --> 00:19:11.100
因為基本上你就是守門員然後可以去決定說什麼樣的任務可以放行什麼樣的一個任務

00:19:11.100 --> 00:19:16.500
不能去做大概像這樣子但這裡面有一個缺點就是會很麻煩因為他可能

00:19:16.500 --> 00:19:22.391
沒過幾步就去問你一遍說這個東西可不可以做還是說這個東西我該做還是不該做

00:19:22.391 --> 00:19:28.619
大概像這樣子那我們今天來看下一個模式下一個模式就是我們提到的這個第二個模式

00:19:28.619 --> 00:19:33.500
這個地方它是自動但是你只開放它去自動的寫檔案但是說如果今天

00:19:33.500 --> 00:19:37.956
有一些 bash 指令這個 bash 指令可能就包含就是說去啟動

00:19:37.956 --> 00:19:39.747
這個 npm 的服務或者說

00:19:39.747 --> 00:19:46.500
我今天去需要去執行一些 可能清除資料夾裡面的內容的檔案的一些指令的時候它會問你說

00:19:46.500 --> 00:19:52.090
可不可以去做執行那這部分也是一樣就是說你可能比起上一個層級

00:19:52.090 --> 00:19:59.107
你不用去手動的一個一個去告訴他說你可以做還是不能做 那第二個部分就是跟這些

00:19:59.107 --> 00:20:02.500
bash 有關的一個命令行的一些指令的話

00:20:02.500 --> 00:20:07.667
你可以決定說要不要讓它去執行那這是第二個的部分那第三個部分的話

00:20:07.667 --> 00:20:12.667
就是說在你看這個地方有沒有它就問我說可不可以去執行這個任務了

00:20:12.667 --> 00:20:18.500
那基本上這個地方我會告訴它就是說你可以直接去執行然後不用再問過我第二次

00:20:18.500 --> 00:20:23.028
那我就選第二個然後去執行那我們來看第三個部分

00:20:23.028 --> 00:20:27.679
第三個部分就是說 我今天讓它去用這個 auto mode

00:20:27.679 --> 00:20:33.648
這個 auto mode 的意思就是說 它會去自動去做所有的事情比如說

00:20:33.648 --> 00:20:35.500
我今天讓它去讀檔案

00:20:35.500 --> 00:20:40.605
讓它去寫檔案然後去自動的把這些東西可以做出來

00:20:40.605 --> 00:20:46.500
但是它有 還是會有一個分類器在背景去判斷說之前內容是

00:20:47.500 --> 00:20:51.446
有問題的還是說它是有可能會有一些風險的那這時候

00:20:51.446 --> 00:20:56.266
如果它判斷是有風險的 它會直接把它擋掉就告訴說這個 action

00:20:56.266 --> 00:21:01.138
就是說你不能用這樣的方式來做處理 但是你可以去選擇其他方式

00:21:01.138 --> 00:21:04.500
然後來做處理這個樣子所以基本上這個 auto

00:21:04.500 --> 00:21:07.031
它是自動幫你去做很多這個大概

00:21:07.031 --> 00:21:15.174
90%以上的一些判斷跟這個工作上面的一些 譬如說寫程式碼或者說執行命令行跟去讀程式碼的一些工作

00:21:15.174 --> 00:21:21.500
都是自動幫你做掉了但是如果有一些真的設計比較高權限的一個 bash 指令的話

00:21:21.500 --> 00:21:25.500
它還是會告訴你就是說問你說可以同意還是不能同意

00:21:26.500 --> 00:21:29.268
但是這三個模式比起來的話其實

00:21:29.268 --> 00:21:37.059
基本上就是最下面這個模式是最方便的 但是它所帶給你的一個風險可能又會高一點像之前

00:21:37.059 --> 00:21:40.500
就是說有發生過一個專案 這個專案就是

00:21:41.500 --> 00:21:46.299
有一間公司然後他們想要去讓這個 Claude Code 的一個 agent

00:21:46.299 --> 00:21:51.469
去做開發的時候是可以基本上就是說不要問過他們就是說他想做什麼

00:21:51.469 --> 00:21:57.500
就讓他去做什麼那他們就輸入了這樣的一個指令但是這個指令他的一個缺點就是

00:21:57.500 --> 00:22:02.020
他不會問你任何事情他覺得想做就做那時候他們就這個 agent

00:22:02.020 --> 00:22:07.248
去覺得就是說 他必須要寫一個指令是去清除掉所有系統裡面的一些檔案

00:22:07.248 --> 00:22:13.500
那這時候 agent 就做這樣的事情然後你就把那台電腦裡面很多很重要的資料都刪除掉

00:22:13.500 --> 00:22:17.308
所以基本上我們今天也不是說可以讓整個 Claude Code

00:22:17.308 --> 00:22:22.856
都可以 擁有整台電腦的權限去做所有事情這樣的話其實也是非常不好的一件事情

00:22:22.856 --> 00:22:27.150
因為他可能 莫名其妙就把你的一些很重要的一個資料都刪掉了

00:22:27.150 --> 00:22:29.500
像是譬如說你一些比較珍貴的照片

00:22:29.500 --> 00:22:34.280
或者說如果你今天有用加密貨幣的錢包那這些私鑰如果被刪掉的話其實

00:22:34.280 --> 00:22:36.500
基本上也是 變得非常麻煩的事情

00:22:37.500 --> 00:22:46.578
所以基本上我會比較推薦就是說你可以選擇第二種的方式像我自己比較常去 用的可能就是第二種跟第三種那大多時間可能也還是用第三種

00:22:46.578 --> 00:22:52.500
因為我有時候 你開發到一半是真的會比較懶惰一點那用這樣的方式他有背有一個背景分類

00:22:52.500 --> 00:22:57.500
器幫去判斷說這個指令是能做還是不能做也是一件比較好的事情

00:22:58.500 --> 00:23:04.298
那這個部分我們就先把它終止掉那我們來介紹其他的指令

00:23:04.298 --> 00:23:12.462
那再來就是說我們來看一下這一個 rewind 這個指令跟這個 resume 的一個指令

00:23:12.462 --> 00:23:15.500
基本上這個 rewind 指令就是

00:23:15.500 --> 00:23:19.650
你今天執行到一半之後你發現到目前為止

00:23:19.650 --> 00:23:31.500
你所輸入的一些指令啊或者說最後所造成的結果或是你想要的 那你可以怎麼樣你可以做一個回退的動作就是說回退到

00:23:31.500 --> 00:23:38.934
前一個指令的版本或說某一個指令的版本像我今天如果打上這個指令 在這個地方

00:23:38.934 --> 00:23:41.969
你就可以看到我按下 end 的時候

00:23:41.969 --> 00:23:48.500
它會讓我選擇我要回到什麼時候就是我第一次調用這個 effort 的時候

00:23:48.500 --> 00:23:54.163
還是說第二個我去剛開始要用 plan 的時候那我現在可能反悔了

00:23:54.163 --> 00:24:01.242
我不想要做這個計算機的功能所以我就讓它回到這個時候然後它會給你幾個選項

00:24:01.242 --> 00:24:06.500
基本上第一個就是它會把這個程式碼跟整個對話也都退回來

00:24:07.500 --> 00:24:13.665
然後當我們按下 end 的時候你就會發現有沒有它幫你退回到這個時候

00:24:13.665 --> 00:24:16.500
然後去回退之前所有的一些改動

00:24:17.500 --> 00:24:23.945
但是我自己還是個人會比較推薦就是說你去使用這樣的一個回退的機制的時候 是可以用

00:24:23.945 --> 00:24:29.559
git 的指令來做處理這樣的話你對整個版本控制上面 也會變得比較有效一點

00:24:29.559 --> 00:24:35.500
然後你的專案也不會因為就是說今天可能回退太多東西 然後你沒有做任何的記錄

00:24:36.500 --> 00:24:42.071
那這就再來就是說我們有這個 resume 的一個指令這個 resume 的指令

00:24:42.071 --> 00:24:52.500
就是說當你今天如果不小心把這一個整個對話框給關掉了那 你今天可能會覺得很懊悔就是說我不小心把這個關掉了那怎麼辦它這時候

00:24:52.500 --> 00:24:56.889
是也會提醒就是說你可以回到剛剛那個指令那這個部分我們就先回到

00:24:56.889 --> 00:25:00.459
這個 Claude Code 裡面然後我們來看一下這個 resume

00:25:00.459 --> 00:25:05.500
它說給我們的效果是什麼按下 end 之後你可以看到有沒有它這個地方去告訴你

00:25:05.500 --> 00:25:10.837
就是說你可以回到這個 session 裡面它你這個電腦裡面 它的好幾個

00:25:10.837 --> 00:25:16.219
session 然後你可以選擇一個 session 回去 然後重新打開那個對話

00:25:16.219 --> 00:25:20.500
然後繼續處理你想處理的事情那這個就是我們17秒之前

00:25:20.500 --> 00:25:26.013
去關掉這個 session 對吧所以我們就回到了這個地方就可以看到 有沒有這個地方

00:25:26.013 --> 00:25:31.121
就把所有的內容給放進來了但是這個地方我還是想要回推到 更早之前的版本

00:25:31.121 --> 00:25:34.500
所以這個地方就我們就打上這個 rewind 這個指令

00:25:34.500 --> 00:25:40.500
然後回推到最原先這個地方然後把所有的程式碼跟對話都清除掉

00:25:41.500 --> 00:25:44.500
所以這兩個指令其實就是可以幫你很好地去

00:25:45.500 --> 00:25:49.830
回推到你想要回推的版本還有就是說如果你今天不小心把整個

00:25:49.830 --> 00:25:55.500
Claude Code 的一個 session 給關掉之後你可以再馬上再回來 原本的對話內容

00:25:56.500 --> 00:25:59.500
那這邊也大概去介紹一下這個 session 跟我們這個

00:26:00.500 --> 00:26:04.524
context 的一個基本的認知那這個地方我們等一下會講 更多

00:26:04.524 --> 00:26:09.039
context 有關的但是我這邊先簡單講一下這個 session 是什麼意思

00:26:09.039 --> 00:26:13.500
首先我們今天在跟這個 agent 聊天的時候基本上你一個聊天的內容

00:26:13.500 --> 00:26:18.190
就是一個 session 就像你已經開了一個聊天室的這樣的一個概念

00:26:18.190 --> 00:26:22.348
那這個聊天室 它裡面有很多的文字對吧那這個文字的部分

00:26:22.348 --> 00:26:27.864
所組成的這個字數的一些限制的話 就是 context 的部分這 context 的部分

00:26:27.864 --> 00:26:29.500
就是說你今天如果送了

00:26:29.500 --> 00:26:35.186
這所有的文字給大模型的時候它所接受的這個上下文長度有多少它會寫在這個地方

00:26:35.186 --> 00:26:40.500
那像我們最近一些比較新的模型都是接受這個大概一個 million 以上的一個

00:26:41.500 --> 00:26:46.500
大概這個 million 左右的一個 context 就會在這部分去展現出來

00:26:47.500 --> 00:26:52.519
所以這個就是我們基本去認識這個 session 跟 context 的一個

00:26:52.519 --> 00:26:57.130
區別是什麼那我們接下來看一下剩下的兩個指令在這個地方

00:26:57.130 --> 00:27:01.085
那這個剩下這兩個指令就是這個關於 code review

00:27:01.085 --> 00:27:05.500
還有這個 security review 的一個區別是什麼首先我們

00:27:05.500 --> 00:27:10.193
我們先來看一下這個 code review 的一個部分 這 code review 的部分

00:27:10.193 --> 00:27:14.915
基本上就是你可以在這個 Claude Code 裡面去直接打這個 code review

00:27:14.915 --> 00:27:19.947
那它這個 code review 做的事情基本上就是一般你今天在跟其他工程師 在做

00:27:19.947 --> 00:27:22.500
code review 基本上是一模一樣的事情

00:27:22.500 --> 00:27:24.271
但是這個 code review

00:27:24.271 --> 00:27:30.555
它有一個比較重要的點要去考慮到就是說 如果你今天這個 Low 或者說比較 medium

00:27:30.555 --> 00:27:33.203
它可能能抓住的問題 會比較少一點

00:27:33.203 --> 00:27:37.500
但是如果你今天是開到比較高一點它可能會花更多的時間

00:27:37.500 --> 00:27:42.500
跟更多的 token 去幫你看你的這個程式碼有沒有什麼問題

00:27:43.500 --> 00:27:47.717
但是今天除了這個 code review 的一個功能之外還有另外一個

00:27:47.717 --> 00:27:52.452
這個 security review 這個 security review 跟這個 code review

00:27:52.452 --> 00:27:57.826
最大的區別是什麼就是說我今天如果去調用這個命令 是 security review 的話

00:27:57.826 --> 00:27:59.500
它是特別針對安全的部分

00:27:59.500 --> 00:28:07.051
去做 review 就是說如果我今天我的程式碼裡面可能有一些跟 比如說這個 SQL injection 或者說

00:28:07.051 --> 00:28:11.664
XSS 相關的一些問題的話 它是專門去抓安全漏洞的一個指令

00:28:11.664 --> 00:28:15.500
那它它們這兩個最主要的區別上面這個是比較通用

00:28:15.500 --> 00:28:21.680
就是它是抓 bug 或者說邏輯錯誤或者說有什麼可以清理的檔案都是用這樣的方式

00:28:21.680 --> 00:28:28.549
來做處理然後甚至它會幫你去關心就是說它跟你這個專案的慣例 有沒有一些不符合的寫法

00:28:28.549 --> 00:28:33.500
那這個部分它是關心的就是說這段程式碼它對還是不對 乾不乾淨

00:28:34.500 --> 00:28:39.027
但是如果我今天是 security review 的話它是專門去抓安全漏洞

00:28:39.027 --> 00:28:45.889
像是比如說它今天看你的這個程式碼裡面有沒有什麼跟 SQL injection 有關的一些安全問題或者說

00:28:45.889 --> 00:28:49.500
XSS 或者說一些授權的缺陷或者說你今天寫的程式碼

00:28:49.500 --> 00:28:52.374
它可能會有一個嚴重的一個資安的漏洞

00:28:52.374 --> 00:28:56.500
那這部分就是它會去關心你的程式碼說 是不是會被攻擊

00:28:57.500 --> 00:29:03.288
那以上就是說我們去使用這兩個指令的時候其實可以很好幫助我們在做

00:29:03.288 --> 00:29:09.450
程式的開發裡面去更好去讓我們的程式碼變得更完善一點因為其實有的時候

00:29:09.450 --> 00:29:15.500
你今天 可能團隊比較小大家可能各自忙的事情比較多那這時候能夠幫你去

00:29:15.500 --> 00:29:21.429
整個 code review 的能力可能就不足然後花的時間會比較少一點但是 AI

00:29:21.429 --> 00:29:24.007
就可以幫我們去做到這樣的事情

00:29:24.007 --> 00:29:28.500
然後幫助我們所產出的程式碼是變得比較 有更高的品質

00:29:29.500 --> 00:29:35.348
那接下來我們要去學習的是這一個跟 context 有關的 一些基本的實戰

00:29:35.348 --> 00:29:40.367
那這個基本的實戰就是說我今天去學習這個 context 的一個

00:29:40.367 --> 00:29:45.500
基本概念是什麼還有就是說我今天怎麼樣去管理我的 context

00:29:45.500 --> 00:29:51.187
會是一個比較好的一個方式包含就是說你今天要用 context 的方式去做管理

00:29:51.187 --> 00:29:55.429
還是說你直接用來說第三種方式是你今天用那個 dump to

00:29:55.429 --> 00:30:00.500
那個 file 的方式來做處理那這個這三種部分它分別都有各自的好處

00:30:00.500 --> 00:30:06.495
可以讓你去管理這個 context 的一個使用然後幫助你在 不管是節省

00:30:06.495 --> 00:30:12.500
token 上面還是說去提升這個 agent 的效率 都會有很大的一個提升

00:30:13.500 --> 00:30:17.825
那首先我們先來看一下 context 這個部分 context 這個部分

00:30:17.825 --> 00:30:23.109
我們一樣也可以在 Claude Code 這個地方去輸入對應的指令 就是 context

00:30:23.109 --> 00:30:26.539
這個地方那當我們輸入 context 之後我們會看到

00:30:26.539 --> 00:30:30.500
它會幫我們把目前上下文所消耗的一些內容都給展示出來

00:30:31.500 --> 00:30:36.604
像是說你今天可以看到我今天使用的模型是什麼然後我今天去使用的 tok

00:30:36.604 --> 00:30:41.771
en 數 已經達到了整個 token 它所接受的這個上下文的窗口的比例是多少

00:30:41.771 --> 00:30:46.500
那裡面包含什麼樣的東西像是今天這個 Claude Code 它本身的一些

00:30:46.500 --> 00:30:52.794
系統的一些 promptt 或者說它的一些系統的工具這個基本上就是它每次發請求

00:30:52.794 --> 00:30:57.698
給這個模型的時候都會帶上了一些提示詞然後再來就是說包含

00:30:57.698 --> 00:31:04.500
你今天安裝的一些 MCP 的一些工具或者說它可以調用的一些內部工具有什麼那或者說

00:31:04.500 --> 00:31:09.045
如果你今天有去自訂一些 agent 那這部分也會展示在這個地方

00:31:09.045 --> 00:31:13.516
還有像是記憶檔案 skills 跟這個一些其他地方都會展示出來

00:31:13.516 --> 00:31:18.861
然後最後它有去跟你講說 你還剩下多少空間可以去做使用那左邊這個部分

00:31:18.861 --> 00:31:21.500
就是很直覺的去理解到就是說我目前

00:31:21.500 --> 00:31:27.500
所使用到的這個 context 的內容包含了一些東西然後還有剩下多少空間 去做使用

00:31:28.500 --> 00:31:34.148
那當我們今天如果發現我們的這個 context 越用越多它已經到了

00:31:34.148 --> 00:31:37.105
可能到這個部分或者說已經快滿了

00:31:37.105 --> 00:31:43.739
那這時候你要去注意幾個重點左邊第一個就是說 我今天如果讓我的 context

00:31:43.739 --> 00:31:46.500
變得越來越滿它對我們這個模型

00:31:46.500 --> 00:31:52.469
會有兩個缺點首先第一個就是你每次傳的 token 很多那代表說就是 你消耗的 tok

00:31:52.469 --> 00:31:57.194
en 很多那這時候就代表你的賬單會變得更貴或者說你今天去使用

00:31:57.194 --> 00:32:02.500
這個訂閱的額度也會很快的就被消耗光了這是第一個缺點第二個部分就是

00:32:02.500 --> 00:32:08.046
你今天如果去用了比較多的 context 的內容去送給這個模型的話

00:32:08.046 --> 00:32:13.079
那這個模型本身它所能認知到的一些重點就會變得比較模糊

00:32:13.079 --> 00:32:18.500
就一樣是我們今天人類如果你今天看到一本書它給你很多的內容

00:32:18.500 --> 00:32:30.401
那它叫你去讀其中一個重點是什麼你是要去翻很久去把這本書都可能 看過一遍才會知道說重點是什麼那有可能會有其他一些內容去影響到你的判斷

00:32:30.401 --> 00:32:36.500
然後也會讓你去模糊整個事情的一個重點讓你沒辦法去專注在這個重點上面

00:32:36.500 --> 00:32:43.012
去解決問題那對於模型來講也是一樣你今天如果餵給它的 context 越多

00:32:43.012 --> 00:32:49.267
那基本上它所能去理解跟解決問題的那個效率 可能就會跟著一起變差

00:32:49.267 --> 00:32:54.000
所以我們今天去管理我們的上下文不只是去要去節省

00:32:54.000 --> 00:32:59.555
Token 這麼簡單也是說要讓我們的這個工作的效率就是說讓這個模型

00:32:59.555 --> 00:33:06.262
去執行我們這個輸出的結果的時候是變得更精準而且更準確的 這樣的一個處理方式

00:33:06.262 --> 00:33:10.500
那我們來看一下有幾種處理的方式說基本上我們會有

00:33:10.500 --> 00:33:18.011
三種處理這個 context 的一個方式是我們在工作上會比較常見的 首先第一個就是說你可以用很簡單的一個

00:33:18.011 --> 00:33:22.425
compact 指令然後把目前的聊天內容 做成摘要去壓縮這個內容

00:33:22.425 --> 00:33:24.500
所以基本上你可以在這個地方

00:33:24.500 --> 00:33:27.607
去輸入 compact 這 compact 做的事情

00:33:27.607 --> 00:33:31.809
基本上就是它自動幫你 把你目前為止對話的所有內容

00:33:31.809 --> 00:33:36.370
然後做一個壓縮還有就是說做一個摘要 它不是把這個內容

00:33:36.370 --> 00:33:40.500
給刪掉而是說它今天可能把這些內容它認為比較需要

00:33:40.500 --> 00:33:46.224
該壓縮的部分壓縮起來然後做成一個摘要這樣一個好處就是你在 維持同一個任務的時候

00:33:46.224 --> 00:33:51.054
譬如說你今天可能是任務做到一半那這個任務做到一半 你不可能關掉整個

00:33:51.054 --> 00:33:55.422
session 嘛對不對你可能希望它繼續做下去 但是 context 不夠用

00:33:55.422 --> 00:33:58.500
那這時候你用 compact 的方式就是你可以保留

00:33:58.500 --> 00:34:04.089
這個任務的一個延續性然後再進行下一個任務的時候有更多的 context

00:34:04.089 --> 00:34:09.704
空間 可以去運用那基本上你也可以在這個地方去打一些你想要他去特別

00:34:09.704 --> 00:34:16.500
不要丟掉的東西不要特別壓縮的東西像是譬如說你可以在這個地方去寫說你想要去保留

00:34:16.500 --> 00:34:22.252
就是你這個任務裡面包含一些錯誤處理的方式或是說一些資料庫的 schema

00:34:22.252 --> 00:34:27.098
你都可以讓這個 agent 讓他知道說他在做壓縮跟做摘要的時候

00:34:27.098 --> 00:34:33.500
什麼樣的內容 是不需要過度的壓縮可能這邊包含比較多的資訊像是可能有一些比較

00:34:33.500 --> 00:34:39.150
你已經定義好的一些模式錯誤處理的方式是你在剛剛 在跟這個 agent

00:34:39.150 --> 00:34:45.910
聊天過程所得到的結論那你可能希望他保留下來 可以用這樣的方式來讓這個 agent

00:34:45.910 --> 00:34:48.500
把這些內容不要壓縮的太太嚴重

00:34:49.500 --> 00:34:55.988
然後第二個方式就是你可以直接把所有的內容清掉那這個也是我一個非常推薦的方式

00:34:55.988 --> 00:34:59.241
就是說當你今天在使用這個 agent 的時候

00:34:59.241 --> 00:35:06.500
我會比較建議就是說不要盲目的去 讓他一次做完所有事情而是說你自己要先把這個任務給分成

00:35:06.500 --> 00:35:08.511
A 跟 B 還有 C 三種任務

00:35:08.511 --> 00:35:17.837
那這三種任務它可能是不相干的 所以就是說我今天可能我舉個例子我這個前端的頁面裡面可能有三個頁面的功能

00:35:17.837 --> 00:35:23.500
第一個頁面的功能它就是單純就是一個個人介紹的頁面那第二個功能

00:35:23.500 --> 00:35:28.095
可能它是一個首頁這個首頁其實跟個人介紹的頁面也沒有任何關係

00:35:28.095 --> 00:35:33.229
那這時候 第三個部分可能它就是一個個人後台的一個頁面這樣的一個方式

00:35:33.229 --> 00:35:38.291
那我今天在做這個 agent 的處理的時候可能就是這樣規劃 就是說我一個

00:35:38.291 --> 00:35:41.500
session 我就讓他去專注處理一個任務就好了

00:35:41.500 --> 00:35:46.526
那當這個任務處理完之後我就把整個 session 丟掉那我是下一個

00:35:46.526 --> 00:35:51.552
再去執行的時候我的下一個 session 再做執行的時候基本上它說

00:35:51.552 --> 00:35:56.500
用的 context 就會比較少首先第一個我的 token 消耗就會變少

00:35:56.500 --> 00:36:02.709
第二個就是我今天在因為 token 消耗變少了 那這 context 的內容會變少了我的 agent

00:36:02.709 --> 00:36:07.420
可以更有效率的去 更專注的完成我想要他完成的任務所以這個地方

00:36:07.420 --> 00:36:13.500
就是 我們今天去使用這個 clear 的時候可以去考慮的一個方式然後在這個地方可以去

00:36:13.500 --> 00:36:19.402
理解就是說我今天如果去使用這個 clear 的一個方式的話 是我把這個 session

00:36:19.402 --> 00:36:24.834
給關掉但是如果你今天想要做一個備份 就是說我今天可能希望在關掉之前

00:36:24.834 --> 00:36:27.500
我給他下一個 id 就可能下一個名字

00:36:27.500 --> 00:36:35.635
譬如說這是一個跟 hello page 有關的東西 那我下一次如果我希望把這個內容

00:36:35.635 --> 00:36:43.500
給救回來的話 就是我可能今天刪掉了發現前面有些東西我需要把它給救回來

00:36:43.500 --> 00:36:49.266
那這地方我可以打 resume 然後有沒有這個地方就有一個 hello page

00:36:49.266 --> 00:36:54.500
讓我去選然後我把它選回來就像這個樣子把剛剛的內容給救回來

00:36:55.500 --> 00:37:00.512
那你也可以就是直接把它打在後面它會把剛剛的內容給救回來

00:37:00.512 --> 00:37:06.442
所以這個時候就是說如果你今天想要去使用這個 clear 的指令來做 不同

00:37:06.442 --> 00:37:11.500
session 的一個切換的話它是有一個保底就是可以讓你回退到

00:37:11.500 --> 00:37:16.193
上一個 session 如果你發現有些東西你是需要的 那你可以回到這個上一個

00:37:16.193 --> 00:37:18.500
session 然後把裡面的東西給拿出來

00:37:20.500 --> 00:37:25.453
然後第三種方式就是這個 dump to file 的方式這個方式跟我們上面

00:37:25.453 --> 00:37:31.130
用這個 resume 的方式其實有一點像就是說我今天是希望他 清除掉所有的內容

00:37:31.130 --> 00:37:35.500
但是有一些部分我覺得我跟 agent 討論起來是非常有價值的

00:37:35.500 --> 00:37:42.123
那我希望他把它備份起來就是說放到我的這個程式碼的工作目錄底下

00:37:42.123 --> 00:37:50.500
所以這個時候它不是一個指令你可能就直接告訴這個 agent 就是說 我希望你幫我整理

00:37:50.500 --> 00:37:56.840
XXX 東西放到哪裡放到你可以自己自定義 任何一個資料夾跟目錄底下

00:37:56.840 --> 00:38:01.629
但是我這邊已經有自定義一個這個 Docs 這個資料夾

00:38:01.629 --> 00:38:08.500
那這個就是我提供的一個範例就是說我可能會希望他把這個假設我做了一個

00:38:08.500 --> 00:38:18.264
AI Refactor 的一個部分那我可能會希望就是說 把他放到這個 Docs

00:38:18.264 --> 00:38:23.500
裡面 裡面 然後命名成這個 .md 檔案

00:38:25.500 --> 00:38:34.418
那這個就是一個範例就是說我今天可能他討論到我覺得他有一些 跟這個 auth 有關的一些實作是很不錯就是他的目標是什麼

00:38:34.418 --> 00:38:39.500
然後我改了哪些檔案然後可能有一些 todo 在這個地方那這個是我認為

00:38:39.500 --> 00:38:54.500
在上一個對話是有價值的東西我可以用這樣的方式來做處理這樣的話有一個好處就是說 他既不會去壓縮到你認為重要的東西也會幫你去 你也可以去任意的清掉就是說沒有必要去殘留在這個 Session 裡面的

00:38:54.500 --> 00:39:00.203
context 的內容那這個時候你可以就是下一次 啟動一個新的一個

00:39:00.203 --> 00:39:05.319
Session 的時候你可以直接跟他講去直接讀 直接讀取 XXX

00:39:05.319 --> 00:39:09.500
檔案就是可能我們剛才命名的這個檔案然後去把

00:39:09.500 --> 00:39:15.148
上一個所定義的內容給載入到這個 Session 裡面那這個也是我平常在工作裡面

00:39:15.148 --> 00:39:20.470
蠻常用到的一個技巧因為我今天可能去使用這 compact 的一個指令的時候

00:39:20.470 --> 00:39:26.500
他所帶給我的一個效果可能不是我想要的反而會把一些我認為重要的東西可以壓縮掉

00:39:26.500 --> 00:39:29.022
即便我今天可能後面打了這個指令

00:39:29.022 --> 00:39:33.823
但是我們要今天要去理解一件事情就是說 當我們今天告訴 agent

00:39:33.823 --> 00:39:37.119
去做一件事情的時候他並不一定 100%會照著

00:39:37.119 --> 00:39:42.500
你的指令去做他可能就是說你叫他保留一些錯誤處理的模式但是他會保留

00:39:42.500 --> 00:39:47.553
多少錯誤處理的模式我不知道可能有五個模式是我想要保留的但是他最後

00:39:47.553 --> 00:39:52.290
決定說他只想保留四個留一個是不重要的那我是就可能錯失掉那一個

00:39:52.290 --> 00:39:57.500
可能我也想要保留的一個模式在這個部分那如果我今天是希望確實所有東西

00:39:57.500 --> 00:40:01.384
我要審核一下然後我想要把這所有的內容給備份起來的話

00:40:01.384 --> 00:40:06.526
那我就可以用這個 dump to file 的方式把這個內容給備份到這個專案底下

00:40:06.526 --> 00:40:12.500
那這時候 就可以變成說就是我下一次在啟動這個新的 session 的時候 我只要載入這個

00:40:12.500 --> 00:40:17.417
.md 檔案我一樣可以獲得上一次 session 所討論的最後我認為

00:40:17.417 --> 00:40:21.500
非常好的一個結果然後繼續延續我的工作繼續做下去

00:40:22.500 --> 00:40:29.050
那以上就是說我們這個三個這個不同管理 session 的 一個指令

00:40:29.050 --> 00:40:34.421
他所去使用的一個方式那這三個指令大概就是到這邊

00:40:34.421 --> 00:40:39.500
接下來是我們這個關於記憶跟這個 CLAUDE.md 的

00:40:39.500 --> 00:40:44.111
一個教學那這個部分的話也是一樣我們會根據這兩個指令

00:40:44.111 --> 00:40:50.566
然後去做教學就是說我們今天去使用這個 init 的指令就是說幫我們的這個專案

00:40:50.566 --> 00:40:55.500
去自動創建一個 CLAUDE.md 的一個檔案那他基本上就是一個

00:40:55.500 --> 00:40:59.828
跟記憶有關的一個檔案那第二個就是這個 memory 的部分

00:40:59.828 --> 00:41:06.380
就是說我今天要怎麼樣去管理我的記憶他就是說我這個記憶跟規則他的一個區別是什麼

00:41:06.380 --> 00:41:11.500
就是說我們這個在 Claude Code 裏面有分成一個叫規則的一個東西

00:41:11.500 --> 00:41:16.092
那這個我們等一下會做詳細的介紹那首先我們先來看這個 init 指令

00:41:16.092 --> 00:41:21.449
他所做的事情是什麼首先我們先回到這個專案底下我們來看一下這個專案的部分

00:41:21.449 --> 00:41:26.500
你可以看到就是說這裏面有一些我已經定義好的東西是我等一下會做教學的

00:41:26.500 --> 00:41:32.552
但是你可以看到我們這裏有一個 CLAUDE.md 的檔案對吧 那這個 CLAUDE.md

00:41:32.552 --> 00:41:38.152
檔案我先把它刪掉那我們回來這個終端機這個地方 這邊我去輸入 init

00:41:38.152 --> 00:41:40.500
這一個指令那這 init 的指令

00:41:40.500 --> 00:41:42.539
當我執行下去之後

00:41:42.539 --> 00:41:51.500
你會發現他會自動幫我們在這個 目錄底下去生成對應的 CLAUDE.md 的一個檔案

00:41:52.500 --> 00:41:57.892
我們等他一下那我們這個 CLAUDE.md 的檔案目前已經生成完成了在這個地方

00:41:57.892 --> 00:42:01.566
我們可以看到他其實花了一點時間去做處理為什麼呢

00:42:01.566 --> 00:42:05.624
因為我們當我們今天 去輸入這個 init 的一個指令的時候

00:42:05.624 --> 00:42:08.500
他所做的事情會是什麼他會先去看你這個

00:42:08.500 --> 00:42:14.041
專案底下有什麼樣的檔案跟什麼樣的重點他需要記錄下來然後他會把這些內容

00:42:14.041 --> 00:42:18.034
記錄到這個 CLAUDE.md 檔案裡面那在 CLAUDE.md 檔案

00:42:18.034 --> 00:42:26.500
你可以把他理解成什麼東西你可以把他理解成就是說你今天這個 agent 在去 你在工作目錄底下去做工作的時候他會去

00:42:26.500 --> 00:42:35.404
應該說去遵循的一個靈魂這個靈魂就是說他會去記憶就是說 我今天可能在這個專案裡面做一些事情的時候

00:42:35.404 --> 00:42:40.278
得用什麼樣的方式去做他可以有點算 算是一個記憶的一種

00:42:40.278 --> 00:42:44.500
但是更多的狀況他會是有點偏向是一個行為的方式

00:42:44.500 --> 00:42:46.577
就是說他今天在讀檔案的時候

00:42:46.577 --> 00:42:55.587
他可以用什麼樣的方式去讀可能會變得比較有效率一點 或是說他今天如果有一些指令他可能不用去從頭去看這個 package.json

00:42:55.587 --> 00:43:00.500
裡面的一些內容你光從這個 CLAUDE.md 裡面就可以知道說有哪些指令

00:43:00.500 --> 00:43:07.133
可以去做執行所以這個地方你可以把他理解成就是說他是一個它像是一個專案底下

00:43:07.133 --> 00:43:12.577
這個 agent 去執行他去工作的時候它所載入的一個靈魂那這個部分

00:43:12.577 --> 00:43:18.500
你可以去 理解一件事情就是這 CLAUDE.md 的檔案他是每一次都會被帶入

00:43:18.500 --> 00:43:22.535
這個 session 裡面做執行的就是說我今天這個 context

00:43:22.535 --> 00:43:27.032
裡面永遠都會有 CLAUDE.md 這一份檔案的內容但這有一個好處

00:43:27.032 --> 00:43:32.500
又有一個壞處就是說當你今天這個 CLAUDE.md 裡面內容越多的話他可能會去

00:43:32.500 --> 00:43:39.288
跟其他的一些規則有衝突就是說你這個裡面如果寫了一些對應的規則 跟其他地方

00:43:39.288 --> 00:43:44.705
像比如說你定一些 rules 在這個檔案底下或是說定一些 skills

00:43:44.705 --> 00:43:49.500
他如果有衝突的話他會有有時候可能去處理一些工作上面

00:43:49.500 --> 00:43:55.383
他的效率就會變差那第二點就是說他其實每一次 都會載入到這個 session

00:43:55.383 --> 00:44:00.978
裡面那載入到這個 session 裡面 你可以把他理解成就是他是一個記憶

00:44:00.978 --> 00:44:03.500
但是說他這個記憶並不是每一次

00:44:03.500 --> 00:44:10.245
都會去準確執行就是說你今天可能會告訴這個 agent 在這個 CLAUDE.md

00:44:10.245 --> 00:44:16.673
裡面去寫就是說你希望他可能去執行比如說每一次 寫完程式碼的時候

00:44:16.673 --> 00:44:20.500
都要去再重新 review 一下前陣子的改動

00:44:20.500 --> 00:44:25.912
然後去抓出有沒有一些資安的 bug 你可能寫了這一套規則或說記憶在這裡面

00:44:25.912 --> 00:44:31.404
但是 這個 agent 不一定每次都會執行為什麼因為這是大模型本身的一個行為

00:44:31.404 --> 00:44:36.500
就是說我今天這個大模型他並不是一個很簡單的你去輸入1 或者說輸入2

00:44:36.500 --> 00:44:41.207
他就會等於3 這樣的一個結果他是一個充滿隨機性的一個結果

00:44:41.207 --> 00:44:44.901
所以當我們今天去 使用這個 CLAUDE.md 的時候

00:44:44.901 --> 00:44:50.560
他基本上就是一個你可以把他理解成他是一個約 不是那麼強制的一個約束

00:44:50.560 --> 00:44:54.500
但是你的 agent 會去讀一下這裡面的東西盡可能去

00:44:54.500 --> 00:44:58.500
按照你所提供的一些內容然後去做做他的工作

00:45:00.500 --> 00:45:06.729
那我們今天除了去做這個 CLAUDE.md 的一個部分 我們還可以有另外一個指令

00:45:06.729 --> 00:45:13.040
來做這個記憶化的一個處理 就是這個 memory 的一個部分這個 memory 的部分

00:45:13.040 --> 00:45:14.500
其實基本上就是你

00:45:14.500 --> 00:45:20.138
輸入之後他會彈出這幾個東西那這幾個東西我們來 講解一下

00:45:20.138 --> 00:45:31.500
首先第一個是跟這個 project 有關的就是說我今天可能 跟這個項目有關的一些記憶都是存在這個 CLAUDE .md 裡面但是

00:45:31.500 --> 00:45:36.594
我今天可能可以額外寫另外一個什麼一個規則就是有時候規則跟記憶

00:45:36.594 --> 00:45:40.500
我們要把它區分開來就是說記憶可能是他今天可能在

00:45:41.500 --> 00:45:49.009
在這個狀態裡面去做工作的時候他可能是比較遵循就是說 我今天可能你可能會希望他去用

00:45:49.009 --> 00:45:55.765
pnpm 而不是 npm 這類的一些指令 或者說我今天可能有一些 auth 的問題的時候

00:45:55.765 --> 00:45:58.500
記得要先去看一些 a 組件的檔案

00:45:58.500 --> 00:46:04.175
或者說 b 組件的檔案這個是屬於比較偏向模糊的東西是需要比較偏向行為的東西

00:46:04.175 --> 00:46:06.607
我們都用記憶來做管理但是 rules

00:46:06.607 --> 00:46:15.500
這個規則他是做什麼樣的事情呢就是說 我今天是一個死的東西就是說他很明確就是有一個指令是你不能去做或者說你必須要做

00:46:15.500 --> 00:46:20.628
的一個東西我們就很適合把它寫成規則像說你希望這個 agent 在做

00:46:20.628 --> 00:46:24.463
所有的工作的時候永遠不要去打印某一個 API key

00:46:24.463 --> 00:46:30.112
裡面的內容 或者說你希望他在做狀態管理的時候永遠都用什麼就用 Jotai

00:46:30.112 --> 00:46:31.500
去做這個狀態管理

00:46:31.500 --> 00:46:36.421
不要用什麼 Redux 或者說其他的一些 library 去做狀態管理的部分

00:46:36.421 --> 00:46:40.983
這時候你把它寫在規則裡面他是會去讀的然後是會記著這件事情

00:46:40.983 --> 00:46:44.730
但是你說他會不會 100% 照這件事情去做其實不一定

00:46:44.730 --> 00:46:47.500
但是你可以理解就是你有訂出這些規則

00:46:47.500 --> 00:46:52.694
總比沒有訂還要好那你訂的這個規則他可能90% 或是 95% 的機率

00:46:52.694 --> 00:46:56.931
會按照你的規則去做執行但是有時候他可能 Context

00:46:56.931 --> 00:47:03.500
變得很混亂 或者說像我們剛才提到的就是你 Context 越來越大他的專注度下降了

00:47:03.500 --> 00:47:09.419
他可能就會忘記這個規則裡面的內容或者說他記憶裡面的內容然後提出了一個

00:47:09.419 --> 00:47:11.978
你不希望他做的事情所以 memory

00:47:11.978 --> 00:47:19.500
還有這個 rules 跟我們剛才提到的那個 Context 的管理是都必須要包含在一起在我們工作上面去

00:47:19.500 --> 00:47:22.500
合作在一起去做調整

00:47:23.500 --> 00:47:28.485
所以這邊可以看到就是說我們今天去定義這個 rules 的方法其實很簡單

00:47:28.485 --> 00:47:33.447
就是說我們今天在這個專案底下我們可以放上這三個規則 這三個資料夾

00:47:33.447 --> 00:47:37.500
基本上 agent 跟 skills 是我們在等一下才會去教學到的

00:47:37.500 --> 00:47:41.921
那這個 rules 我們可以先來看一下他就是一個 .md 的檔案

00:47:41.921 --> 00:47:47.073
但是你可以讓 不管要自己的打也好還是說你可以讓 ai 直接去生成也

00:47:47.073 --> 00:47:53.500
ok 就是說你可以在這裡面 去定義一些比較硬的規則就是說你希望 ai 每一次去做決策

00:47:53.500 --> 00:47:58.868
或者說去做工作的時候都是要遵循你這個定義好的規則不可以有任何一點

00:47:58.868 --> 00:48:04.236
查錯的話你可以把這些東西給寫在這個地方但是他實際怎麼做你也不知道

00:48:04.236 --> 00:48:08.983
但是基本上我覺得只要你的 context 不是太混亂大概90%的行為

00:48:08.983 --> 00:48:11.500
都是會按照你定好的規則去做處理

00:48:12.500 --> 00:48:17.923
所以我今天寫這條規則之後我的這個 agent 他在做處理的時候 譬如說

00:48:17.923 --> 00:48:22.505
我今天想要他去做一些狀態管理的處理他就不會調用 Redux

00:48:22.505 --> 00:48:27.500
之類的一些 解決方案來做處理那我們再回到這個 memory 的部分

00:48:27.500 --> 00:48:36.546
基本上這個 memory 的部分他除了包含這個 項目的一個層級之外還有包含這個用戶的層級

00:48:36.546 --> 00:48:42.500
這個用戶的層級的意思就是說你先點擊點擊之後他會在你的

00:48:42.500 --> 00:48:44.505
以你用戶的角度比如說

00:48:44.505 --> 00:48:53.006
你今天這個電腦上面有很多的專案那就是說 根據你好幾個專案他都套用這樣的一個記憶去做處理

00:48:53.006 --> 00:48:58.500
所以這個是 跨專案的一個維度去做處理的這樣的一個記憶方式

00:48:59.500 --> 00:49:04.094
那接下來是我們這個第四個記憶的方式這個第四個記憶的方式

00:49:04.094 --> 00:49:08.415
基本上就是你先可以讓 然後自動去記憶你的一些工作內容

00:49:08.415 --> 00:49:14.438
像是譬如說你們在工作對話的內容 他會自動幫你去做一些記憶這個是第一個部分

00:49:14.438 --> 00:49:17.500
那這個是他完全自動的這個我們不用特別

00:49:17.500 --> 00:49:23.420
干涉他怎麼樣去做處理那第二個部分就是說你今天可能希望他主動去記憶某一些事情

00:49:23.420 --> 00:49:25.500
那這時候你可以讓他寫成一個

00:49:26.500 --> 00:49:31.801
自己在自動去記憶的一個內容然後他會放到固定的資料夾裡面

00:49:31.801 --> 00:49:36.513
所以我們這個地方來演示一下會要怎麼樣去做這件事情

00:49:36.513 --> 00:49:41.500
基本上你就可以在這個 指令這個地方去輸入請幫我請幫我

00:49:41.500 --> 00:49:52.500
記住我的開發編號 是使用 React 框架

00:49:53.500 --> 00:49:56.500
那我們就等他跑一下看他是怎麼樣處理這件事情

00:49:57.500 --> 00:50:04.243
那這時候他已經執行完了所以我們可以來可以來看一下他是怎麼樣去自動記住這件事情

00:50:04.243 --> 00:50:09.052
首先我們來回來這個地方我們來輸入這個 memory 的一個指令

00:50:09.052 --> 00:50:14.500
然後我們打開第四個這個部分去打開這個 auto memory 的一個資料夾

00:50:14.500 --> 00:50:18.472
那打開之後你可以看到有沒有在這個地方他出現了一個

00:50:18.472 --> 00:50:21.873
React development preference 的一個 .md

00:50:21.873 --> 00:50:27.500
那這裡面就包含了什麼包含了我們今天可能希望他去做的事情就放在這個裡面

00:50:27.500 --> 00:50:39.048
所以其實基本上我們這個第四個方式他所做的事情就是你可以讓他主動去記得一些東西 或者說讓他自動去記得你的一些工作的內容

00:50:39.048 --> 00:50:44.500
那以上就是我們這個在這個 init 還有這個 memory 指令裡面

00:50:44.500 --> 00:50:50.836
去做的一個教學那這個部分的話其實基本上就是說我們在用這兩個 跟記憶有關的一個指令

00:50:50.836 --> 00:50:55.676
去代入到了什麼叫做規則還有就是說什麼叫做 memory 然後這個部分

00:50:55.676 --> 00:51:00.500
我們要怎麼樣去區分這兩個東西在我們的專案裡面要怎麼樣去做定義

00:51:00.500 --> 00:51:05.247
像是譬如說如果今天是一些比較模糊或者說一些比較行為有關的一些內容

00:51:05.247 --> 00:51:10.439
我們可以把它歸類成記憶的部分但是如果是一些死的規則是一些可以定義的規則

00:51:10.439 --> 00:51:13.954
那就是說我們就會把它寫在 rules 裡面那這個 rules

00:51:13.954 --> 00:51:18.500
裡面是 基本上是可以放在這個.claude 的一個資料夾底下我們就放在

00:51:18.500 --> 00:51:20.751
我們的專案目錄底下就可以了

00:51:20.751 --> 00:51:26.500
然後這邊還包含這個 agents 跟 skills 是我們這個後面會講到的一個部分

00:51:27.500 --> 00:51:31.319
那接下來是我們這個跟 skill 有關的一個教學

00:51:31.319 --> 00:51:36.950
那這個教學我們最主要會去跟大家講解什麼是我們這個 Claude Code

00:51:36.950 --> 00:51:40.500
裡面的 skills 還有就是說他跟我們前面所

00:51:41.500 --> 00:51:45.441
之前所教到的一個這個 CLAUDE.md 的一個區別是什麼

00:51:45.441 --> 00:51:51.738
然後再來就是說 我們在開始去講解這個 skills 之前要先跟大家講解這個 MCP 的指令

00:51:51.738 --> 00:51:56.500
他所做的事情是什麼還有就是說其他另外的一個東西這個 plugin

00:51:56.500 --> 00:52:02.420
是什麼樣的一個東西那我們首先先來看一下這個 MCP 的部分 MCP 的部分

00:52:02.420 --> 00:52:06.986
就是一樣我們在這個地方去輸入這個 MCP 然後按 Enter

00:52:06.986 --> 00:52:13.500
然後這個時候我們會看到什麼 我們會看到我們這個 Claude Code 他有去管理著

00:52:13.500 --> 00:52:16.438
哪些 MCP 的 servers 那這個 MCP 的這個 servers

00:52:16.438 --> 00:52:18.500
我們會看到就是說他裡面有包含一些

00:52:19.500 --> 00:52:26.481
是純 MCP 的部分他就是說是一些內建的一個已經安裝好了這個跟 plugin 有關的一些工具

00:52:26.481 --> 00:52:28.626
那這個 MCP 跟這個 plugin

00:52:28.626 --> 00:52:35.500
他分別代表什麼樣的東西 跟我們的那個 skill 有什麼樣的關係我們這時候來做一個講解

00:52:35.500 --> 00:52:41.346
那這邊我們來看一下這一個部分首先基本上我們可以把他分成三個東西

00:52:41.346 --> 00:52:48.031
來討論第一個我們先來討論 MCP 基本上可以把 MCP 理解成就是他是 這個 agent

00:52:48.031 --> 00:52:52.500
就是我們這個 Claude Code 他的一個外掛的一個方式

00:52:52.500 --> 00:52:59.780
就是說我今天可能對於大模型來講他可以做的事情是有限的就是說他可能就是 你今天輸入一些文字

00:52:59.780 --> 00:53:05.550
然後吐出一些文字但是如果我今天幫他搭配一些工具 讓他去做選擇就是譬如說

00:53:05.550 --> 00:53:09.500
我今天告訴這個模型就是說你有可以看 Figma 的工具

00:53:09.500 --> 00:53:14.198
你有可以調用瀏覽器的工具那這個時候我要讓他去做這些處理的時候

00:53:14.198 --> 00:53:17.080
我會告訴他就是 你可以選擇要不要去調用

00:53:17.080 --> 00:53:20.862
Figma 或說你選擇要不要去調用瀏覽器來完成這個工作

00:53:20.862 --> 00:53:26.500
那如果你要我可以幫你去執行這個工具那這個工具執行的方式就是你在自己的本地

00:53:26.500 --> 00:53:30.218
有一個 MCP 的一個 server 那這 MCP 的 server

00:53:30.218 --> 00:53:34.845
就作為一個工具的橋樑去幫助大模型去完成他想要完成的任務

00:53:34.845 --> 00:53:40.500
所以就以我們剛才那個舉例來講如果今天可能希望去做一些前端的一些切版

00:53:40.500 --> 00:53:45.932
切版的一些工作那這切版的工作我可能希望大模型可以看懂什麼 看懂

00:53:45.932 --> 00:53:49.175
Figma 的一個設計稿那這個設計稿的部分

00:53:49.175 --> 00:53:55.500
可能就是 模型本身是沒辦法自己去讀的他需要依賴外部的工具去幫他做這件事情

00:53:55.500 --> 00:54:00.130
但是我們這個工具要怎麼樣做呢就是我們要在本地這個地方

00:54:00.130 --> 00:54:03.549
去 搭建一個小型的 server 那這個 server

00:54:03.549 --> 00:54:09.158
就可以讓 這個模型有這個能力去透過這樣的一個 server 然後看到一個

00:54:09.158 --> 00:54:11.500
Figma 設計稿裡面的一些內容

00:54:12.500 --> 00:54:18.073
所以基本上 MCP 我們可以就把它理解成就是我們幫我們的這個模型

00:54:18.073 --> 00:54:24.498
去裝備這樣的一個工具讓他有能力可以做到更多的事情 那 skill 是什麼東西

00:54:24.498 --> 00:54:28.500
skill 他其實就有點偏向是一個滑鼠巨集的概念

00:54:28.500 --> 00:54:35.417
就是說我今天可能大家在玩遊戲或者說在使用一些 鍵盤上面的功能的時候

00:54:35.417 --> 00:54:42.366
你可能會希望把所有的功能很多的功能去聚集到 某一個按鍵上面那 skill

00:54:42.366 --> 00:54:44.500
可能就會在做這件事情

00:54:44.500 --> 00:54:50.492
就是說 skill 在做這件事情的原理就是你今天可能會在這個 檔案裡面這個 skill

00:54:50.492 --> 00:54:55.587
裡面去寫好我這是什麼樣的一個 skill 譬如說這是一個切版的 skill

00:54:55.587 --> 00:54:58.500
那這切版 skill 包含什麼包含要去調用

00:54:58.500 --> 00:55:03.175
這個 MCP 的一個工具還要去調用這個瀏覽器偵錯的功能 為什麼

00:55:03.175 --> 00:55:07.800
因為我今天寫完這個前端頁面我需要我的 agent 去幫我看一下

00:55:07.800 --> 00:55:12.500
這個瀏覽器的畫面有沒有什麼錯誤跟他預期要寫出來這樣的一個

00:55:12.500 --> 00:55:19.054
Figma 上面的設計稿是不是相對保持一致的那這個時候我們可以把所有的一些內容

00:55:19.054 --> 00:55:24.693
都包裝成一個 skill 然後變成一個專屬的技能給這個 agent 去做處理

00:55:24.693 --> 00:55:28.500
所以基本上 skill 在 MCP 它是相輔相成的東西

00:55:28.500 --> 00:55:37.840
然後最後這個 plugin 是什麼意思就是說我今天可能 有好幾個不同的 skill 的技能跟好幾個不同的 MCP

00:55:37.840 --> 00:55:42.500
我希望把它包裝在一起然後方便分享給我團隊的成員

00:55:42.500 --> 00:55:48.801
去做安裝或說下載跟去做處理就是譬如說我今天把這一整套 這個看 Figma

00:55:48.801 --> 00:55:54.822
然後讓模型可以去調用瀏覽器偵錯的這個工作流程 包裝成一個 plugin

00:55:54.822 --> 00:55:58.500
之後我可以把它分享給什麼分享給我的同事

00:55:58.500 --> 00:56:02.941
它去安裝這個 plugin 一下就把這個 skill 跟 MCP 全部都裝好

00:56:02.941 --> 00:56:08.085
那這時候它也可以讓它的 agent 去有這個能力可以去跟我做到一樣的事情

00:56:08.085 --> 00:56:09.776
所以基本上這個 plugin

00:56:09.776 --> 00:56:16.500
做的事情就是所以你可以看到我們今天在這個 這個管理這個 MCP server 的地方你會看到就是說

00:56:16.500 --> 00:56:20.176
它的這個工具是來自於哪一個 plugin 裡面 所以我可以看到

00:56:20.176 --> 00:56:24.560
我今天這個 Figma 的工具 就是來自於這個 Figma 的這個 plugin 裡面

00:56:24.560 --> 00:56:28.500
然後這個 Playwright 的一個工具就是來自於這個 plugin 裡面

00:56:29.500 --> 00:56:34.316
那我們講解完這個部分之後我們來講解這個 skill 要怎麼去做處理

00:56:34.316 --> 00:56:39.010
基本上我們這個自定義的一些 skill 我們可以把它放在 .claude

00:56:39.010 --> 00:56:43.500
這個資料夾底下就跟我們這個前面提到的這個 rules 是一樣的

00:56:43.500 --> 00:56:48.500
我們可以把它放在同一個層級的資料夾裡面然後定義一個

00:56:48.500 --> 00:56:54.500
它對應的一個技能這個技能是什麼就是說我今天可能可以用手打也好

00:56:54.500 --> 00:56:59.500
你也可以去遵循一些別人寫好的一些比較好的範例去寫那

00:56:59.500 --> 00:57:05.068
更多的是你也可以讓 AI 去自動幫你去生成一個技能放到這個目錄底下

00:57:05.068 --> 00:57:11.014
像是我這個讓它生成的技能就是我希望它幫我做一個專案的講解的一個技能

00:57:11.014 --> 00:57:17.500
為什麼因為我今天可能今天這個專案可能會有新人進來然後我希望它每一次就是說

00:57:17.500 --> 00:57:20.809
如果有新人進來的時候可以調用這個技能

00:57:20.809 --> 00:57:35.500
然後去跟新人解釋說我們今天這個目錄裡面 有哪一些內容有哪些組件或者說有哪些檔案是需要去先去閱讀的 或者說有哪些跟這個資料庫有關的一些 schema 是希望這個新人可以先去

00:57:35.500 --> 00:57:39.462
讀看看這時候我可以把它包裝成一個技能去做處理

00:57:39.462 --> 00:57:43.856
那這裡面它可能就會包含一些 工具的調用寫在這個裡面

00:57:43.856 --> 00:57:47.638
所以這個就是我們基本上在使用這樣的一個技能

00:57:47.638 --> 00:57:52.500
去做處理的時候的一種方式這只是其中一種比較簡單的方式那

00:57:52.500 --> 00:57:58.271
另外就是說我今天如果要去讓它執行這個技能的時候你可以直接跟它講

00:57:58.271 --> 00:58:03.185
然後它執行什麼就是這個地方打執行這個技能 這樣就可以了

00:58:03.185 --> 00:58:08.500
那這個時候我們的這個 agent 他就會去看一下我們這個專案目錄

00:58:08.500 --> 00:58:15.500
底下有哪樣的技能有沒有這個地方他去執行這個技能然後最後 去輸出這個結果

00:58:17.500 --> 00:58:21.823
那再來就是另外一個問題就是我們這個 skill 本身他跟我們之前

00:58:21.823 --> 00:58:27.108
介紹的 那個 CLAUDE.md 就是我們這個專案底下這個 CLAUDE.md 的區別是什麼

00:58:27.108 --> 00:58:31.500
因為他們看起來很像就是我都在這個檔案裡面寫我希望他做的事情

00:58:31.500 --> 00:58:40.244
那一個是跟記憶有關一個是跟技能有關那他這兩個實際上的一個區別 在什麼地方我把它列出來給大家看一下

00:58:40.244 --> 00:58:43.703
首先我們可以看到就是說 對於 CLAUDE.md

00:58:43.703 --> 00:58:48.500
來講他的核心用途是你這個專案平常他是什麼樣的一個專案

00:58:48.500 --> 00:58:55.251
他必須要去遵守什麼樣的一些記憶或者說規則或者說行為這個我會把它寫在 這個 CLAUDE.md

00:58:55.251 --> 00:59:00.230
裡面為什麼因為他是每一次 都會被 session 給載入進去的但是對於

00:59:00.230 --> 00:59:02.500
skills 來講基本上只要你沒有

00:59:02.500 --> 00:59:06.922
希望他去調用他就不會幾乎是不會去用到這個 context

00:59:06.922 --> 00:59:11.426
就是說他可能會讓這個 agent 知道說有什麼樣的 skill

00:59:11.426 --> 00:59:18.500
但是他不會直接去 讀取裡面的內容然後去做裡面的事情這是第一個部分 然後再來就是說

00:59:18.500 --> 00:59:24.102
只有你去手動去操作或者說你今天可能希望 他去特別做某件事情的時候

00:59:24.102 --> 00:59:27.233
他會自動去觸發這個 skill 像是比如說

00:59:27.233 --> 00:59:32.326
我今天 可能跟他講說有新人來了他可能就自動去調用這個 skill

00:59:32.326 --> 00:59:36.500
然後幫我告訴說 這個新人他想要去理解什麼樣的範圍

00:59:37.500 --> 00:59:41.469
那如果你用直接指定的方式就是我用直接用這種指定的方式

00:59:41.469 --> 00:59:44.813
他也會直接去調用這個 skill 那對於 CLAUDE.md

00:59:44.813 --> 00:59:47.775
來講是 你這個專案只要一執行他就載入進來

00:59:47.775 --> 00:59:51.500
所以你也不需要特別告訴他是 你要去調用什麼樣的東西

00:59:52.500 --> 00:59:57.124
然後再來就是說他這個東西啊他是比較偏向背景資料的東西

00:59:57.124 --> 01:00:02.699
你可以把一些資源的檔案給加入進來就是譬如說你希望這個 CLAUDE.md

01:00:02.699 --> 01:00:07.500
去讀一些可能外部一些資訊那這個外部的資訊你可能放在哪裡

01:00:07.500 --> 01:00:13.076
放在這個 docs 資料夾底下或說你有其他一些資料夾是放一些外部資訊

01:00:13.076 --> 01:00:16.413
但是對 skill 來講他也是可以做這些事情

01:00:16.413 --> 01:00:23.500
但是他做更多的事情是什麼就是說 他是放可能一些腳本或說放一些輸出的內容的一個結果

01:00:23.500 --> 01:00:30.718
因為他是比較偏向技能嘛那譬如說我有一個技能是我希望他做一些 自動去寫程式碼的功能像

01:00:30.718 --> 01:00:34.470
譬如說我今天可能有一個系統我希望他建立一個

01:00:34.470 --> 01:00:39.500
skill 是自動幫我的用戶去處理錢包裡面的額度譬如說自動充值

01:00:39.500 --> 01:00:43.895
或說自動扣除點數這部分他是屬於一個 agent 的技能

01:00:43.895 --> 01:00:50.240
那他可能會額外再寫一個什麼寫一些程式碼放在也是一樣放在某個資料夾底下

01:00:50.240 --> 01:00:56.500
那這時候我的如果把這個路徑告訴這個 skill 就是說把它寫進這個檔案裡面

01:00:56.500 --> 01:01:02.504
那這個檔案他知道說我有這些腳本可以用他會在這個過程 再去調用這個腳本

01:01:02.504 --> 01:01:07.025
所以基本上就是你可以透過這樣的方式去豐富你的 agent

01:01:07.025 --> 01:01:12.500
可以做的事情那不管是把 MCP 的工具加進來還是你另外再寫一些腳本

01:01:12.500 --> 01:01:16.588
讓他去處理一些更複雜的任務都會用這樣的方式來做處理像

01:01:16.588 --> 01:01:22.468
譬如說你想要讓他去爬蟲 那你可以去把爬蟲的腳本寫好然後把這個爬蟲的腳本的路徑

01:01:22.468 --> 01:01:26.500
放到這個 skills 裡面然後當你去執行這個 skill 的時候

01:01:26.500 --> 01:01:30.236
他就自動去調用那個腳本如果他認為要調用的話他就自動去調用

01:01:30.236 --> 01:01:35.994
然後幫你去把這個 你想要爬蟲的那些資料給抓下來這個是他們跟 CLAUDE.md 的一個最主要的區別

01:01:35.994 --> 01:01:39.964
那 CLAUDE.md 它就是因為他不是技能嘛他是比較偏背景資料的東西

01:01:39.964 --> 01:01:44.500
所以我們就是把一些可能跟行為有關的東西放在這裡面就好了然後再來就是說

01:01:44.500 --> 01:01:51.100
他是能不能被控制基本上 skills 是可以被控制的因為如果你今天這個 他判斷這個模型

01:01:51.100 --> 01:01:55.386
判斷就是說你希望他去執行的任務是不需要用到這個技能

01:01:55.386 --> 01:01:59.500
他就不會去觸發在裡面這些腳本啊或說你寫好一些內容

01:01:59.500 --> 01:02:05.571
跟你指定的這些 MCP 的工具但是對於 CLAUDE.md 來講沒辦法

01:02:05.571 --> 01:02:12.491
因為他每次就是會被載入進來所以這裡面我們要放的東西就是比較偏向

01:02:12.491 --> 01:02:14.500
每次都要調用的東西

01:02:15.500 --> 01:02:20.807
然後再來就是他是適合去做團隊共享基本上兩個東西都很適合去做團隊的共享

01:02:20.807 --> 01:02:26.114
基本上左邊這個他就是如果今天在同一個專案裡面工作我要遵循的行為是什麼

01:02:26.114 --> 01:02:30.500
我要遵循的規則是什麼都寫在這裡面了但是對 skills 來講就是

01:02:30.500 --> 01:02:35.378
你等於幫這個 agent 豐富了他的一個工作的技能那一樣這個部分

01:02:35.378 --> 01:02:41.358
如果你去分享給其他同事他也是可以做得更好像比如說你們今天可能多寫了一個

01:02:41.358 --> 01:02:46.500
性能優化的一個 skill 那你今天可以用這個性能優化的 skill 來做

01:02:46.500 --> 01:02:51.741
這個專案的一個性能上面的一個衡量那你也可以同樣把這個 skill

01:02:51.741 --> 01:02:56.083
包裝給你的另外一個同事同樣去做用那樣的一個 skill

01:02:56.083 --> 01:02:59.661
去衡量另外一個專案 或是說同一個專案都 OK

01:02:59.661 --> 01:03:03.500
所以這個就是我們今天在去使用這個 CLAUDE.md

01:03:03.500 --> 01:03:06.500
跟這個 skill 的時候他的一個最主要的區別就在這個地方

01:03:08.500 --> 01:03:16.862
那這個部分就是 我們這個 MCP 工具的一個介紹 那這個部分就到這個地方

01:03:16.862 --> 01:03:23.500
然後再來就是我們這個 關於 subagent 的一個教學的部分

01:03:23.500 --> 01:03:26.313
那基本上我們在處理這個 subagent 的時候

01:03:26.313 --> 01:03:31.762
我們也可以理解就是說 他是被放在這個 .claude 的一個資料夾底下他跟這個 skill

01:03:31.762 --> 01:03:36.823
還有 rules 一樣都是被放在這裡面的那我們可以來看一下這裡面的定義是什麼

01:03:36.823 --> 01:03:40.500
基本上你可以在這裡面去定義一個 agents 的一個資料夾

01:03:40.500 --> 01:03:43.784
然後一樣你也是用 .md 的方式去把這個內容

01:03:43.784 --> 01:03:51.467
給寫出來那基本上你可以 不管是你用自己的方式去寫或者說你去網路上面下載一些 agents 的這個樣板

01:03:51.467 --> 01:03:56.500
放到這裡面也 OK 或者說你也可以讓 AI 自動去幫你寫一些你希望他

01:03:56.500 --> 01:04:00.585
去寫好一些 agents 那這個 agent 他的一個重點是什麼

01:04:00.585 --> 01:04:05.407
就是說我今天在調用這個 agent 的時候他是一個子 agent 這個子

01:04:05.407 --> 01:04:10.470
agent 跟我們的主要的這個 agent 就是 Claude Code 這個主 agent

01:04:10.470 --> 01:04:12.500
他是兩個不一樣的 context

01:04:12.500 --> 01:04:17.475
就是說我們之前有提到就是說這個 context 本身他是如果你越混亂

01:04:17.475 --> 01:04:21.930
他可能他的專注度這個 agent 的專注度就會變得比較低一點

01:04:21.930 --> 01:04:27.500
但是這個 subagent 去解決另外一個問題就是我今天希望有一些特定的任務

01:04:27.500 --> 01:04:32.284
他是可以平行的去執行但是又不要跟我這個 context 共享在一起

01:04:32.284 --> 01:04:36.458
這可以避免什麼問題就是我剛才提到的那個專注度的問題

01:04:36.458 --> 01:04:41.500
那今天對於這個 subagent 來講他可能更專注於就是做某些特定任務

01:04:41.500 --> 01:04:48.500
這樣才是我們繼續使用這個 subagent 更主要的一個 前置條件

01:04:49.500 --> 01:04:54.690
那這邊的話你就可以看到我這個範例是去建立這個 code review 的一個

01:04:54.690 --> 01:04:58.570
subagent 那這個部分的話基本上 就是說可能會讓 AI

01:04:58.570 --> 01:05:02.500
去寫說他希望他完成的這個任務是什麼然後再來就是說

01:05:02.500 --> 01:05:08.146
他裡面有一些可能跟我這個我這個 repo 有關的一些 規則都寫在這個裡面

01:05:08.146 --> 01:05:13.652
然後還有就是說這個 workflow 也會寫在這裡面 那基本上就是一個讓主

01:05:13.652 --> 01:05:18.758
agent 就是我們這個 agent 去 讓這個 subagent 去做處理的時候

01:05:18.758 --> 01:05:20.500
他要怎麼去做這個工作

01:05:20.500 --> 01:05:26.805
都把它定義在這裡面那我們要怎麼樣去使用這個內容呢很簡單

01:05:26.805 --> 01:05:33.297
我們可以把這個路徑給複製下來然後這邊去寫說執行 subagent

01:05:33.297 --> 01:05:37.500
然後把他帶進來那我們可以看到這個地方

01:05:37.500 --> 01:05:42.350
他開始在讀取我們這個下的這個指令 然後稍微等他一下

01:05:42.350 --> 01:05:45.928
那這個時候你就可以看到他去執行了什麼

01:05:45.928 --> 01:05:51.921
執行了我們這個 code reviewer 的一個這個 agent 這個 subagent

01:05:51.921 --> 01:05:55.500
那你可以看到這什麼地方在下面這個地方

01:05:55.500 --> 01:05:59.044
我們可以看到在下面又有一個內容這個內容是什麼

01:05:59.044 --> 01:06:02.717
就是它真的去執行這個 code reviewer 的一個內容

01:06:02.717 --> 01:06:05.520
基本上你可以在用這個 上下鍵來做選擇

01:06:05.520 --> 01:06:09.500
如果你今天看到你的左下角這個 Claude Code 幫你開了

01:06:09.500 --> 01:06:14.958
另外一個這個這一行東西在這下面代表說他去幫你 調用了一個 subagent

01:06:14.958 --> 01:06:20.831
然後來做一些特定的任務那這個特定的任務裡面 他的一個上下文這個 context

01:06:20.831 --> 01:06:24.500
就跟我們這個主要的 context 是沒有混合在一起

01:06:26.500 --> 01:06:31.722
那基本上這個就是我們在去使用這個 Claude Code 來去處理

01:06:31.722 --> 01:06:34.500
我們這個 subagent 的一個方式

01:06:38.500 --> 01:06:43.384
那以上這14個常用的一個 Claude Code 指令就是我們在這次教學裡面

01:06:43.384 --> 01:06:48.569
去教給各位去學習的一個跟 Claude Code 有關的一個快速入門的一個部分

01:06:48.569 --> 01:06:53.500
那基本上這14個指令也是我自己平常在開發裡面蠻常去用到的一些指令

01:06:53.500 --> 01:06:58.580
然後不管是對於剛剛開始接觸這個 Claude Code 工具的一個新手

01:06:58.580 --> 01:07:01.058
還是說對於已經在使用這個工具

01:07:01.058 --> 01:07:07.500
一段時間的老手都是一個非常值得花時間去學習 跟理解它裡面底層原理的一些指令

01:07:09.500 --> 01:07:25.500
那再來就是說我們也介紹了跟這個 context 有關還有這個記憶有關規則有關 跟這個 skills 有關的一些內容那基本上這個就是我們在教學這個 整個快速入門的一個內容的部分

01:07:26.500 --> 01:07:32.500
然後就謝謝大家我們就下一個章節見我們下次見再見