WEBVTT
Kind: captions
Language: zh-TW

00:00:00.000 --> 00:00:02.960
你的電腦裡有沒有這種檔案：

00:00:02.960 --> 00:00:05.670
提案_最終版、提案_最終版2、

00:00:05.670 --> 00:00:07.240
提案_這版才對。

00:00:07.240 --> 00:00:09.930
如果有，那你其實已經在做版本控制了。

00:00:09.930 --> 00:00:12.450
只是用的是最痛苦的做法：

00:00:12.450 --> 00:00:14.730
靠檔名，靠記憶，靠運氣。

00:00:14.730 --> 00:00:16.700
工程師二十年前就受不了了，

00:00:16.700 --> 00:00:19.010
做了一套工具解決它：那套工具叫

00:00:19.010 --> 00:00:21.580
Git，存放的地方叫 GitHub。

00:00:21.580 --> 00:00:23.960
GitHub 你可能點進去過一次，

00:00:23.960 --> 00:00:25.230
然後就關掉了，因為

00:00:25.230 --> 00:00:27.080
那看起來是工程師的地方。

00:00:27.080 --> 00:00:28.950
但如果你最近開始用 AI

00:00:28.950 --> 00:00:31.770
幫你做東西，那個地方遲早會變成你的。

00:00:31.770 --> 00:00:34.400
不是因為你要變成工程師，是因為 AI

00:00:34.400 --> 00:00:37.350
一次改的東西比你多得多，你需要一個地方

00:00:37.350 --> 00:00:38.760
，讓你做壞了回得去。

00:00:38.760 --> 00:00:40.670
這支影片用一條線串起來，

00:00:40.670 --> 00:00:43.460
從你做出第一個東西，到你同時開兩個

00:00:43.460 --> 00:00:44.600
AI 幫你做事。

00:00:44.600 --> 00:00:46.120
每個名詞出現之前，

00:00:46.120 --> 00:00:48.300
我會先讓你遇到那個問題。

00:00:48.300 --> 00:00:50.550
而且每一個動作我都會多講一句：

00:00:50.550 --> 00:00:53.050
做完之後，你怎麼確認它真的做到了。

00:00:53.050 --> 00:00:55.400
因為這一年我自己踩過三次，

00:00:55.400 --> 00:00:57.360
每一次都是它做的事情，

00:00:57.360 --> 00:01:00.600
跟我以為它在做的事情，中間差了一層。

00:01:00.600 --> 00:01:01.570
我們直接開始。

00:01:02.370 --> 00:01:05.160
如果你還不認識我，我是 Gucci。

00:01:05.160 --> 00:01:07.880
我曾經是全球前三大記憶體廠的大數據

00:01:07.880 --> 00:01:10.920
工程師，2019 年放棄年薪近兩百萬，

00:01:10.920 --> 00:01:11.720
全職創業。

00:01:11.720 --> 00:01:14.580
去年，我的線上事業收入 440 萬。

00:01:14.580 --> 00:01:17.160
一年多前，我帶著老婆和剛滿 3

00:01:17.160 --> 00:01:19.930
歲的女兒開始旅居世界——不是度假，

00:01:19.930 --> 00:01:22.110
我照常工作，女兒照常上學，

00:01:22.110 --> 00:01:23.870
世界就是她的課本。

00:01:23.870 --> 00:01:27.140
從峇里島、清邁到檳城，支撐這種日子的，

00:01:27.140 --> 00:01:28.370
就是槓桿 AI：

00:01:28.370 --> 00:01:31.030
用更少的工時，把生活還給家人。

00:01:31.030 --> 00:01:32.830
好，回到今天的主題。

00:01:32.840 --> 00:01:35.160
假設你請 AI 幫你做一個東西。

00:01:35.160 --> 00:01:37.900
一頁網站也好，一個會自己跑的小工具也好

00:01:37.900 --> 00:01:39.980
，或是一份自動整理資料的表格。

00:01:39.980 --> 00:01:42.960
過了半小時，它做出來了，打得開。

00:01:42.960 --> 00:01:45.780
第一個問題馬上來了：這東西現在在哪裡？

00:01:45.780 --> 00:01:48.250
它在你的電腦裡，某個資料夾。

00:01:48.250 --> 00:01:51.140
這代表三件事：換一台電腦你就沒有它了、

00:01:51.140 --> 00:01:52.670
電腦壞了它跟著沒了、

00:01:52.670 --> 00:01:55.330
想給朋友看你只能整包壓縮寄過去。

00:01:55.330 --> 00:01:57.590
所以你需要一個雲端的地方。

00:01:57.590 --> 00:01:58.520
你可能會想，那用

00:01:58.520 --> 00:02:00.880
Google Drive 不就好了？

00:02:00.880 --> 00:02:01.440
不行。

00:02:01.440 --> 00:02:03.730
而原因就是這支影片的第一個重點。

00:02:03.730 --> 00:02:05.600
還記得開頭那幾個檔名嗎？

00:02:05.600 --> 00:02:06.770
你為什麼要留那些版本？

00:02:06.770 --> 00:02:08.230
不是因為你愛整理檔案，

00:02:08.230 --> 00:02:09.680
是因為你知道會有一刻，

00:02:09.680 --> 00:02:11.230
你想回到昨天那個版本。

00:02:11.230 --> 00:02:13.020
程式比報告更需要這件事，

00:02:13.020 --> 00:02:14.900
因為改壞的機會高太多了。

00:02:14.900 --> 00:02:16.680
所以放程式的那個地方，

00:02:16.680 --> 00:02:18.280
不能只是把檔案收好，

00:02:18.280 --> 00:02:21.230
它還要記得每一次改了什麼、為什麼改。

00:02:21.230 --> 00:02:22.500
Google Drive

00:02:22.500 --> 00:02:23.300
只做前面那半。

00:02:23.300 --> 00:02:25.830
做後面那半的，是今天的第一個名詞：

00:02:25.830 --> 00:02:26.440
Git。

00:02:26.440 --> 00:02:29.320
Git 是一個裝在你電腦裡的程式。

00:02:29.320 --> 00:02:31.230
它只管一件事：你每存一次，

00:02:31.230 --> 00:02:34.170
它就記下這一刻整個資料夾長什麼樣子，

00:02:34.170 --> 00:02:36.170
還有你留給自己的一句話。

00:02:36.170 --> 00:02:38.450
它從頭到尾都在你的機器上跑，

00:02:38.450 --> 00:02:39.770
沒有網路也能用。

00:02:39.770 --> 00:02:41.880
而 GitHub 是網路上的一個網站，

00:02:41.880 --> 00:02:43.830
專門放這種有版本紀錄的資料夾。

00:02:43.830 --> 00:02:46.710
這兩個名字只差三個字母，是兩個東西。

00:02:46.710 --> 00:02:48.750
一個在你電腦裡管紀錄，

00:02:48.750 --> 00:02:51.500
一個在網路上管存放跟給人看。

00:02:51.500 --> 00:02:52.220
怎麼開始？

00:02:52.220 --> 00:02:53.550
你不用學指令。

00:02:53.550 --> 00:02:54.820
不過下面每一句話，

00:02:54.820 --> 00:02:57.360
都要說給能直接動你電腦檔案的 AI

00:02:57.360 --> 00:02:58.890
聽，像 Codex 這種。

00:02:58.890 --> 00:03:01.970
貼進一般聊天視窗，它只會教你怎麼做，

00:03:01.970 --> 00:03:03.220
不會真的去做。

00:03:03.220 --> 00:03:05.230
幫我把這個資料夾建立版本紀錄，

00:03:05.230 --> 00:03:07.190
之後我要放到 GitHub 上。

00:03:07.190 --> 00:03:08.470
做完怎麼確認？

00:03:08.470 --> 00:03:09.540
請 AI 檢查這個

00:03:09.540 --> 00:03:11.220
資料夾有沒有開始記版本，

00:03:11.220 --> 00:03:13.160
並把它查到的結果貼給你看。

00:03:13.160 --> 00:03:15.190
不要特地去找那個叫 .git

00:03:15.190 --> 00:03:17.220
的資料夾，它預設是藏起來的，

00:03:17.220 --> 00:03:19.140
看不到很正常。

00:03:19.140 --> 00:03:21.430
Git 裝好了，但它不會自己動。

00:03:21.430 --> 00:03:23.230
你請 AI 加一個新功能，

00:03:23.230 --> 00:03:24.770
它動了七八個檔案。

00:03:24.770 --> 00:03:25.750
跑起來，壞了。

00:03:25.750 --> 00:03:27.510
這時候的問題不是「壞了」。

00:03:27.510 --> 00:03:28.770
壞掉可以修。

00:03:28.770 --> 00:03:31.550
真正的問題是你不知道它剛剛動了哪幾個

00:03:31.550 --> 00:03:34.120
地方，也不知道要退回到哪裡才是好的。

00:03:34.120 --> 00:03:36.510
你連「半小時前」在哪都指不出來。

00:03:36.510 --> 00:03:38.420
所以在事情還正常的時候，

00:03:38.420 --> 00:03:40.440
你要先留一個回得去的點。

00:03:40.440 --> 00:03:41.650
這個動作叫 commit。

00:03:41.650 --> 00:03:43.160
一次 commit 就是一個點。

00:03:43.160 --> 00:03:45.950
它記下這一刻你整個專案長什麼樣子，

00:03:45.950 --> 00:03:47.690
加上你自己寫的一句話：

00:03:47.690 --> 00:03:48.840
「第一版做好了」。

00:03:48.840 --> 00:03:50.220
之後不管 AI 怎麼改，

00:03:50.220 --> 00:03:51.550
你都指得回這個點。

00:03:51.550 --> 00:03:53.210
所以當 AI 問你「要不要

00:03:53.210 --> 00:03:54.200
commit」，

00:03:54.200 --> 00:03:56.030
它在問的是：現在這個狀態，

00:03:56.030 --> 00:03:58.110
值不值得留一個回得去的點？

00:03:58.110 --> 00:03:59.180
判準很簡單：只要

00:03:59.180 --> 00:04:01.890
接下來那件事你不確定會不會壞，就先留。

00:04:01.890 --> 00:04:04.640
要請 AI 動一個你不熟的地方，先留。

00:04:04.640 --> 00:04:06.340
要一次改很多檔案，先留。

00:04:06.340 --> 00:04:08.410
改完覺得可以了，再留一個。

00:04:08.410 --> 00:04:10.500
你不用記指令，只要會講這句話： 

00:04:10.500 --> 00:04:12.900
這一版是好的，先幫我留一個紀錄點，

00:04:12.900 --> 00:04:14.450
說明寫「第一版做好了」。

00:04:14.450 --> 00:04:15.730
做完怎麼確認？

00:04:15.730 --> 00:04:18.370
這裡有第一個陷阱，而且它最不起眼。

00:04:18.370 --> 00:04:19.740
你留的這些點，全部

00:04:19.740 --> 00:04:21.720
都還在你自己這台電腦上。

00:04:21.720 --> 00:04:23.030
回到開頭那些檔名。

00:04:23.030 --> 00:04:25.580
你存了好幾個版本，每一版你都找得到。

00:04:25.580 --> 00:04:27.450
可是對方一份都還沒收到。

00:04:27.450 --> 00:04:29.790
你只是在自己桌上把東西整理好，

00:04:29.790 --> 00:04:31.230
你沒有把它交出去。

00:04:31.230 --> 00:04:32.400
commit 就是這樣。

00:04:32.400 --> 00:04:33.370
它不是上傳。

00:04:33.370 --> 00:04:36.590
這台電腦壞掉，那些點會跟著一起消失。

00:04:36.590 --> 00:04:38.420
所以確認的方式是問它：

00:04:38.420 --> 00:04:40.810
「這些改動現在只在我的電腦上，

00:04:40.810 --> 00:04:42.100
還是已經上去了？

00:04:42.100 --> 00:04:44.600
」那另一半怎麼辦？

00:04:44.600 --> 00:04:46.490
把你電腦上記好的那些點，送到

00:04:46.490 --> 00:04:48.240
GitHub 去，這個動作叫

00:04:48.240 --> 00:04:48.930
push。

00:04:48.930 --> 00:04:50.900
送上去之後你就有了三樣東西：

00:04:50.900 --> 00:04:53.330
一份雲端備份、一個可以給人看的網址、

00:04:53.330 --> 00:04:56.070
還有一份不會因為電腦壞掉而消失的完整

00:04:56.070 --> 00:04:56.470
歷史。

00:04:56.470 --> 00:04:57.840
到這裡都很順。

00:04:57.840 --> 00:05:00.120
但這一段的重點在下一句：

00:05:00.120 --> 00:05:02.500
有些東西不能跟著送上去。

00:05:02.500 --> 00:05:03.890
你請 AI 串一個服務，

00:05:03.890 --> 00:05:05.540
它可能會需要一組金鑰。

00:05:05.540 --> 00:05:07.560
那組金鑰就像你家大門的鑰匙，

00:05:07.560 --> 00:05:10.000
誰拿到誰就能用你的帳號、花你的錢。

00:05:10.000 --> 00:05:13.200
問題是那組金鑰通常就寫在專案的某個檔案

00:05:13.200 --> 00:05:14.630
裡。
你 push 的時候，

00:05:14.630 --> 00:05:16.740
如果沒有特別交代，它會一起上去。

00:05:16.740 --> 00:05:18.540
而 GitHub 上的東西是有紀錄的。

00:05:18.540 --> 00:05:21.330
你把它刪掉，紀錄裡還留著。

00:05:21.330 --> 00:05:23.360
有人專門在掃這種東西，

00:05:23.360 --> 00:05:25.500
而且掃得比你想像中快。

00:05:25.500 --> 00:05:27.810
所以這裡要做一件事：告訴 Git

00:05:27.810 --> 00:05:29.890
哪些檔案不要記帳、不要上傳。

00:05:29.890 --> 00:05:31.880
那份清單叫 .gitignore。

00:05:31.880 --> 00:05:33.130
你可以直接這樣講： 

00:05:33.130 --> 00:05:35.610
幫我檢查一遍：這個專案裡有沒有金鑰、

00:05:35.610 --> 00:05:37.420
密碼這類不該公開的東西？

00:05:37.420 --> 00:05:39.450
有的話幫我設成不要上傳。

00:05:39.450 --> 00:05:40.730
做完怎麼確認？

00:05:40.730 --> 00:05:41.990
打開 GitHub

00:05:41.990 --> 00:05:43.410
上你那個專案的頁面，

00:05:43.410 --> 00:05:45.090
用眼睛看一遍檔案清單。

00:05:45.090 --> 00:05:48.120
這一段值得你親眼看，因為金鑰一旦公開，

00:05:48.120 --> 00:05:50.190
光把檔案刪掉也收不回來。

00:05:50.190 --> 00:05:52.300
而且如果你發現它真的上去了，

00:05:52.300 --> 00:05:54.260
正確的做法不是把紀錄刪掉，

00:05:54.260 --> 00:05:56.150
是立刻去把那把金鑰換掉。

00:05:56.150 --> 00:05:57.260
紀錄可以整理，但

00:05:57.260 --> 00:05:59.320
外流的那幾分鐘裡誰複製走了，

00:05:59.320 --> 00:06:01.020
你不會知道。

00:06:01.020 --> 00:06:03.410
東西上去了，但它還不是「正式版本」。

00:06:03.410 --> 00:06:04.480
GitHub 上

00:06:04.480 --> 00:06:06.430
通常有一份大家公認的正本。

00:06:06.430 --> 00:06:08.230
你送上去的是你自己那一份。

00:06:08.230 --> 00:06:10.790
要讓你的改動變成正本的一部分，

00:06:10.790 --> 00:06:13.640
得先提出來，讓人看過，才會被收進去。

00:06:13.640 --> 00:06:15.040
這個「提出來」叫 PR。

00:06:15.040 --> 00:06:16.910
收進去的那一下叫 merge。

00:06:16.910 --> 00:06:20.080
一個人做專案的時候，這一段常常會被跳過

00:06:20.080 --> 00:06:22.120
，AI 也可能直接幫你合併。

00:06:22.120 --> 00:06:24.580
但只要有第二個人、或第二個 AI

00:06:24.580 --> 00:06:25.800
參與，這一段就是

00:06:25.800 --> 00:06:28.360
你唯一看得到「誰改了什麼」的地方。

00:06:28.360 --> 00:06:29.640
做完怎麼確認？

00:06:29.640 --> 00:06:31.730
這是我踩過最尷尬的一次。

00:06:31.730 --> 00:06:34.320
我們自己的專案裡有一支編號 708

00:06:34.320 --> 00:06:34.910
的提案。

00:06:34.910 --> 00:06:36.830
它被收進去了，正式結案。

00:06:36.830 --> 00:06:38.410
結案之後，同一天晚上，

00:06:38.410 --> 00:06:40.610
我又往同一個地方推了幾次。

00:06:40.610 --> 00:06:43.410
每一次都成功，沒有錯誤訊息，沒有警告，

00:06:43.410 --> 00:06:44.380
什麼都沒有。

00:06:44.380 --> 00:06:46.930
然後我回報：推上 708 了。

00:06:46.930 --> 00:06:48.470
那支提案早就關閉了。

00:06:48.470 --> 00:06:50.700
後面那幾次不屬於任何一個提案，

00:06:50.700 --> 00:06:52.400
永遠不會進到正本裡面。

00:06:52.400 --> 00:06:53.630
推送本來就會成功，

00:06:53.630 --> 00:06:56.250
因為它只負責把東西送到 GitHub，

00:06:56.250 --> 00:06:58.500
不負責判斷「你送的地方還收不收」。

00:06:58.500 --> 00:07:00.330
而 AI 也不會提醒你，

00:07:00.330 --> 00:07:02.960
它照著你說的做，做完回你成功，

00:07:02.960 --> 00:07:05.490
因為對它來說那確實成功了。

00:07:05.490 --> 00:07:07.680
所以確認的方式是多問一句：

00:07:07.680 --> 00:07:09.230
這個提案還開著嗎？

00:07:09.230 --> 00:07:11.420
幫我確認我剛剛推上去的那個 PR

00:07:11.420 --> 00:07:12.540
現在是什麼狀態。

00:07:12.540 --> 00:07:13.720
如果已經 merge

00:07:13.720 --> 00:07:16.720
了，那我後來推的東西是不是還在外面。

00:07:16.720 --> 00:07:18.480
到目前為止都是你一個人。

00:07:18.680 --> 00:07:20.080
很多人在這裡誤會，

00:07:20.080 --> 00:07:22.040
是因為AI回報「已commit」的時候

00:07:22.040 --> 00:07:24.840
，那個語氣聽起來就像事情辦完了。

00:07:24.840 --> 00:07:27.220
它辦完的是一半：在你這裡辦完了。

00:07:27.220 --> 00:07:28.560
所以整條路是四段，

00:07:28.560 --> 00:07:30.860
你記這四段就好：在你電腦上留點，

00:07:30.860 --> 00:07:33.080
送到GitHub，提出來，被收進去。

00:07:33.080 --> 00:07:34.220
只有最後一段完成，

00:07:34.220 --> 00:07:36.460
你的改動才算是正式版本的一部分。

00:07:36.460 --> 00:07:38.980
前面三段做完，東西都還在旁邊等。

00:07:38.980 --> 00:07:40.540
這件事的重點是：

00:07:40.540 --> 00:07:42.820
這個系統在那個情況下不會提醒任何人。

00:07:42.820 --> 00:07:44.700
你不用會判斷，你只要會問。

00:07:44.700 --> 00:07:46.900
現在假設有第二個人要加進來。

00:07:46.900 --> 00:07:49.290
他要先把東西拿到自己電腦上，

00:07:49.290 --> 00:07:52.340
而這件事有兩個名字，差別只在第幾次。

00:07:52.340 --> 00:07:54.500
第一次整包拿走，叫 clone。

00:07:54.500 --> 00:07:57.020
之後每次拿別人的新進度，叫 pull。

00:07:57.020 --> 00:07:59.030
這裡有個很多人會踩的地方：

00:07:59.030 --> 00:08:00.200
第一次拿的時候，

00:08:00.200 --> 00:08:01.800
不要在網頁上按「下載」。

00:08:01.800 --> 00:08:04.070
下載拿到的是一包死檔案，

00:08:04.070 --> 00:08:07.250
沒有紀錄、沒有歷史，改完也送不回去。

00:08:07.250 --> 00:08:08.300
clone 拿到

00:08:08.300 --> 00:08:10.490
的才是連同整本紀錄的完整專案。

00:08:10.490 --> 00:08:13.730
合作的循環就是四步：拉下來、改、留點、

00:08:13.730 --> 00:08:14.630
送上去。

00:08:14.630 --> 00:08:16.740
現在，那個「別人」常常不是人，

00:08:16.740 --> 00:08:18.170
而是另一個 AI。

00:08:18.170 --> 00:08:19.290
而 AI 不會跟

00:08:19.290 --> 00:08:21.810
你說一聲它拉了什麼、改了什麼。

00:08:21.810 --> 00:08:23.630
然後就會遇到最麻煩的那一種：

00:08:23.630 --> 00:08:24.990
兩邊改到同一個地方。

00:08:24.990 --> 00:08:26.830
Git 這時候會停下來，跳出

00:08:26.830 --> 00:08:28.920
conflict，中文叫衝突。

00:08:28.920 --> 00:08:30.250
意思很直白：同一段

00:08:30.250 --> 00:08:32.240
內容出現了兩個不同的版本，

00:08:32.240 --> 00:08:34.990
它不知道該聽誰的，所以它不猜，它問你。

00:08:34.990 --> 00:08:37.630
現在的 AI 遇到衝突通常會自己處理。

00:08:37.630 --> 00:08:39.790
它會看懂兩邊各自想做什麼，

00:08:39.790 --> 00:08:41.940
然後幫你合：有時候是二選一，

00:08:41.940 --> 00:08:43.380
有時候是兩邊都留，

00:08:43.380 --> 00:08:46.430
有時候是乾脆重寫一段把兩邊的功能接

00:08:46.430 --> 00:08:46.890
起來。

00:08:46.890 --> 00:08:48.160
做完怎麼確認？

00:08:48.160 --> 00:08:50.720
這裡是我覺得最值得你記住的一件事。

00:08:50.720 --> 00:08:52.740
AI 卡住的時候其實很安全，

00:08:52.740 --> 00:08:54.350
因為它會停下來問你。

00:08:54.350 --> 00:08:55.880
危險的是它沒有卡住。

00:08:55.880 --> 00:08:58.900
它沒有你的產品規劃，它只看得到程式碼。

00:08:58.900 --> 00:09:00.830
所以它可能很順地選了一邊，

00:09:00.830 --> 00:09:02.600
而那一邊剛好是你不要的，

00:09:02.600 --> 00:09:04.480
然後回你一句「衝突已解決」。

00:09:04.480 --> 00:09:05.910
畫面上什麼警告都沒有。

00:09:05.910 --> 00:09:07.150
所以合併完之後，

00:09:07.150 --> 00:09:09.100
你要問的不是「解決了嗎」，是： 

00:09:09.100 --> 00:09:10.970
這次衝突你是怎麼解的？

00:09:10.970 --> 00:09:12.670
兩邊各自原本想做什麼，

00:09:12.670 --> 00:09:14.310
你留了哪一邊、為什麼？

00:09:14.310 --> 00:09:17.560
重點不是它答不答得出來，是它講的那兩邊

00:09:17.560 --> 00:09:18.930
，你自己各試一次。

00:09:18.930 --> 00:09:21.860
少了一邊，就叫它重做。

00:09:21.860 --> 00:09:24.020
接下來會發生一件很自然的事：

00:09:24.020 --> 00:09:25.450
你會想同時開兩個。

00:09:25.450 --> 00:09:27.550
一個在幫你改版面，你在旁邊等，

00:09:27.550 --> 00:09:30.440
你會想那我為什麼不順便開另一個去處理

00:09:30.440 --> 00:09:30.860
別的。

00:09:30.860 --> 00:09:32.070
問題在於，這兩個

00:09:32.070 --> 00:09:34.320
視窗會直接改同一個資料夾，而

00:09:34.320 --> 00:09:35.450
Git 不會攔。

00:09:35.450 --> 00:09:36.760
剛剛那個衝突警告，

00:09:36.760 --> 00:09:38.990
只在合併兩份紀錄時才會出現。

00:09:38.990 --> 00:09:41.660
同一份東西，兩個人同時在上面動手，

00:09:41.660 --> 00:09:43.720
這件事你在辦公室裡見過。

00:09:43.720 --> 00:09:47.170
兩個人各自打開同一份共用檔案，各自改，

00:09:47.170 --> 00:09:47.880
各自存。

00:09:47.880 --> 00:09:49.020
最後存的那個人，

00:09:49.020 --> 00:09:50.900
蓋掉前一個人的所有修改。

00:09:50.900 --> 00:09:52.710
而前一個人不會收到通知，

00:09:52.710 --> 00:09:55.660
他要到很久以後才會發現自己那半天不見

00:09:55.660 --> 00:09:58.140
了。
在專案裡一樣，只是更難察覺，

00:09:58.140 --> 00:09:59.620
因為兩邊都是 AI，

00:09:59.620 --> 00:10:01.760
它們不會抬頭跟你說一聲。

00:10:01.760 --> 00:10:02.760
這時候 AI 可能

00:10:02.760 --> 00:10:04.440
會問你要不要開一個分支。

00:10:04.440 --> 00:10:06.800
分支的意思是「跟正本隔開來做」，

00:10:06.800 --> 00:10:08.540
改壞了整條丟掉就好。

00:10:08.540 --> 00:10:11.720
那是好東西，但它解決不了現在這個問題。

00:10:11.720 --> 00:10:12.870
因為分支再多，你

00:10:12.870 --> 00:10:15.490
電腦上那個資料夾還是只有一個，兩個

00:10:15.490 --> 00:10:17.720
AI 還是站在同一張桌子前面。

00:10:17.720 --> 00:10:20.650
真正解決這件事的做法只有一個：給第二個

00:10:20.650 --> 00:10:22.050
AI 第二個資料夾。

00:10:22.050 --> 00:10:23.650
這個做法叫 worktree。

00:10:23.650 --> 00:10:25.920
它在你硬碟上多開一個資料夾，

00:10:25.920 --> 00:10:27.310
裝的是同一個專案，

00:10:27.310 --> 00:10:29.160
但跟原本那個各自獨立。

00:10:29.160 --> 00:10:31.480
一個 AI 待一個，互不干擾。

00:10:31.480 --> 00:10:32.760
做完怎麼確認？

00:10:32.760 --> 00:10:34.050
分別問這兩個 AI：

00:10:34.050 --> 00:10:35.600
你現在在哪個資料夾？

00:10:35.600 --> 00:10:38.090
兩個答案不一樣，才是真的分開了。

00:10:38.090 --> 00:10:39.540
沒做到的時候會發生什麼，

00:10:39.540 --> 00:10:41.230
我們是用最貴的方式知道的。

00:10:41.230 --> 00:10:42.870
有一次，我們有兩個 AI

00:10:42.870 --> 00:10:45.490
同時在做事，而它們沒有各自的資料夾，

00:10:45.490 --> 00:10:46.570
用的是同一個。

00:10:46.570 --> 00:10:49.010
其中一個想看「原本的版本長什麼樣」，

00:10:49.010 --> 00:10:50.240
就下了兩道指令。

00:10:50.240 --> 00:10:51.390
這兩道指令，一個

00:10:51.390 --> 00:10:53.460
人單獨工作的時候完全正常。

00:10:53.460 --> 00:10:55.060
你不用會下這兩道指令，

00:10:55.060 --> 00:10:57.770
你只要知道它們做了什麼：把桌面收乾淨，

00:10:57.770 --> 00:10:59.950
然後把資料夾換成另一個版本。

00:10:59.950 --> 00:11:01.710
但那天不是一個人在工作。

00:11:01.710 --> 00:11:04.370
那兩道指令的作用範圍，涵蓋了另一個

00:11:04.370 --> 00:11:06.140
AI還沒有存好的東西。

00:11:06.140 --> 00:11:09.030
大約五百七十行被掃掉了，是另一個 AI

00:11:09.030 --> 00:11:10.660
還沒留下紀錄的工作。

00:11:10.660 --> 00:11:11.670
而它不會報錯。

00:11:11.670 --> 00:11:14.860
指令成功執行，畫面上什麼都沒有。

00:11:14.860 --> 00:11:17.100
要等到另一邊回頭找自己的東西，

00:11:17.100 --> 00:11:17.840
才會發現。

00:11:17.840 --> 00:11:19.000
如果那個人是你，

00:11:19.000 --> 00:11:21.420
你的第一個念頭會是自己記錯了。

00:11:21.420 --> 00:11:23.650
所以這一段你要帶走的只有一句：

00:11:23.650 --> 00:11:24.770
不要讓兩個 AI

00:11:24.770 --> 00:11:26.470
在同一個資料夾裡動手。

00:11:26.470 --> 00:11:28.670
我要同時開兩個來做不同的事，

00:11:28.670 --> 00:11:31.040
幫我各開一個獨立的工作資料夾，

00:11:31.040 --> 00:11:33.630
不要讓它們共用同一個。

00:11:33.630 --> 00:11:36.000
最後講你每天都在怕的那一刻：AI

00:11:36.000 --> 00:11:37.370
真的把東西改壞了。

00:11:37.370 --> 00:11:39.800
分兩種情況，而且分法只有一個問題：

00:11:39.800 --> 00:11:41.350
你有沒有留過點。

00:11:41.350 --> 00:11:42.860
第一種，你還沒留點。

00:11:42.860 --> 00:11:44.570
AI 剛剛改了一堆檔案，

00:11:44.570 --> 00:11:46.040
你跑起來完全不對。

00:11:46.040 --> 00:11:48.190
這時候的動作叫 restore，

00:11:48.190 --> 00:11:50.950
意思是把這些還沒留過點的改動全部丟掉，

00:11:50.950 --> 00:11:51.970
回到上一個點。

00:11:51.970 --> 00:11:53.900
就當剛剛那半小時沒發生過。

00:11:53.900 --> 00:11:55.750
第二種，你已經留過點了，

00:11:55.750 --> 00:11:57.890
而且是那個點本身有問題。

00:11:57.890 --> 00:12:00.050
這時候比較安全的做法叫 revert。

00:12:00.050 --> 00:12:02.410
它不是把歷史刪掉，是再記一筆，

00:12:02.410 --> 00:12:04.510
內容是把前面那筆抵消掉。

00:12:04.510 --> 00:12:05.720
為什麼要繞這一圈？

00:12:05.720 --> 00:12:07.200
因為直接刪掉歷史的話，

00:12:07.200 --> 00:12:09.420
跟你一起做的人手上版本會對不上，

00:12:09.420 --> 00:12:11.290
而且他不會知道發生過什麼。

00:12:11.290 --> 00:12:14.650
多記一筆抵消，所有人都看得到「加錯了、

00:12:14.650 --> 00:12:16.020
然後被抵消了」。

00:12:16.020 --> 00:12:17.840
這兩個你都不用記，你只要說： 

00:12:17.840 --> 00:12:19.510
剛剛這次的改動我不要了，

00:12:19.510 --> 00:12:21.590
請幫我回到上一個正常的版本。

00:12:21.590 --> 00:12:23.550
AI 會自己看現在的狀態，

00:12:23.550 --> 00:12:24.900
決定該用哪一個。

00:12:24.900 --> 00:12:26.180
做完怎麼確認？

00:12:26.180 --> 00:12:29.340
這裡有兩件事是我覺得沒有人會先告訴你

00:12:29.340 --> 00:12:31.570
的。
第一，restore 是不可逆的。

00:12:31.570 --> 00:12:33.500
它丟掉的東西沒有回收桶。

00:12:33.500 --> 00:12:35.300
不像刪檔案還能去垃圾桶撿，

00:12:35.300 --> 00:12:37.240
那些改動是真的消失了，Git

00:12:37.240 --> 00:12:38.740
裡面任何地方都找不到，

00:12:38.740 --> 00:12:40.780
因為它們從來沒有被記下來過。

00:12:40.780 --> 00:12:42.780
剛剛那五百七十行其實不是這一種。

00:12:42.780 --> 00:12:44.140
那次是被暫時收起來，

00:12:44.140 --> 00:12:45.960
還找得回來；restore

00:12:45.960 --> 00:12:47.890
丟掉的才是真的沒有回收桶。

00:12:47.890 --> 00:12:49.540
但兩次的傷害是同一種：

00:12:49.540 --> 00:12:51.530
做那件事的不是壞掉的程式，

00:12:51.530 --> 00:12:53.010
是收東西的動作本身，

00:12:53.010 --> 00:12:54.930
而你不會知道要去哪裡找。

00:12:54.930 --> 00:12:57.310
所以在說「回到上一個正常版本」之前，

00:12:57.310 --> 00:12:58.260
值得多問一句： 

00:12:58.260 --> 00:13:00.900
這個動作會丟掉哪些還沒記錄的改動？

00:13:00.900 --> 00:13:01.680
先列給我看。

00:13:01.680 --> 00:13:04.030
第二件是他們很少講的第三種情況：

00:13:04.030 --> 00:13:05.380
東西已經送出去了。

00:13:05.380 --> 00:13:07.580
這時候光救你自己的電腦沒有用，要連

00:13:07.580 --> 00:13:09.610
GitHub 上那一份一起處理。

00:13:09.610 --> 00:13:12.100
你問 AI 的時候要把這件事講出來：

00:13:12.100 --> 00:13:13.920
「這批改動我已經推上去了，

00:13:13.920 --> 00:13:14.920
也要一起處理。

00:13:14.920 --> 00:13:16.590
」所以這一章的判準是：

00:13:16.590 --> 00:13:18.500
在說「回到上一個版本」之前，

00:13:18.500 --> 00:13:20.800
先問它會丟掉什麼。

00:13:20.800 --> 00:13:23.110
救回來之後還有最後一件事，

00:13:23.110 --> 00:13:25.040
而且跟前面幾章不一樣：

00:13:25.040 --> 00:13:28.130
前面都是事情沒到，這次是事情做到了，

00:13:28.130 --> 00:13:29.190
但份量不對。

00:13:29.190 --> 00:13:31.260
這是我踩過最容易被騙的一次。

00:13:31.260 --> 00:13:34.280
有一次我叫 AI 算給我看它改了多少。

00:13:34.280 --> 00:13:37.120
它回我：刪掉兩千六百二十一行。

00:13:37.120 --> 00:13:38.260
兩千六百多行。

00:13:38.260 --> 00:13:40.820
而我心裡預期的是幾十行。

00:13:40.820 --> 00:13:42.710
我們當時真的停下來查了。

00:13:42.710 --> 00:13:45.170
實際上那次刪掉的是三十行。

00:13:45.170 --> 00:13:47.400
比對兩個版本有兩種算法。

00:13:47.400 --> 00:13:49.560
一種是拿兩邊現在的樣子直接比。

00:13:49.560 --> 00:13:52.000
另一種是先回到你們還一樣的時候，

00:13:52.000 --> 00:13:54.050
再從那裡往後算你改了什麼。

00:13:54.050 --> 00:13:56.250
當你這一份比正本少了幾次更新，

00:13:56.250 --> 00:13:58.930
第一種算法會把別人後來加進去的東西，

00:13:58.930 --> 00:14:00.290
全部算成你刪掉的。

00:14:00.290 --> 00:14:03.200
你手上沒有，於是它就被記成你刪的。

00:14:03.200 --> 00:14:04.050
而你看不出來。

00:14:04.050 --> 00:14:06.510
兩個數字長得一模一樣，都是「刪掉 N

00:14:06.510 --> 00:14:08.800
行」，沒有任何東西告訴你這兩個 N

00:14:08.800 --> 00:14:09.730
的意思不同。

00:14:09.730 --> 00:14:12.000
判準是最好記的一個：不要自己算，看

00:14:12.000 --> 00:14:14.220
GitHub 自己算的那個數字。

00:14:14.220 --> 00:14:15.300
GitHub 在

00:14:15.300 --> 00:14:17.460
每一個提案上都會顯示改了多少，

00:14:17.460 --> 00:14:20.020
那個數字用的是第二種算法，是權威值。

00:14:20.020 --> 00:14:22.260
這個 PR 在 GitHub

00:14:22.260 --> 00:14:25.200
上顯示的新增跟刪除行數是多少？

00:14:25.200 --> 00:14:27.290
跟我預期改的份量對不對得上？

00:14:27.290 --> 00:14:28.100
對得上就過。

00:14:28.100 --> 00:14:30.590
對不上，那才是真的要查的時候。

00:14:30.590 --> 00:14:32.940
你不用背數字，你只要拿它報的份量，

00:14:32.940 --> 00:14:34.760
跟你交代它做的事比一下。

00:14:34.760 --> 00:14:37.910
明顯不成比例，就值得問一句。

00:14:37.910 --> 00:14:39.260
AI 問你的那幾句話，

00:14:39.260 --> 00:14:40.700
你現在都答得出來了。

00:14:40.920 --> 00:14:41.900
AI沒有騙你。

00:14:41.900 --> 00:14:43.360
那兩種算法都是對的，

00:14:43.360 --> 00:14:45.000
它們回答的是不同的問題。

00:14:45.000 --> 00:14:46.880
AI挑了比較常見的那一種，

00:14:46.880 --> 00:14:48.740
而它不知道你要問的是另一個。

00:14:48.740 --> 00:14:50.440
其實這支片講的三次，

00:14:50.440 --> 00:14:53.420
全部是同一個形狀：沒有一次是AI亂來，

00:14:53.420 --> 00:14:56.000
每一次都是它做的事情跟你以為它在做的

00:14:56.000 --> 00:14:57.770
事情，中間差了一層。

00:14:57.770 --> 00:14:59.080
要不要 commit，

00:14:59.080 --> 00:15:01.370
問的是值不值得留一個回得去的點。

00:15:01.370 --> 00:15:02.480
要不要開分支，問

00:15:02.480 --> 00:15:04.480
的是要不要跟正本隔開來做。

00:15:04.480 --> 00:15:05.540
要不要發 PR，

00:15:05.540 --> 00:15:07.590
問的是要不要正式提出去。

00:15:07.590 --> 00:15:09.660
但我更想留給你的是另一半。

00:15:09.660 --> 00:15:12.410
這支片每一個動作我都多講了一句「做完

00:15:12.410 --> 00:15:13.390
怎麼確認」，因為

00:15:13.390 --> 00:15:15.660
那才是這套工具對你真正的用處： 

00:15:15.660 --> 00:15:18.510
東西是還在我電腦上，還是已經送出去了？

00:15:18.510 --> 00:15:20.670
我送去的那個地方，還收不收？

00:15:20.670 --> 00:15:23.140
兩個 AI 有沒有共用同一個資料夾？

00:15:23.140 --> 00:15:25.690
它給我的份量，跟我以為的對得上嗎？

00:15:25.690 --> 00:15:28.530
四個問題，你不用會做，你只要會問。

00:15:28.530 --> 00:15:30.100
對不寫程式的人來說，

00:15:30.100 --> 00:15:33.230
版本控制真正的價值不是多學會一個工具，

00:15:33.230 --> 00:15:35.930
是它把 AI 做的事情變成看得見的。

00:15:35.930 --> 00:15:38.610
在那之前，AI 說完成了你只能相信；

00:15:38.610 --> 00:15:40.320
有了之後，你可以去看。

00:15:40.320 --> 00:15:43.350
而這個差別會決定你敢不敢把更大的事情

00:15:43.350 --> 00:15:43.960
交出去。

00:15:43.960 --> 00:15:45.180
你敢交，是因為你

00:15:45.180 --> 00:15:47.550
知道出事了退得回來、看得出來。

00:15:47.550 --> 00:15:49.840
這才是時間真正省下來的地方。

00:15:49.840 --> 00:15:52.280
你不會因為看完這支影片就不再踩到，

00:15:52.280 --> 00:15:53.440
我到現在還是會。

00:15:53.440 --> 00:15:55.670
差別在於現在我知道要去哪裡看。

00:15:55.670 --> 00:15:57.610
如果你想把這幾個檢查變成習慣，

00:15:57.610 --> 00:16:00.110
我在免費社群裡整理了一份可以直接貼給

00:16:00.110 --> 00:16:01.080
AI 的檢查清單，

00:16:01.080 --> 00:16:02.980
就是這支影片講的這四個問題。

00:16:02.980 --> 00:16:04.410
連結在資訊欄，網址是

00:16:04.410 --> 00:16:05.680
guccidgi.

00:16:05.680 --> 00:16:07.210
com/aifree。

00:16:07.210 --> 00:16:09.640
不過在你去看之前，先做一件事。

00:16:09.640 --> 00:16:11.170
打開你手邊那個 AI

00:16:11.170 --> 00:16:12.700
幫你做到一半的東西，

00:16:12.700 --> 00:16:15.590
問它一句：這些改動現在只在我的電腦上，

00:16:15.590 --> 00:16:16.880
還是已經上去了？

00:16:16.880 --> 00:16:17.730
那一次就夠了。

00:16:17.730 --> 00:16:19.330
你會知道我在講什麼。