0:00.000–0:02.960
zh你的電腦裡有沒有這種檔案：
0:02.960–0:05.670
zh提案_最終版、提案_最終版2、
0:05.670–0:07.240
zh提案_這版才對。
0:07.240–0:09.930
zh如果有，那你其實已經在做版本控制了。
0:09.930–0:12.450
zh只是用的是最痛苦的做法：
0:12.450–0:14.730
zh靠檔名，靠記憶，靠運氣。
0:14.730–0:16.700
zh工程師二十年前就受不了了，
0:16.700–0:19.010
zh做了一套工具解決它：那套工具叫
0:19.010–0:21.580
zhGit，存放的地方叫 GitHub。
0:21.580–0:23.960
zhGitHub 你可能點進去過一次，
0:23.960–0:25.230
zh然後就關掉了，因為
0:25.230–0:27.080
zh那看起來是工程師的地方。
0:27.080–0:28.950
zh但如果你最近開始用 AI
0:28.950–0:31.770
zh幫你做東西，那個地方遲早會變成你的。
0:31.770–0:34.400
zh不是因為你要變成工程師，是因為 AI
0:34.400–0:37.350
zh一次改的東西比你多得多，你需要一個地方
0:37.350–0:38.760
zh，讓你做壞了回得去。
0:38.760–0:40.670
zh這支影片用一條線串起來，
0:40.670–0:43.460
zh從你做出第一個東西，到你同時開兩個
0:43.460–0:44.600
zhAI 幫你做事。
0:44.600–0:46.120
zh每個名詞出現之前，
0:46.120–0:48.300
zh我會先讓你遇到那個問題。
0:48.300–0:50.550
zh而且每一個動作我都會多講一句：
0:50.550–0:53.050
zh做完之後，你怎麼確認它真的做到了。
0:53.050–0:55.400
zh因為這一年我自己踩過三次，
0:55.400–0:57.360
zh每一次都是它做的事情，
0:57.360–1:00.600
zh跟我以為它在做的事情，中間差了一層。
1:00.600–1:01.570
zh我們直接開始。
1:02.370–1:05.160
zh如果你還不認識我，我是 Gucci。
1:05.160–1:07.880
zh我曾經是全球前三大記憶體廠的大數據
1:07.880–1:10.920
zh工程師，2019 年放棄年薪近兩百萬，
1:10.920–1:11.720
zh全職創業。
1:11.720–1:14.580
zh去年，我的線上事業收入 440 萬。
1:14.580–1:17.160
zh一年多前，我帶著老婆和剛滿 3
1:17.160–1:19.930
zh歲的女兒開始旅居世界——不是度假，
1:19.930–1:22.110
zh我照常工作，女兒照常上學，
1:22.110–1:23.870
zh世界就是她的課本。
1:23.870–1:27.140
zh從峇里島、清邁到檳城，支撐這種日子的，
1:27.140–1:28.370
zh就是槓桿 AI：
1:28.370–1:31.030
zh用更少的工時，把生活還給家人。
1:31.030–1:32.830
zh好，回到今天的主題。
1:32.840–1:35.160
zh假設你請 AI 幫你做一個東西。
1:35.160–1:37.900
zh一頁網站也好，一個會自己跑的小工具也好
1:37.900–1:39.980
zh，或是一份自動整理資料的表格。
1:39.980–1:42.960
zh過了半小時，它做出來了，打得開。
1:42.960–1:45.780
zh第一個問題馬上來了：這東西現在在哪裡？
1:45.780–1:48.250
zh它在你的電腦裡，某個資料夾。
1:48.250–1:51.140
zh這代表三件事：換一台電腦你就沒有它了、
1:51.140–1:52.670
zh電腦壞了它跟著沒了、
1:52.670–1:55.330
zh想給朋友看你只能整包壓縮寄過去。
1:55.330–1:57.590
zh所以你需要一個雲端的地方。
1:57.590–1:58.520
zh你可能會想，那用
1:58.520–2:00.880
zhGoogle Drive 不就好了？
2:00.880–2:01.440
zh不行。
2:01.440–2:03.730
zh而原因就是這支影片的第一個重點。
2:03.730–2:05.600
zh還記得開頭那幾個檔名嗎？
2:05.600–2:06.770
zh你為什麼要留那些版本？
2:06.770–2:08.230
zh不是因為你愛整理檔案，
2:08.230–2:09.680
zh是因為你知道會有一刻，
2:09.680–2:11.230
zh你想回到昨天那個版本。
2:11.230–2:13.020
zh程式比報告更需要這件事，
2:13.020–2:14.900
zh因為改壞的機會高太多了。
2:14.900–2:16.680
zh所以放程式的那個地方，
2:16.680–2:18.280
zh不能只是把檔案收好，
2:18.280–2:21.230
zh它還要記得每一次改了什麼、為什麼改。
2:21.230–2:22.500
enGoogle Drive
2:22.500–2:23.300
zh只做前面那半。
2:23.300–2:25.830
zh做後面那半的，是今天的第一個名詞：
2:25.830–2:26.440
enGit。
2:26.440–2:29.320
zhGit 是一個裝在你電腦裡的程式。
2:29.320–2:31.230
zh它只管一件事：你每存一次，
2:31.230–2:34.170
zh它就記下這一刻整個資料夾長什麼樣子，
2:34.170–2:36.170
zh還有你留給自己的一句話。
2:36.170–2:38.450
zh它從頭到尾都在你的機器上跑，
2:38.450–2:39.770
zh沒有網路也能用。
2:39.770–2:41.880
zh而 GitHub 是網路上的一個網站，
2:41.880–2:43.830
zh專門放這種有版本紀錄的資料夾。
2:43.830–2:46.710
zh這兩個名字只差三個字母，是兩個東西。
2:46.710–2:48.750
zh一個在你電腦裡管紀錄，
2:48.750–2:51.500
zh一個在網路上管存放跟給人看。
2:51.500–2:52.220
zh怎麼開始？
2:52.220–2:53.550
zh你不用學指令。
2:53.550–2:54.820
zh不過下面每一句話，
2:54.820–2:57.360
zh都要說給能直接動你電腦檔案的 AI
2:57.360–2:58.890
zh聽，像 Codex 這種。
2:58.890–3:01.970
zh貼進一般聊天視窗，它只會教你怎麼做，
3:01.970–3:03.220
zh不會真的去做。
3:03.220–3:05.230
zh幫我把這個資料夾建立版本紀錄，
3:05.230–3:07.190
zh之後我要放到 GitHub 上。
3:07.190–3:08.470
zh做完怎麼確認？
3:08.470–3:09.540
zh請 AI 檢查這個
3:09.540–3:11.220
zh資料夾有沒有開始記版本，
3:11.220–3:13.160
zh並把它查到的結果貼給你看。
3:13.160–3:15.190
zh不要特地去找那個叫 .git
3:15.190–3:17.220
zh的資料夾，它預設是藏起來的，
3:17.220–3:19.140
zh看不到很正常。
3:19.140–3:21.430
zhGit 裝好了，但它不會自己動。
3:21.430–3:23.230
zh你請 AI 加一個新功能，
3:23.230–3:24.770
zh它動了七八個檔案。
3:24.770–3:25.750
zh跑起來，壞了。
3:25.750–3:27.510
zh這時候的問題不是「壞了」。
3:27.510–3:28.770
zh壞掉可以修。
3:28.770–3:31.550
zh真正的問題是你不知道它剛剛動了哪幾個
3:31.550–3:34.120
zh地方，也不知道要退回到哪裡才是好的。
3:34.120–3:36.510
zh你連「半小時前」在哪都指不出來。
3:36.510–3:38.420
zh所以在事情還正常的時候，
3:38.420–3:40.440
zh你要先留一個回得去的點。
3:40.440–3:41.650
zh這個動作叫 commit。
3:41.650–3:43.160
zh一次 commit 就是一個點。
3:43.160–3:45.950
zh它記下這一刻你整個專案長什麼樣子，
3:45.950–3:47.690
zh加上你自己寫的一句話：
3:47.690–3:48.840
zh「第一版做好了」。
3:48.840–3:50.220
zh之後不管 AI 怎麼改，
3:50.220–3:51.550
zh你都指得回這個點。
3:51.550–3:53.210
zh所以當 AI 問你「要不要
3:53.210–3:54.200
encommit」，
3:54.200–3:56.030
zh它在問的是：現在這個狀態，
3:56.030–3:58.110
zh值不值得留一個回得去的點？
3:58.110–3:59.180
zh判準很簡單：只要
3:59.180–4:01.890
zh接下來那件事你不確定會不會壞，就先留。
4:01.890–4:04.640
zh要請 AI 動一個你不熟的地方，先留。
4:04.640–4:06.340
zh要一次改很多檔案，先留。
4:06.340–4:08.410
zh改完覺得可以了，再留一個。
4:08.410–4:10.500
zh你不用記指令，只要會講這句話：
4:10.500–4:12.900
zh這一版是好的，先幫我留一個紀錄點，
4:12.900–4:14.450
zh說明寫「第一版做好了」。
4:14.450–4:15.730
zh做完怎麼確認？
4:15.730–4:18.370
zh這裡有第一個陷阱，而且它最不起眼。
4:18.370–4:19.740
zh你留的這些點，全部
4:19.740–4:21.720
zh都還在你自己這台電腦上。
4:21.720–4:23.030
zh回到開頭那些檔名。
4:23.030–4:25.580
zh你存了好幾個版本，每一版你都找得到。
4:25.580–4:27.450
zh可是對方一份都還沒收到。
4:27.450–4:29.790
zh你只是在自己桌上把東西整理好，
4:29.790–4:31.230
zh你沒有把它交出去。
4:31.230–4:32.400
zhcommit 就是這樣。
4:32.400–4:33.370
zh它不是上傳。
4:33.370–4:36.590
zh這台電腦壞掉，那些點會跟著一起消失。
4:36.590–4:38.420
zh所以確認的方式是問它：
4:38.420–4:40.810
zh「這些改動現在只在我的電腦上，
4:40.810–4:42.100
zh還是已經上去了？
4:42.100–4:44.600
zh」那另一半怎麼辦？
4:44.600–4:46.490
zh把你電腦上記好的那些點，送到
4:46.490–4:48.240
zhGitHub 去，這個動作叫
4:48.240–4:48.930
enpush。
4:48.930–4:50.900
zh送上去之後你就有了三樣東西：
4:50.900–4:53.330
zh一份雲端備份、一個可以給人看的網址、
4:53.330–4:56.070
zh還有一份不會因為電腦壞掉而消失的完整
4:56.070–4:56.470
zh歷史。
4:56.470–4:57.840
zh到這裡都很順。
4:57.840–5:00.120
zh但這一段的重點在下一句：
5:00.120–5:02.500
zh有些東西不能跟著送上去。
5:02.500–5:03.890
zh你請 AI 串一個服務，
5:03.890–5:05.540
zh它可能會需要一組金鑰。
5:05.540–5:07.560
zh那組金鑰就像你家大門的鑰匙，
5:07.560–5:10.000
zh誰拿到誰就能用你的帳號、花你的錢。
5:10.000–5:13.200
zh問題是那組金鑰通常就寫在專案的某個檔案
5:13.200–5:14.630
zh裡。 你 push 的時候，
5:14.630–5:16.740
zh如果沒有特別交代，它會一起上去。
5:16.740–5:18.540
zh而 GitHub 上的東西是有紀錄的。
5:18.540–5:21.330
zh你把它刪掉，紀錄裡還留著。
5:21.330–5:23.360
zh有人專門在掃這種東西，
5:23.360–5:25.500
zh而且掃得比你想像中快。
5:25.500–5:27.810
zh所以這裡要做一件事：告訴 Git
5:27.810–5:29.890
zh哪些檔案不要記帳、不要上傳。
5:29.890–5:31.880
zh那份清單叫 .gitignore。
5:31.880–5:33.130
zh你可以直接這樣講：
5:33.130–5:35.610
zh幫我檢查一遍：這個專案裡有沒有金鑰、
5:35.610–5:37.420
zh密碼這類不該公開的東西？
5:37.420–5:39.450
zh有的話幫我設成不要上傳。
5:39.450–5:40.730
zh做完怎麼確認？
5:40.730–5:41.990
zh打開 GitHub
5:41.990–5:43.410
zh上你那個專案的頁面，
5:43.410–5:45.090
zh用眼睛看一遍檔案清單。
5:45.090–5:48.120
zh這一段值得你親眼看，因為金鑰一旦公開，
5:48.120–5:50.190
zh光把檔案刪掉也收不回來。
5:50.190–5:52.300
zh而且如果你發現它真的上去了，
5:52.300–5:54.260
zh正確的做法不是把紀錄刪掉，
5:54.260–5:56.150
zh是立刻去把那把金鑰換掉。
5:56.150–5:57.260
zh紀錄可以整理，但
5:57.260–5:59.320
zh外流的那幾分鐘裡誰複製走了，
5:59.320–6:01.020
zh你不會知道。
6:01.020–6:03.410
zh東西上去了，但它還不是「正式版本」。
6:03.410–6:04.480
zhGitHub 上
6:04.480–6:06.430
zh通常有一份大家公認的正本。
6:06.430–6:08.230
zh你送上去的是你自己那一份。
6:08.230–6:10.790
zh要讓你的改動變成正本的一部分，
6:10.790–6:13.640
zh得先提出來，讓人看過，才會被收進去。
6:13.640–6:15.040
zh這個「提出來」叫 PR。
6:15.040–6:16.910
zh收進去的那一下叫 merge。
6:16.910–6:20.080
zh一個人做專案的時候，這一段常常會被跳過
6:20.080–6:22.120
zh，AI 也可能直接幫你合併。
6:22.120–6:24.580
zh但只要有第二個人、或第二個 AI
6:24.580–6:25.800
zh參與，這一段就是
6:25.800–6:28.360
zh你唯一看得到「誰改了什麼」的地方。
6:28.360–6:29.640
zh做完怎麼確認？
6:29.640–6:31.730
zh這是我踩過最尷尬的一次。
6:31.730–6:34.320
zh我們自己的專案裡有一支編號 708
6:34.320–6:34.910
zh的提案。
6:34.910–6:36.830
zh它被收進去了，正式結案。
6:36.830–6:38.410
zh結案之後，同一天晚上，
6:38.410–6:40.610
zh我又往同一個地方推了幾次。
6:40.610–6:43.410
zh每一次都成功，沒有錯誤訊息，沒有警告，
6:43.410–6:44.380
zh什麼都沒有。
6:44.380–6:46.930
zh然後我回報：推上 708 了。
6:46.930–6:48.470
zh那支提案早就關閉了。
6:48.470–6:50.700
zh後面那幾次不屬於任何一個提案，
6:50.700–6:52.400
zh永遠不會進到正本裡面。
6:52.400–6:53.630
zh推送本來就會成功，
6:53.630–6:56.250
zh因為它只負責把東西送到 GitHub，
6:56.250–6:58.500
zh不負責判斷「你送的地方還收不收」。
6:58.500–7:00.330
zh而 AI 也不會提醒你，
7:00.330–7:02.960
zh它照著你說的做，做完回你成功，
7:02.960–7:05.490
zh因為對它來說那確實成功了。
7:05.490–7:07.680
zh所以確認的方式是多問一句：
7:07.680–7:09.230
zh這個提案還開著嗎？
7:09.230–7:11.420
zh幫我確認我剛剛推上去的那個 PR
7:11.420–7:12.540
zh現在是什麼狀態。
7:12.540–7:13.720
zh如果已經 merge
7:13.720–7:16.720
zh了，那我後來推的東西是不是還在外面。
7:16.720–7:18.480
zh到目前為止都是你一個人。
7:18.680–7:20.080
zh很多人在這裡誤會，
7:20.080–7:22.040
zh是因為AI回報「已commit」的時候
7:22.040–7:24.840
zh，那個語氣聽起來就像事情辦完了。
7:24.840–7:27.220
zh它辦完的是一半：在你這裡辦完了。
7:27.220–7:28.560
zh所以整條路是四段，
7:28.560–7:30.860
zh你記這四段就好：在你電腦上留點，
7:30.860–7:33.080
zh送到GitHub，提出來，被收進去。
7:33.080–7:34.220
zh只有最後一段完成，
7:34.220–7:36.460
zh你的改動才算是正式版本的一部分。
7:36.460–7:38.980
zh前面三段做完，東西都還在旁邊等。
7:38.980–7:40.540
zh這件事的重點是：
7:40.540–7:42.820
zh這個系統在那個情況下不會提醒任何人。
7:42.820–7:44.700
zh你不用會判斷，你只要會問。
7:44.700–7:46.900
zh現在假設有第二個人要加進來。
7:46.900–7:49.290
zh他要先把東西拿到自己電腦上，
7:49.290–7:52.340
zh而這件事有兩個名字，差別只在第幾次。
7:52.340–7:54.500
zh第一次整包拿走，叫 clone。
7:54.500–7:57.020
zh之後每次拿別人的新進度，叫 pull。
7:57.020–7:59.030
zh這裡有個很多人會踩的地方：
7:59.030–8:00.200
zh第一次拿的時候，
8:00.200–8:01.800
zh不要在網頁上按「下載」。
8:01.800–8:04.070
zh下載拿到的是一包死檔案，
8:04.070–8:07.250
zh沒有紀錄、沒有歷史，改完也送不回去。
8:07.250–8:08.300
zhclone 拿到
8:08.300–8:10.490
zh的才是連同整本紀錄的完整專案。
8:10.490–8:13.730
zh合作的循環就是四步：拉下來、改、留點、
8:13.730–8:14.630
zh送上去。
8:14.630–8:16.740
zh現在，那個「別人」常常不是人，
8:16.740–8:18.170
zh而是另一個 AI。
8:18.170–8:19.290
zh而 AI 不會跟
8:19.290–8:21.810
zh你說一聲它拉了什麼、改了什麼。
8:21.810–8:23.630
zh然後就會遇到最麻煩的那一種：
8:23.630–8:24.990
zh兩邊改到同一個地方。
8:24.990–8:26.830
zhGit 這時候會停下來，跳出
8:26.830–8:28.920
zhconflict，中文叫衝突。
8:28.920–8:30.250
zh意思很直白：同一段
8:30.250–8:32.240
zh內容出現了兩個不同的版本，
8:32.240–8:34.990
zh它不知道該聽誰的，所以它不猜，它問你。
8:34.990–8:37.630
zh現在的 AI 遇到衝突通常會自己處理。
8:37.630–8:39.790
zh它會看懂兩邊各自想做什麼，
8:39.790–8:41.940
zh然後幫你合：有時候是二選一，
8:41.940–8:43.380
zh有時候是兩邊都留，
8:43.380–8:46.430
zh有時候是乾脆重寫一段把兩邊的功能接
8:46.430–8:46.890
zh起來。
8:46.890–8:48.160
zh做完怎麼確認？
8:48.160–8:50.720
zh這裡是我覺得最值得你記住的一件事。
8:50.720–8:52.740
zhAI 卡住的時候其實很安全，
8:52.740–8:54.350
zh因為它會停下來問你。
8:54.350–8:55.880
zh危險的是它沒有卡住。
8:55.880–8:58.900
zh它沒有你的產品規劃，它只看得到程式碼。
8:58.900–9:00.830
zh所以它可能很順地選了一邊，
9:00.830–9:02.600
zh而那一邊剛好是你不要的，
9:02.600–9:04.480
zh然後回你一句「衝突已解決」。
9:04.480–9:05.910
zh畫面上什麼警告都沒有。
9:05.910–9:07.150
zh所以合併完之後，
9:07.150–9:09.100
zh你要問的不是「解決了嗎」，是：
9:09.100–9:10.970
zh這次衝突你是怎麼解的？
9:10.970–9:12.670
zh兩邊各自原本想做什麼，
9:12.670–9:14.310
zh你留了哪一邊、為什麼？
9:14.310–9:17.560
zh重點不是它答不答得出來，是它講的那兩邊
9:17.560–9:18.930
zh，你自己各試一次。
9:18.930–9:21.860
zh少了一邊，就叫它重做。
9:21.860–9:24.020
zh接下來會發生一件很自然的事：
9:24.020–9:25.450
zh你會想同時開兩個。
9:25.450–9:27.550
zh一個在幫你改版面，你在旁邊等，
9:27.550–9:30.440
zh你會想那我為什麼不順便開另一個去處理
9:30.440–9:30.860
zh別的。
9:30.860–9:32.070
zh問題在於，這兩個
9:32.070–9:34.320
zh視窗會直接改同一個資料夾，而
9:34.320–9:35.450
zhGit 不會攔。
9:35.450–9:36.760
zh剛剛那個衝突警告，
9:36.760–9:38.990
zh只在合併兩份紀錄時才會出現。
9:38.990–9:41.660
zh同一份東西，兩個人同時在上面動手，
9:41.660–9:43.720
zh這件事你在辦公室裡見過。
9:43.720–9:47.170
zh兩個人各自打開同一份共用檔案，各自改，
9:47.170–9:47.880
zh各自存。
9:47.880–9:49.020
zh最後存的那個人，
9:49.020–9:50.900
zh蓋掉前一個人的所有修改。
9:50.900–9:52.710
zh而前一個人不會收到通知，
9:52.710–9:55.660
zh他要到很久以後才會發現自己那半天不見
9:55.660–9:58.140
zh了。 在專案裡一樣，只是更難察覺，
9:58.140–9:59.620
zh因為兩邊都是 AI，
9:59.620–10:01.760
zh它們不會抬頭跟你說一聲。
10:01.760–10:02.760
zh這時候 AI 可能
10:02.760–10:04.440
zh會問你要不要開一個分支。
10:04.440–10:06.800
zh分支的意思是「跟正本隔開來做」，
10:06.800–10:08.540
zh改壞了整條丟掉就好。
10:08.540–10:11.720
zh那是好東西，但它解決不了現在這個問題。
10:11.720–10:12.870
zh因為分支再多，你
10:12.870–10:15.490
zh電腦上那個資料夾還是只有一個，兩個
10:15.490–10:17.720
zhAI 還是站在同一張桌子前面。
10:17.720–10:20.650
zh真正解決這件事的做法只有一個：給第二個
10:20.650–10:22.050
zhAI 第二個資料夾。
10:22.050–10:23.650
zh這個做法叫 worktree。
10:23.650–10:25.920
zh它在你硬碟上多開一個資料夾，
10:25.920–10:27.310
zh裝的是同一個專案，
10:27.310–10:29.160
zh但跟原本那個各自獨立。
10:29.160–10:31.480
zh一個 AI 待一個，互不干擾。
10:31.480–10:32.760
zh做完怎麼確認？
10:32.760–10:34.050
zh分別問這兩個 AI：
10:34.050–10:35.600
zh你現在在哪個資料夾？
10:35.600–10:38.090
zh兩個答案不一樣，才是真的分開了。
10:38.090–10:39.540
zh沒做到的時候會發生什麼，
10:39.540–10:41.230
zh我們是用最貴的方式知道的。
10:41.230–10:42.870
zh有一次，我們有兩個 AI
10:42.870–10:45.490
zh同時在做事，而它們沒有各自的資料夾，
10:45.490–10:46.570
zh用的是同一個。
10:46.570–10:49.010
zh其中一個想看「原本的版本長什麼樣」，
10:49.010–10:50.240
zh就下了兩道指令。
10:50.240–10:51.390
zh這兩道指令，一個
10:51.390–10:53.460
zh人單獨工作的時候完全正常。
10:53.460–10:55.060
zh你不用會下這兩道指令，
10:55.060–10:57.770
zh你只要知道它們做了什麼：把桌面收乾淨，
10:57.770–10:59.950
zh然後把資料夾換成另一個版本。
10:59.950–11:01.710
zh但那天不是一個人在工作。
11:01.710–11:04.370
zh那兩道指令的作用範圍，涵蓋了另一個
11:04.370–11:06.140
zhAI還沒有存好的東西。
11:06.140–11:09.030
zh大約五百七十行被掃掉了，是另一個 AI
11:09.030–11:10.660
zh還沒留下紀錄的工作。
11:10.660–11:11.670
zh而它不會報錯。
11:11.670–11:14.860
zh指令成功執行，畫面上什麼都沒有。
11:14.860–11:17.100
zh要等到另一邊回頭找自己的東西，
11:17.100–11:17.840
zh才會發現。
11:17.840–11:19.000
zh如果那個人是你，
11:19.000–11:21.420
zh你的第一個念頭會是自己記錯了。
11:21.420–11:23.650
zh所以這一段你要帶走的只有一句：
11:23.650–11:24.770
zh不要讓兩個 AI
11:24.770–11:26.470
zh在同一個資料夾裡動手。
11:26.470–11:28.670
zh我要同時開兩個來做不同的事，
11:28.670–11:31.040
zh幫我各開一個獨立的工作資料夾，
11:31.040–11:33.630
zh不要讓它們共用同一個。
11:33.630–11:36.000
zh最後講你每天都在怕的那一刻：AI
11:36.000–11:37.370
zh真的把東西改壞了。
11:37.370–11:39.800
zh分兩種情況，而且分法只有一個問題：
11:39.800–11:41.350
zh你有沒有留過點。
11:41.350–11:42.860
zh第一種，你還沒留點。
11:42.860–11:44.570
zhAI 剛剛改了一堆檔案，
11:44.570–11:46.040
zh你跑起來完全不對。
11:46.040–11:48.190
zh這時候的動作叫 restore，
11:48.190–11:50.950
zh意思是把這些還沒留過點的改動全部丟掉，
11:50.950–11:51.970
zh回到上一個點。
11:51.970–11:53.900
zh就當剛剛那半小時沒發生過。
11:53.900–11:55.750
zh第二種，你已經留過點了，
11:55.750–11:57.890
zh而且是那個點本身有問題。
11:57.890–12:00.050
zh這時候比較安全的做法叫 revert。
12:00.050–12:02.410
zh它不是把歷史刪掉，是再記一筆，
12:02.410–12:04.510
zh內容是把前面那筆抵消掉。
12:04.510–12:05.720
zh為什麼要繞這一圈？
12:05.720–12:07.200
zh因為直接刪掉歷史的話，
12:07.200–12:09.420
zh跟你一起做的人手上版本會對不上，
12:09.420–12:11.290
zh而且他不會知道發生過什麼。
12:11.290–12:14.650
zh多記一筆抵消，所有人都看得到「加錯了、
12:14.650–12:16.020
zh然後被抵消了」。
12:16.020–12:17.840
zh這兩個你都不用記，你只要說：
12:17.840–12:19.510
zh剛剛這次的改動我不要了，
12:19.510–12:21.590
zh請幫我回到上一個正常的版本。
12:21.590–12:23.550
zhAI 會自己看現在的狀態，
12:23.550–12:24.900
zh決定該用哪一個。
12:24.900–12:26.180
zh做完怎麼確認？
12:26.180–12:29.340
zh這裡有兩件事是我覺得沒有人會先告訴你
12:29.340–12:31.570
zh的。 第一，restore 是不可逆的。
12:31.570–12:33.500
zh它丟掉的東西沒有回收桶。
12:33.500–12:35.300
zh不像刪檔案還能去垃圾桶撿，
12:35.300–12:37.240
zh那些改動是真的消失了，Git
12:37.240–12:38.740
zh裡面任何地方都找不到，
12:38.740–12:40.780
zh因為它們從來沒有被記下來過。
12:40.780–12:42.780
zh剛剛那五百七十行其實不是這一種。
12:42.780–12:44.140
zh那次是被暫時收起來，
12:44.140–12:45.960
zh還找得回來；restore
12:45.960–12:47.890
zh丟掉的才是真的沒有回收桶。
12:47.890–12:49.540
zh但兩次的傷害是同一種：
12:49.540–12:51.530
zh做那件事的不是壞掉的程式，
12:51.530–12:53.010
zh是收東西的動作本身，
12:53.010–12:54.930
zh而你不會知道要去哪裡找。
12:54.930–12:57.310
zh所以在說「回到上一個正常版本」之前，
12:57.310–12:58.260
zh值得多問一句：
12:58.260–13:00.900
zh這個動作會丟掉哪些還沒記錄的改動？
13:00.900–13:01.680
zh先列給我看。
13:01.680–13:04.030
zh第二件是他們很少講的第三種情況：
13:04.030–13:05.380
zh東西已經送出去了。
13:05.380–13:07.580
zh這時候光救你自己的電腦沒有用，要連
13:07.580–13:09.610
zhGitHub 上那一份一起處理。
13:09.610–13:12.100
zh你問 AI 的時候要把這件事講出來：
13:12.100–13:13.920
zh「這批改動我已經推上去了，
13:13.920–13:14.920
zh也要一起處理。
13:14.920–13:16.590
zh」所以這一章的判準是：
13:16.590–13:18.500
zh在說「回到上一個版本」之前，
13:18.500–13:20.800
zh先問它會丟掉什麼。
13:20.800–13:23.110
zh救回來之後還有最後一件事，
13:23.110–13:25.040
zh而且跟前面幾章不一樣：
13:25.040–13:28.130
zh前面都是事情沒到，這次是事情做到了，
13:28.130–13:29.190
zh但份量不對。
13:29.190–13:31.260
zh這是我踩過最容易被騙的一次。
13:31.260–13:34.280
zh有一次我叫 AI 算給我看它改了多少。
13:34.280–13:37.120
zh它回我：刪掉兩千六百二十一行。
13:37.120–13:38.260
zh兩千六百多行。
13:38.260–13:40.820
zh而我心裡預期的是幾十行。
13:40.820–13:42.710
zh我們當時真的停下來查了。
13:42.710–13:45.170
zh實際上那次刪掉的是三十行。
13:45.170–13:47.400
zh比對兩個版本有兩種算法。
13:47.400–13:49.560
zh一種是拿兩邊現在的樣子直接比。
13:49.560–13:52.000
zh另一種是先回到你們還一樣的時候，
13:52.000–13:54.050
zh再從那裡往後算你改了什麼。
13:54.050–13:56.250
zh當你這一份比正本少了幾次更新，
13:56.250–13:58.930
zh第一種算法會把別人後來加進去的東西，
13:58.930–14:00.290
zh全部算成你刪掉的。
14:00.290–14:03.200
zh你手上沒有，於是它就被記成你刪的。
14:03.200–14:04.050
zh而你看不出來。
14:04.050–14:06.510
zh兩個數字長得一模一樣，都是「刪掉 N
14:06.510–14:08.800
zh行」，沒有任何東西告訴你這兩個 N
14:08.800–14:09.730
zh的意思不同。
14:09.730–14:12.000
zh判準是最好記的一個：不要自己算，看
14:12.000–14:14.220
zhGitHub 自己算的那個數字。
14:14.220–14:15.300
zhGitHub 在
14:15.300–14:17.460
zh每一個提案上都會顯示改了多少，
14:17.460–14:20.020
zh那個數字用的是第二種算法，是權威值。
14:20.020–14:22.260
zh這個 PR 在 GitHub
14:22.260–14:25.200
zh上顯示的新增跟刪除行數是多少？
14:25.200–14:27.290
zh跟我預期改的份量對不對得上？
14:27.290–14:28.100
zh對得上就過。
14:28.100–14:30.590
zh對不上，那才是真的要查的時候。
14:30.590–14:32.940
zh你不用背數字，你只要拿它報的份量，
14:32.940–14:34.760
zh跟你交代它做的事比一下。
14:34.760–14:37.910
zh明顯不成比例，就值得問一句。
14:37.910–14:39.260
zhAI 問你的那幾句話，
14:39.260–14:40.700
zh你現在都答得出來了。
14:40.920–14:41.900
zhAI沒有騙你。
14:41.900–14:43.360
zh那兩種算法都是對的，
14:43.360–14:45.000
zh它們回答的是不同的問題。
14:45.000–14:46.880
zhAI挑了比較常見的那一種，
14:46.880–14:48.740
zh而它不知道你要問的是另一個。
14:48.740–14:50.440
zh其實這支片講的三次，
14:50.440–14:53.420
zh全部是同一個形狀：沒有一次是AI亂來，
14:53.420–14:56.000
zh每一次都是它做的事情跟你以為它在做的
14:56.000–14:57.770
zh事情，中間差了一層。
14:57.770–14:59.080
zh要不要 commit，
14:59.080–15:01.370
zh問的是值不值得留一個回得去的點。
15:01.370–15:02.480
zh要不要開分支，問
15:02.480–15:04.480
zh的是要不要跟正本隔開來做。
15:04.480–15:05.540
zh要不要發 PR，
15:05.540–15:07.590
zh問的是要不要正式提出去。
15:07.590–15:09.660
zh但我更想留給你的是另一半。
15:09.660–15:12.410
zh這支片每一個動作我都多講了一句「做完
15:12.410–15:13.390
zh怎麼確認」，因為
15:13.390–15:15.660
zh那才是這套工具對你真正的用處：
15:15.660–15:18.510
zh東西是還在我電腦上，還是已經送出去了？
15:18.510–15:20.670
zh我送去的那個地方，還收不收？
15:20.670–15:23.140
zh兩個 AI 有沒有共用同一個資料夾？
15:23.140–15:25.690
zh它給我的份量，跟我以為的對得上嗎？
15:25.690–15:28.530
zh四個問題，你不用會做，你只要會問。
15:28.530–15:30.100
zh對不寫程式的人來說，
15:30.100–15:33.230
zh版本控制真正的價值不是多學會一個工具，
15:33.230–15:35.930
zh是它把 AI 做的事情變成看得見的。
15:35.930–15:38.610
zh在那之前，AI 說完成了你只能相信；
15:38.610–15:40.320
zh有了之後，你可以去看。
15:40.320–15:43.350
zh而這個差別會決定你敢不敢把更大的事情
15:43.350–15:43.960
zh交出去。
15:43.960–15:45.180
zh你敢交，是因為你
15:45.180–15:47.550
zh知道出事了退得回來、看得出來。
15:47.550–15:49.840
zh這才是時間真正省下來的地方。
15:49.840–15:52.280
zh你不會因為看完這支影片就不再踩到，
15:52.280–15:53.440
zh我到現在還是會。
15:53.440–15:55.670
zh差別在於現在我知道要去哪裡看。
15:55.670–15:57.610
zh如果你想把這幾個檢查變成習慣，
15:57.610–16:00.110
zh我在免費社群裡整理了一份可以直接貼給
16:00.110–16:01.080
zhAI 的檢查清單，
16:01.080–16:02.980
zh就是這支影片講的這四個問題。
16:02.980–16:04.410
zh連結在資訊欄，網址是
16:04.410–16:05.680
enguccidgi.
16:05.680–16:07.210
encom/aifree。
16:07.210–16:09.640
zh不過在你去看之前，先做一件事。
16:09.640–16:11.170
zh打開你手邊那個 AI
16:11.170–16:12.700
zh幫你做到一半的東西，
16:12.700–16:15.590
zh問它一句：這些改動現在只在我的電腦上，
16:15.590–16:16.880
zh還是已經上去了？
16:16.880–16:17.730
zh那一次就夠了。
16:17.730–16:19.000
zh你會知道我在講什麼。

0:00.000–0:02.960
你的電腦裡有沒有這種檔案：
0:02.960–0:05.670
提案_最終版、提案_最終版2、
0:05.670–0:07.240
提案_這版才對。
0:07.240–0:09.930
如果有，那你其實已經在做版本控制了。
0:09.930–0:12.450
只是用的是最痛苦的做法：
0:12.450–0:14.730
靠檔名，靠記憶，靠運氣。
0:14.730–0:16.700
工程師二十年前就受不了了，
0:16.700–0:19.010
做了一套工具解決它：那套工具叫
0:19.010–0:21.580
Git，存放的地方叫 GitHub。
0:21.580–0:23.960
GitHub 你可能點進去過一次，
0:23.960–0:25.230
然後就關掉了，因為
0:25.230–0:27.080
那看起來是工程師的地方。
0:27.080–0:28.950
但如果你最近開始用 AI
0:28.950–0:31.770
幫你做東西，那個地方遲早會變成你的。
0:31.770–0:34.400
不是因為你要變成工程師，是因為 AI
0:34.400–0:37.350
一次改的東西比你多得多，你需要一個地方
0:37.350–0:38.760
，讓你做壞了回得去。
0:38.760–0:40.670
這支影片用一條線串起來，
0:40.670–0:43.460
從你做出第一個東西，到你同時開兩個
0:43.460–0:44.600
AI 幫你做事。
0:44.600–0:46.120
每個名詞出現之前，
0:46.120–0:48.300
我會先讓你遇到那個問題。
0:48.300–0:50.550
而且每一個動作我都會多講一句：
0:50.550–0:53.050
做完之後，你怎麼確認它真的做到了。
0:53.050–0:55.400
因為這一年我自己踩過三次，
0:55.400–0:57.360
每一次都是它做的事情，
0:57.360–1:00.600
跟我以為它在做的事情，中間差了一層。
1:00.600–1:01.570
我們直接開始。
1:02.370–1:05.160
如果你還不認識我，我是 Gucci。
1:05.160–1:07.880
我曾經是全球前三大記憶體廠的大數據
1:07.880–1:10.920
工程師，2019 年放棄年薪近兩百萬，
1:10.920–1:11.720
全職創業。
1:11.720–1:14.580
去年，我的線上事業收入 440 萬。
1:14.580–1:17.160
一年多前，我帶著老婆和剛滿 3
1:17.160–1:19.930
歲的女兒開始旅居世界——不是度假，
1:19.930–1:22.110
我照常工作，女兒照常上學，
1:22.110–1:23.870
世界就是她的課本。
1:23.870–1:27.140
從峇里島、清邁到檳城，支撐這種日子的，
1:27.140–1:28.370
就是槓桿 AI：
1:28.370–1:31.030
用更少的工時，把生活還給家人。
1:31.030–1:32.830
好，回到今天的主題。
1:32.840–1:35.160
假設你請 AI 幫你做一個東西。
1:35.160–1:37.900
一頁網站也好，一個會自己跑的小工具也好
1:37.900–1:39.980
，或是一份自動整理資料的表格。
1:39.980–1:42.960
過了半小時，它做出來了，打得開。
1:42.960–1:45.780
第一個問題馬上來了：這東西現在在哪裡？
1:45.780–1:48.250
它在你的電腦裡，某個資料夾。
1:48.250–1:51.140
這代表三件事：換一台電腦你就沒有它了、
1:51.140–1:52.670
電腦壞了它跟著沒了、
1:52.670–1:55.330
想給朋友看你只能整包壓縮寄過去。
1:55.330–1:57.590
所以你需要一個雲端的地方。
1:57.590–1:58.520
你可能會想，那用
1:58.520–2:00.880
Google Drive 不就好了？
2:00.880–2:01.440
不行。
2:01.440–2:03.730
而原因就是這支影片的第一個重點。
2:03.730–2:05.600
還記得開頭那幾個檔名嗎？
2:05.600–2:06.770
你為什麼要留那些版本？
2:06.770–2:08.230
不是因為你愛整理檔案，
2:08.230–2:09.680
是因為你知道會有一刻，
2:09.680–2:11.230
你想回到昨天那個版本。
2:11.230–2:13.020
程式比報告更需要這件事，
2:13.020–2:14.900
因為改壞的機會高太多了。
2:14.900–2:16.680
所以放程式的那個地方，
2:16.680–2:18.280
不能只是把檔案收好，
2:18.280–2:21.230
它還要記得每一次改了什麼、為什麼改。
2:21.230–2:22.500
Google Drive
2:22.500–2:23.300
只做前面那半。
2:23.300–2:25.830
做後面那半的，是今天的第一個名詞：
2:25.830–2:26.440
Git。
2:26.440–2:29.320
Git 是一個裝在你電腦裡的程式。
2:29.320–2:31.230
它只管一件事：你每存一次，
2:31.230–2:34.170
它就記下這一刻整個資料夾長什麼樣子，
2:34.170–2:36.170
還有你留給自己的一句話。
2:36.170–2:38.450
它從頭到尾都在你的機器上跑，
2:38.450–2:39.770
沒有網路也能用。
2:39.770–2:41.880
而 GitHub 是網路上的一個網站，
2:41.880–2:43.830
專門放這種有版本紀錄的資料夾。
2:43.830–2:46.710
這兩個名字只差三個字母，是兩個東西。
2:46.710–2:48.750
一個在你電腦裡管紀錄，
2:48.750–2:51.500
一個在網路上管存放跟給人看。
2:51.500–2:52.220
怎麼開始？
2:52.220–2:53.550
你不用學指令。
2:53.550–2:54.820
不過下面每一句話，
2:54.820–2:57.360
都要說給能直接動你電腦檔案的 AI
2:57.360–2:58.890
聽，像 Codex 這種。
2:58.890–3:01.970
貼進一般聊天視窗，它只會教你怎麼做，
3:01.970–3:03.220
不會真的去做。
3:03.220–3:05.230
幫我把這個資料夾建立版本紀錄，
3:05.230–3:07.190
之後我要放到 GitHub 上。
3:07.190–3:08.470
做完怎麼確認？
3:08.470–3:09.540
請 AI 檢查這個
3:09.540–3:11.220
資料夾有沒有開始記版本，
3:11.220–3:13.160
並把它查到的結果貼給你看。
3:13.160–3:15.190
不要特地去找那個叫 .git
3:15.190–3:17.220
的資料夾，它預設是藏起來的，
3:17.220–3:19.140
看不到很正常。
3:19.140–3:21.430
Git 裝好了，但它不會自己動。
3:21.430–3:23.230
你請 AI 加一個新功能，
3:23.230–3:24.770
它動了七八個檔案。
3:24.770–3:25.750
跑起來，壞了。
3:25.750–3:27.510
這時候的問題不是「壞了」。
3:27.510–3:28.770
壞掉可以修。
3:28.770–3:31.550
真正的問題是你不知道它剛剛動了哪幾個
3:31.550–3:34.120
地方，也不知道要退回到哪裡才是好的。
3:34.120–3:36.510
你連「半小時前」在哪都指不出來。
3:36.510–3:38.420
所以在事情還正常的時候，
3:38.420–3:40.440
你要先留一個回得去的點。
3:40.440–3:41.650
這個動作叫 commit。
3:41.650–3:43.160
一次 commit 就是一個點。
3:43.160–3:45.950
它記下這一刻你整個專案長什麼樣子，
3:45.950–3:47.690
加上你自己寫的一句話：
3:47.690–3:48.840
「第一版做好了」。
3:48.840–3:50.220
之後不管 AI 怎麼改，
3:50.220–3:51.550
你都指得回這個點。
3:51.550–3:53.210
所以當 AI 問你「要不要
3:53.210–3:54.200
commit」，
3:54.200–3:56.030
它在問的是：現在這個狀態，
3:56.030–3:58.110
值不值得留一個回得去的點？
3:58.110–3:59.180
判準很簡單：只要
3:59.180–4:01.890
接下來那件事你不確定會不會壞，就先留。
4:01.890–4:04.640
要請 AI 動一個你不熟的地方，先留。
4:04.640–4:06.340
要一次改很多檔案，先留。
4:06.340–4:08.410
改完覺得可以了，再留一個。
4:08.410–4:10.500
你不用記指令，只要會講這句話：
4:10.500–4:12.900
這一版是好的，先幫我留一個紀錄點，
4:12.900–4:14.450
說明寫「第一版做好了」。
4:14.450–4:15.730
做完怎麼確認？
4:15.730–4:18.370
這裡有第一個陷阱，而且它最不起眼。
4:18.370–4:19.740
你留的這些點，全部
4:19.740–4:21.720
都還在你自己這台電腦上。
4:21.720–4:23.030
回到開頭那些檔名。
4:23.030–4:25.580
你存了好幾個版本，每一版你都找得到。
4:25.580–4:27.450
可是對方一份都還沒收到。
4:27.450–4:29.790
你只是在自己桌上把東西整理好，
4:29.790–4:31.230
你沒有把它交出去。
4:31.230–4:32.400
commit 就是這樣。
4:32.400–4:33.370
它不是上傳。
4:33.370–4:36.590
這台電腦壞掉，那些點會跟著一起消失。
4:36.590–4:38.420
所以確認的方式是問它：
4:38.420–4:40.810
「這些改動現在只在我的電腦上，
4:40.810–4:42.100
還是已經上去了？
4:42.100–4:44.600
」那另一半怎麼辦？
4:44.600–4:46.490
把你電腦上記好的那些點，送到
4:46.490–4:48.240
GitHub 去，這個動作叫
4:48.240–4:48.930
push。
4:48.930–4:50.900
送上去之後你就有了三樣東西：
4:50.900–4:53.330
一份雲端備份、一個可以給人看的網址、
4:53.330–4:56.070
還有一份不會因為電腦壞掉而消失的完整
4:56.070–4:56.470
歷史。
4:56.470–4:57.840
到這裡都很順。
4:57.840–5:00.120
但這一段的重點在下一句：
5:00.120–5:02.500
有些東西不能跟著送上去。
5:02.500–5:03.890
你請 AI 串一個服務，
5:03.890–5:05.540
它可能會需要一組金鑰。
5:05.540–5:07.560
那組金鑰就像你家大門的鑰匙，
5:07.560–5:10.000
誰拿到誰就能用你的帳號、花你的錢。
5:10.000–5:13.200
問題是那組金鑰通常就寫在專案的某個檔案
5:13.200–5:14.630
裡。 你 push 的時候，
5:14.630–5:16.740
如果沒有特別交代，它會一起上去。
5:16.740–5:18.540
而 GitHub 上的東西是有紀錄的。
5:18.540–5:21.330
你把它刪掉，紀錄裡還留著。
5:21.330–5:23.360
有人專門在掃這種東西，
5:23.360–5:25.500
而且掃得比你想像中快。
5:25.500–5:27.810
所以這裡要做一件事：告訴 Git
5:27.810–5:29.890
哪些檔案不要記帳、不要上傳。
5:29.890–5:31.880
那份清單叫 .gitignore。
5:31.880–5:33.130
你可以直接這樣講：
5:33.130–5:35.610
幫我檢查一遍：這個專案裡有沒有金鑰、
5:35.610–5:37.420
密碼這類不該公開的東西？
5:37.420–5:39.450
有的話幫我設成不要上傳。
5:39.450–5:40.730
做完怎麼確認？
5:40.730–5:41.990
打開 GitHub
5:41.990–5:43.410
上你那個專案的頁面，
5:43.410–5:45.090
用眼睛看一遍檔案清單。
5:45.090–5:48.120
這一段值得你親眼看，因為金鑰一旦公開，
5:48.120–5:50.190
光把檔案刪掉也收不回來。
5:50.190–5:52.300
而且如果你發現它真的上去了，
5:52.300–5:54.260
正確的做法不是把紀錄刪掉，
5:54.260–5:56.150
是立刻去把那把金鑰換掉。
5:56.150–5:57.260
紀錄可以整理，但
5:57.260–5:59.320
外流的那幾分鐘裡誰複製走了，
5:59.320–6:01.020
你不會知道。
6:01.020–6:03.410
東西上去了，但它還不是「正式版本」。
6:03.410–6:04.480
GitHub 上
6:04.480–6:06.430
通常有一份大家公認的正本。
6:06.430–6:08.230
你送上去的是你自己那一份。
6:08.230–6:10.790
要讓你的改動變成正本的一部分，
6:10.790–6:13.640
得先提出來，讓人看過，才會被收進去。
6:13.640–6:15.040
這個「提出來」叫 PR。
6:15.040–6:16.910
收進去的那一下叫 merge。
6:16.910–6:20.080
一個人做專案的時候，這一段常常會被跳過
6:20.080–6:22.120
，AI 也可能直接幫你合併。
6:22.120–6:24.580
但只要有第二個人、或第二個 AI
6:24.580–6:25.800
參與，這一段就是
6:25.800–6:28.360
你唯一看得到「誰改了什麼」的地方。
6:28.360–6:29.640
做完怎麼確認？
6:29.640–6:31.730
這是我踩過最尷尬的一次。
6:31.730–6:34.320
我們自己的專案裡有一支編號 708
6:34.320–6:34.910
的提案。
6:34.910–6:36.830
它被收進去了，正式結案。
6:36.830–6:38.410
結案之後，同一天晚上，
6:38.410–6:40.610
我又往同一個地方推了幾次。
6:40.610–6:43.410
每一次都成功，沒有錯誤訊息，沒有警告，
6:43.410–6:44.380
什麼都沒有。
6:44.380–6:46.930
然後我回報：推上 708 了。
6:46.930–6:48.470
那支提案早就關閉了。
6:48.470–6:50.700
後面那幾次不屬於任何一個提案，
6:50.700–6:52.400
永遠不會進到正本裡面。
6:52.400–6:53.630
推送本來就會成功，
6:53.630–6:56.250
因為它只負責把東西送到 GitHub，
6:56.250–6:58.500
不負責判斷「你送的地方還收不收」。
6:58.500–7:00.330
而 AI 也不會提醒你，
7:00.330–7:02.960
它照著你說的做，做完回你成功，
7:02.960–7:05.490
因為對它來說那確實成功了。
7:05.490–7:07.680
所以確認的方式是多問一句：
7:07.680–7:09.230
這個提案還開著嗎？
7:09.230–7:11.420
幫我確認我剛剛推上去的那個 PR
7:11.420–7:12.540
現在是什麼狀態。
7:12.540–7:13.720
如果已經 merge
7:13.720–7:16.720
了，那我後來推的東西是不是還在外面。
7:16.720–7:18.480
到目前為止都是你一個人。
7:18.680–7:20.080
很多人在這裡誤會，
7:20.080–7:22.040
是因為AI回報「已commit」的時候
7:22.040–7:24.840
，那個語氣聽起來就像事情辦完了。
7:24.840–7:27.220
它辦完的是一半：在你這裡辦完了。
7:27.220–7:28.560
所以整條路是四段，
7:28.560–7:30.860
你記這四段就好：在你電腦上留點，
7:30.860–7:33.080
送到GitHub，提出來，被收進去。
7:33.080–7:34.220
只有最後一段完成，
7:34.220–7:36.460
你的改動才算是正式版本的一部分。
7:36.460–7:38.980
前面三段做完，東西都還在旁邊等。
7:38.980–7:40.540
這件事的重點是：
7:40.540–7:42.820
這個系統在那個情況下不會提醒任何人。
7:42.820–7:44.700
你不用會判斷，你只要會問。
7:44.700–7:46.900
現在假設有第二個人要加進來。
7:46.900–7:49.290
他要先把東西拿到自己電腦上，
7:49.290–7:52.340
而這件事有兩個名字，差別只在第幾次。
7:52.340–7:54.500
第一次整包拿走，叫 clone。
7:54.500–7:57.020
之後每次拿別人的新進度，叫 pull。
7:57.020–7:59.030
這裡有個很多人會踩的地方：
7:59.030–8:00.200
第一次拿的時候，
8:00.200–8:01.800
不要在網頁上按「下載」。
8:01.800–8:04.070
下載拿到的是一包死檔案，
8:04.070–8:07.250
沒有紀錄、沒有歷史，改完也送不回去。
8:07.250–8:08.300
clone 拿到
8:08.300–8:10.490
的才是連同整本紀錄的完整專案。
8:10.490–8:13.730
合作的循環就是四步：拉下來、改、留點、
8:13.730–8:14.630
送上去。
8:14.630–8:16.740
現在，那個「別人」常常不是人，
8:16.740–8:18.170
而是另一個 AI。
8:18.170–8:19.290
而 AI 不會跟
8:19.290–8:21.810
你說一聲它拉了什麼、改了什麼。
8:21.810–8:23.630
然後就會遇到最麻煩的那一種：
8:23.630–8:24.990
兩邊改到同一個地方。
8:24.990–8:26.830
Git 這時候會停下來，跳出
8:26.830–8:28.920
conflict，中文叫衝突。
8:28.920–8:30.250
意思很直白：同一段
8:30.250–8:32.240
內容出現了兩個不同的版本，
8:32.240–8:34.990
它不知道該聽誰的，所以它不猜，它問你。
8:34.990–8:37.630
現在的 AI 遇到衝突通常會自己處理。
8:37.630–8:39.790
它會看懂兩邊各自想做什麼，
8:39.790–8:41.940
然後幫你合：有時候是二選一，
8:41.940–8:43.380
有時候是兩邊都留，
8:43.380–8:46.430
有時候是乾脆重寫一段把兩邊的功能接
8:46.430–8:46.890
起來。
8:46.890–8:48.160
做完怎麼確認？
8:48.160–8:50.720
這裡是我覺得最值得你記住的一件事。
8:50.720–8:52.740
AI 卡住的時候其實很安全，
8:52.740–8:54.350
因為它會停下來問你。
8:54.350–8:55.880
危險的是它沒有卡住。
8:55.880–8:58.900
它沒有你的產品規劃，它只看得到程式碼。
8:58.900–9:00.830
所以它可能很順地選了一邊，
9:00.830–9:02.600
而那一邊剛好是你不要的，
9:02.600–9:04.480
然後回你一句「衝突已解決」。
9:04.480–9:05.910
畫面上什麼警告都沒有。
9:05.910–9:07.150
所以合併完之後，
9:07.150–9:09.100
你要問的不是「解決了嗎」，是：
9:09.100–9:10.970
這次衝突你是怎麼解的？
9:10.970–9:12.670
兩邊各自原本想做什麼，
9:12.670–9:14.310
你留了哪一邊、為什麼？
9:14.310–9:17.560
重點不是它答不答得出來，是它講的那兩邊
9:17.560–9:18.930
，你自己各試一次。
9:18.930–9:21.860
少了一邊，就叫它重做。
9:21.860–9:24.020
接下來會發生一件很自然的事：
9:24.020–9:25.450
你會想同時開兩個。
9:25.450–9:27.550
一個在幫你改版面，你在旁邊等，
9:27.550–9:30.440
你會想那我為什麼不順便開另一個去處理
9:30.440–9:30.860
別的。
9:30.860–9:32.070
問題在於，這兩個
9:32.070–9:34.320
視窗會直接改同一個資料夾，而
9:34.320–9:35.450
Git 不會攔。
9:35.450–9:36.760
剛剛那個衝突警告，
9:36.760–9:38.990
只在合併兩份紀錄時才會出現。
9:38.990–9:41.660
同一份東西，兩個人同時在上面動手，
9:41.660–9:43.720
這件事你在辦公室裡見過。
9:43.720–9:47.170
兩個人各自打開同一份共用檔案，各自改，
9:47.170–9:47.880
各自存。
9:47.880–9:49.020
最後存的那個人，
9:49.020–9:50.900
蓋掉前一個人的所有修改。
9:50.900–9:52.710
而前一個人不會收到通知，
9:52.710–9:55.660
他要到很久以後才會發現自己那半天不見
9:55.660–9:58.140
了。 在專案裡一樣，只是更難察覺，
9:58.140–9:59.620
因為兩邊都是 AI，
9:59.620–10:01.760
它們不會抬頭跟你說一聲。
10:01.760–10:02.760
這時候 AI 可能
10:02.760–10:04.440
會問你要不要開一個分支。
10:04.440–10:06.800
分支的意思是「跟正本隔開來做」，
10:06.800–10:08.540
改壞了整條丟掉就好。
10:08.540–10:11.720
那是好東西，但它解決不了現在這個問題。
10:11.720–10:12.870
因為分支再多，你
10:12.870–10:15.490
電腦上那個資料夾還是只有一個，兩個
10:15.490–10:17.720
AI 還是站在同一張桌子前面。
10:17.720–10:20.650
真正解決這件事的做法只有一個：給第二個
10:20.650–10:22.050
AI 第二個資料夾。
10:22.050–10:23.650
這個做法叫 worktree。
10:23.650–10:25.920
它在你硬碟上多開一個資料夾，
10:25.920–10:27.310
裝的是同一個專案，
10:27.310–10:29.160
但跟原本那個各自獨立。
10:29.160–10:31.480
一個 AI 待一個，互不干擾。
10:31.480–10:32.760
做完怎麼確認？
10:32.760–10:34.050
分別問這兩個 AI：
10:34.050–10:35.600
你現在在哪個資料夾？
10:35.600–10:38.090
兩個答案不一樣，才是真的分開了。
10:38.090–10:39.540
沒做到的時候會發生什麼，
10:39.540–10:41.230
我們是用最貴的方式知道的。
10:41.230–10:42.870
有一次，我們有兩個 AI
10:42.870–10:45.490
同時在做事，而它們沒有各自的資料夾，
10:45.490–10:46.570
用的是同一個。
10:46.570–10:49.010
其中一個想看「原本的版本長什麼樣」，
10:49.010–10:50.240
就下了兩道指令。
10:50.240–10:51.390
這兩道指令，一個
10:51.390–10:53.460
人單獨工作的時候完全正常。
10:53.460–10:55.060
你不用會下這兩道指令，
10:55.060–10:57.770
你只要知道它們做了什麼：把桌面收乾淨，
10:57.770–10:59.950
然後把資料夾換成另一個版本。
10:59.950–11:01.710
但那天不是一個人在工作。
11:01.710–11:04.370
那兩道指令的作用範圍，涵蓋了另一個
11:04.370–11:06.140
AI還沒有存好的東西。
11:06.140–11:09.030
大約五百七十行被掃掉了，是另一個 AI
11:09.030–11:10.660
還沒留下紀錄的工作。
11:10.660–11:11.670
而它不會報錯。
11:11.670–11:14.860
指令成功執行，畫面上什麼都沒有。
11:14.860–11:17.100
要等到另一邊回頭找自己的東西，
11:17.100–11:17.840
才會發現。
11:17.840–11:19.000
如果那個人是你，
11:19.000–11:21.420
你的第一個念頭會是自己記錯了。
11:21.420–11:23.650
所以這一段你要帶走的只有一句：
11:23.650–11:24.770
不要讓兩個 AI
11:24.770–11:26.470
在同一個資料夾裡動手。
11:26.470–11:28.670
我要同時開兩個來做不同的事，
11:28.670–11:31.040
幫我各開一個獨立的工作資料夾，
11:31.040–11:33.630
不要讓它們共用同一個。
11:33.630–11:36.000
最後講你每天都在怕的那一刻：AI
11:36.000–11:37.370
真的把東西改壞了。
11:37.370–11:39.800
分兩種情況，而且分法只有一個問題：
11:39.800–11:41.350
你有沒有留過點。
11:41.350–11:42.860
第一種，你還沒留點。
11:42.860–11:44.570
AI 剛剛改了一堆檔案，
11:44.570–11:46.040
你跑起來完全不對。
11:46.040–11:48.190
這時候的動作叫 restore，
11:48.190–11:50.950
意思是把這些還沒留過點的改動全部丟掉，
11:50.950–11:51.970
回到上一個點。
11:51.970–11:53.900
就當剛剛那半小時沒發生過。
11:53.900–11:55.750
第二種，你已經留過點了，
11:55.750–11:57.890
而且是那個點本身有問題。
11:57.890–12:00.050
這時候比較安全的做法叫 revert。
12:00.050–12:02.410
它不是把歷史刪掉，是再記一筆，
12:02.410–12:04.510
內容是把前面那筆抵消掉。
12:04.510–12:05.720
為什麼要繞這一圈？
12:05.720–12:07.200
因為直接刪掉歷史的話，
12:07.200–12:09.420
跟你一起做的人手上版本會對不上，
12:09.420–12:11.290
而且他不會知道發生過什麼。
12:11.290–12:14.650
多記一筆抵消，所有人都看得到「加錯了、
12:14.650–12:16.020
然後被抵消了」。
12:16.020–12:17.840
這兩個你都不用記，你只要說：
12:17.840–12:19.510
剛剛這次的改動我不要了，
12:19.510–12:21.590
請幫我回到上一個正常的版本。
12:21.590–12:23.550
AI 會自己看現在的狀態，
12:23.550–12:24.900
決定該用哪一個。
12:24.900–12:26.180
做完怎麼確認？
12:26.180–12:29.340
這裡有兩件事是我覺得沒有人會先告訴你
12:29.340–12:31.570
的。 第一，restore 是不可逆的。
12:31.570–12:33.500
它丟掉的東西沒有回收桶。
12:33.500–12:35.300
不像刪檔案還能去垃圾桶撿，
12:35.300–12:37.240
那些改動是真的消失了，Git
12:37.240–12:38.740
裡面任何地方都找不到，
12:38.740–12:40.780
因為它們從來沒有被記下來過。
12:40.780–12:42.780
剛剛那五百七十行其實不是這一種。
12:42.780–12:44.140
那次是被暫時收起來，
12:44.140–12:45.960
還找得回來；restore
12:45.960–12:47.890
丟掉的才是真的沒有回收桶。
12:47.890–12:49.540
但兩次的傷害是同一種：
12:49.540–12:51.530
做那件事的不是壞掉的程式，
12:51.530–12:53.010
是收東西的動作本身，
12:53.010–12:54.930
而你不會知道要去哪裡找。
12:54.930–12:57.310
所以在說「回到上一個正常版本」之前，
12:57.310–12:58.260
值得多問一句：
12:58.260–13:00.900
這個動作會丟掉哪些還沒記錄的改動？
13:00.900–13:01.680
先列給我看。
13:01.680–13:04.030
第二件是他們很少講的第三種情況：
13:04.030–13:05.380
東西已經送出去了。
13:05.380–13:07.580
這時候光救你自己的電腦沒有用，要連
13:07.580–13:09.610
GitHub 上那一份一起處理。
13:09.610–13:12.100
你問 AI 的時候要把這件事講出來：
13:12.100–13:13.920
「這批改動我已經推上去了，
13:13.920–13:14.920
也要一起處理。
13:14.920–13:16.590
」所以這一章的判準是：
13:16.590–13:18.500
在說「回到上一個版本」之前，
13:18.500–13:20.800
先問它會丟掉什麼。
13:20.800–13:23.110
救回來之後還有最後一件事，
13:23.110–13:25.040
而且跟前面幾章不一樣：
13:25.040–13:28.130
前面都是事情沒到，這次是事情做到了，
13:28.130–13:29.190
但份量不對。
13:29.190–13:31.260
這是我踩過最容易被騙的一次。
13:31.260–13:34.280
有一次我叫 AI 算給我看它改了多少。
13:34.280–13:37.120
它回我：刪掉兩千六百二十一行。
13:37.120–13:38.260
兩千六百多行。
13:38.260–13:40.820
而我心裡預期的是幾十行。
13:40.820–13:42.710
我們當時真的停下來查了。
13:42.710–13:45.170
實際上那次刪掉的是三十行。
13:45.170–13:47.400
比對兩個版本有兩種算法。
13:47.400–13:49.560
一種是拿兩邊現在的樣子直接比。
13:49.560–13:52.000
另一種是先回到你們還一樣的時候，
13:52.000–13:54.050
再從那裡往後算你改了什麼。
13:54.050–13:56.250
當你這一份比正本少了幾次更新，
13:56.250–13:58.930
第一種算法會把別人後來加進去的東西，
13:58.930–14:00.290
全部算成你刪掉的。
14:00.290–14:03.200
你手上沒有，於是它就被記成你刪的。
14:03.200–14:04.050
而你看不出來。
14:04.050–14:06.510
兩個數字長得一模一樣，都是「刪掉 N
14:06.510–14:08.800
行」，沒有任何東西告訴你這兩個 N
14:08.800–14:09.730
的意思不同。
14:09.730–14:12.000
判準是最好記的一個：不要自己算，看
14:12.000–14:14.220
GitHub 自己算的那個數字。
14:14.220–14:15.300
GitHub 在
14:15.300–14:17.460
每一個提案上都會顯示改了多少，
14:17.460–14:20.020
那個數字用的是第二種算法，是權威值。
14:20.020–14:22.260
這個 PR 在 GitHub
14:22.260–14:25.200
上顯示的新增跟刪除行數是多少？
14:25.200–14:27.290
跟我預期改的份量對不對得上？
14:27.290–14:28.100
對得上就過。
14:28.100–14:30.590
對不上，那才是真的要查的時候。
14:30.590–14:32.940
你不用背數字，你只要拿它報的份量，
14:32.940–14:34.760
跟你交代它做的事比一下。
14:34.760–14:37.910
明顯不成比例，就值得問一句。
14:37.910–14:39.260
AI 問你的那幾句話，
14:39.260–14:40.700
你現在都答得出來了。
14:40.920–14:41.900
AI沒有騙你。
14:41.900–14:43.360
那兩種算法都是對的，
14:43.360–14:45.000
它們回答的是不同的問題。
14:45.000–14:46.880
AI挑了比較常見的那一種，
14:46.880–14:48.740
而它不知道你要問的是另一個。
14:48.740–14:50.440
其實這支片講的三次，
14:50.440–14:53.420
全部是同一個形狀：沒有一次是AI亂來，
14:53.420–14:56.000
每一次都是它做的事情跟你以為它在做的
14:56.000–14:57.770
事情，中間差了一層。
14:57.770–14:59.080
要不要 commit，
14:59.080–15:01.370
問的是值不值得留一個回得去的點。
15:01.370–15:02.480
要不要開分支，問
15:02.480–15:04.480
的是要不要跟正本隔開來做。
15:04.480–15:05.540
要不要發 PR，
15:05.540–15:07.590
問的是要不要正式提出去。
15:07.590–15:09.660
但我更想留給你的是另一半。
15:09.660–15:12.410
這支片每一個動作我都多講了一句「做完
15:12.410–15:13.390
怎麼確認」，因為
15:13.390–15:15.660
那才是這套工具對你真正的用處：
15:15.660–15:18.510
東西是還在我電腦上，還是已經送出去了？
15:18.510–15:20.670
我送去的那個地方，還收不收？
15:20.670–15:23.140
兩個 AI 有沒有共用同一個資料夾？
15:23.140–15:25.690
它給我的份量，跟我以為的對得上嗎？
15:25.690–15:28.530
四個問題，你不用會做，你只要會問。
15:28.530–15:30.100
對不寫程式的人來說，
15:30.100–15:33.230
版本控制真正的價值不是多學會一個工具，
15:33.230–15:35.930
是它把 AI 做的事情變成看得見的。
15:35.930–15:38.610
在那之前，AI 說完成了你只能相信；
15:38.610–15:40.320
有了之後，你可以去看。
15:40.320–15:43.350
而這個差別會決定你敢不敢把更大的事情
15:43.350–15:43.960
交出去。
15:43.960–15:45.180
你敢交，是因為你
15:45.180–15:47.550
知道出事了退得回來、看得出來。
15:47.550–15:49.840
這才是時間真正省下來的地方。
15:49.840–15:52.280
你不會因為看完這支影片就不再踩到，
15:52.280–15:53.440
我到現在還是會。
15:53.440–15:55.670
差別在於現在我知道要去哪裡看。
15:55.670–15:57.610
如果你想把這幾個檢查變成習慣，
15:57.610–16:00.110
我在免費社群裡整理了一份可以直接貼給
16:00.110–16:01.080
AI 的檢查清單，
16:01.080–16:02.980
就是這支影片講的這四個問題。
16:02.980–16:04.410
連結在資訊欄，網址是
16:04.410–16:05.680
guccidgi.
16:05.680–16:07.210
com/aifree。
16:07.210–16:09.640
不過在你去看之前，先做一件事。
16:09.640–16:11.170
打開你手邊那個 AI
16:11.170–16:12.700
幫你做到一半的東西，
16:12.700–16:15.590
問它一句：這些改動現在只在我的電腦上，
16:15.590–16:16.880
還是已經上去了？
16:16.880–16:17.730
那一次就夠了。
16:17.730–16:19.000
你會知道我在講什麼。

0:00.000–0:02.960
zh你的電腦裡有沒有這種檔案：
你的電腦裡有沒有這種檔案：
0:02.960–0:05.670
zh提案_最終版、提案_最終版2、
提案_最終版、提案_最終版2、
0:05.670–0:07.240
zh提案_這版才對。
提案_這版才對。
0:07.240–0:09.930
zh如果有，那你其實已經在做版本控制了。
如果有，那你其實已經在做版本控制了。
0:09.930–0:12.450
zh只是用的是最痛苦的做法：
只是用的是最痛苦的做法：
0:12.450–0:14.730
zh靠檔名，靠記憶，靠運氣。
靠檔名，靠記憶，靠運氣。
0:14.730–0:16.700
zh工程師二十年前就受不了了，
工程師二十年前就受不了了，
0:16.700–0:19.010
zh做了一套工具解決它：那套工具叫
做了一套工具解決它：那套工具叫
0:19.010–0:21.580
zhGit，存放的地方叫 GitHub。
Git，存放的地方叫 GitHub。
0:21.580–0:23.960
zhGitHub 你可能點進去過一次，
GitHub 你可能點進去過一次，
0:23.960–0:25.230
zh然後就關掉了，因為
然後就關掉了，因為
0:25.230–0:27.080
zh那看起來是工程師的地方。
那看起來是工程師的地方。
0:27.080–0:28.950
zh但如果你最近開始用 AI
但如果你最近開始用 AI
0:28.950–0:31.770
zh幫你做東西，那個地方遲早會變成你的。
幫你做東西，那個地方遲早會變成你的。
0:31.770–0:34.400
zh不是因為你要變成工程師，是因為 AI
不是因為你要變成工程師，是因為 AI
0:34.400–0:37.350
zh一次改的東西比你多得多，你需要一個地方
一次改的東西比你多得多，你需要一個地方
0:37.350–0:38.760
zh，讓你做壞了回得去。
，讓你做壞了回得去。
0:38.760–0:40.670
zh這支影片用一條線串起來，
這支影片用一條線串起來，
0:40.670–0:43.460
zh從你做出第一個東西，到你同時開兩個
從你做出第一個東西，到你同時開兩個
0:43.460–0:44.600
zhAI 幫你做事。
AI 幫你做事。
0:44.600–0:46.120
zh每個名詞出現之前，
每個名詞出現之前，
0:46.120–0:48.300
zh我會先讓你遇到那個問題。
我會先讓你遇到那個問題。
0:48.300–0:50.550
zh而且每一個動作我都會多講一句：
而且每一個動作我都會多講一句：
0:50.550–0:53.050
zh做完之後，你怎麼確認它真的做到了。
做完之後，你怎麼確認它真的做到了。
0:53.050–0:55.400
zh因為這一年我自己踩過三次，
因為這一年我自己踩過三次，
0:55.400–0:57.360
zh每一次都是它做的事情，
每一次都是它做的事情，
0:57.360–1:00.600
zh跟我以為它在做的事情，中間差了一層。
跟我以為它在做的事情，中間差了一層。
1:00.600–1:01.570
zh我們直接開始。
我們直接開始。
1:02.370–1:05.160
zh如果你還不認識我，我是 Gucci。
如果你還不認識我，我是 Gucci。
1:05.160–1:07.880
zh我曾經是全球前三大記憶體廠的大數據
我曾經是全球前三大記憶體廠的大數據
1:07.880–1:10.920
zh工程師，2019 年放棄年薪近兩百萬，
工程師，2019 年放棄年薪近兩百萬，
1:10.920–1:11.720
zh全職創業。
全職創業。
1:11.720–1:14.580
zh去年，我的線上事業收入 440 萬。
去年，我的線上事業收入 440 萬。
1:14.580–1:17.160
zh一年多前，我帶著老婆和剛滿 3
一年多前，我帶著老婆和剛滿 3
1:17.160–1:19.930
zh歲的女兒開始旅居世界——不是度假，
歲的女兒開始旅居世界——不是度假，
1:19.930–1:22.110
zh我照常工作，女兒照常上學，
我照常工作，女兒照常上學，
1:22.110–1:23.870
zh世界就是她的課本。
世界就是她的課本。
1:23.870–1:27.140
zh從峇里島、清邁到檳城，支撐這種日子的，
從峇里島、清邁到檳城，支撐這種日子的，
1:27.140–1:28.370
zh就是槓桿 AI：
就是槓桿 AI：
1:28.370–1:31.030
zh用更少的工時，把生活還給家人。
用更少的工時，把生活還給家人。
1:31.030–1:32.830
zh好，回到今天的主題。
好，回到今天的主題。
1:32.840–1:35.160
zh假設你請 AI 幫你做一個東西。
假設你請 AI 幫你做一個東西。
1:35.160–1:37.900
zh一頁網站也好，一個會自己跑的小工具也好
一頁網站也好，一個會自己跑的小工具也好
1:37.900–1:39.980
zh，或是一份自動整理資料的表格。
，或是一份自動整理資料的表格。
1:39.980–1:42.960
zh過了半小時，它做出來了，打得開。
過了半小時，它做出來了，打得開。
1:42.960–1:45.780
zh第一個問題馬上來了：這東西現在在哪裡？
第一個問題馬上來了：這東西現在在哪裡？
1:45.780–1:48.250
zh它在你的電腦裡，某個資料夾。
它在你的電腦裡，某個資料夾。
1:48.250–1:51.140
zh這代表三件事：換一台電腦你就沒有它了、
這代表三件事：換一台電腦你就沒有它了、
1:51.140–1:52.670
zh電腦壞了它跟著沒了、
電腦壞了它跟著沒了、
1:52.670–1:55.330
zh想給朋友看你只能整包壓縮寄過去。
想給朋友看你只能整包壓縮寄過去。
1:55.330–1:57.590
zh所以你需要一個雲端的地方。
所以你需要一個雲端的地方。
1:57.590–1:58.520
zh你可能會想，那用
你可能會想，那用
1:58.520–2:00.880
zhGoogle Drive 不就好了？
Google Drive 不就好了？
2:00.880–2:01.440
zh不行。
不行。
2:01.440–2:03.730
zh而原因就是這支影片的第一個重點。
而原因就是這支影片的第一個重點。
2:03.730–2:05.600
zh還記得開頭那幾個檔名嗎？
還記得開頭那幾個檔名嗎？
2:05.600–2:06.770
zh你為什麼要留那些版本？
你為什麼要留那些版本？
2:06.770–2:08.230
zh不是因為你愛整理檔案，
不是因為你愛整理檔案，
2:08.230–2:09.680
zh是因為你知道會有一刻，
是因為你知道會有一刻，
2:09.680–2:11.230
zh你想回到昨天那個版本。
你想回到昨天那個版本。
2:11.230–2:13.020
zh程式比報告更需要這件事，
程式比報告更需要這件事，
2:13.020–2:14.900
zh因為改壞的機會高太多了。
因為改壞的機會高太多了。
2:14.900–2:16.680
zh所以放程式的那個地方，
所以放程式的那個地方，
2:16.680–2:18.280
zh不能只是把檔案收好，
不能只是把檔案收好，
2:18.280–2:21.230
zh它還要記得每一次改了什麼、為什麼改。
它還要記得每一次改了什麼、為什麼改。
2:21.230–2:22.500
enGoogle Drive
Google Drive
2:22.500–2:23.300
zh只做前面那半。
只做前面那半。
2:23.300–2:25.830
zh做後面那半的，是今天的第一個名詞：
做後面那半的，是今天的第一個名詞：
2:25.830–2:26.440
enGit。
Git。
2:26.440–2:29.320
zhGit 是一個裝在你電腦裡的程式。
Git 是一個裝在你電腦裡的程式。
2:29.320–2:31.230
zh它只管一件事：你每存一次，
它只管一件事：你每存一次，
2:31.230–2:34.170
zh它就記下這一刻整個資料夾長什麼樣子，
它就記下這一刻整個資料夾長什麼樣子，
2:34.170–2:36.170
zh還有你留給自己的一句話。
還有你留給自己的一句話。
2:36.170–2:38.450
zh它從頭到尾都在你的機器上跑，
它從頭到尾都在你的機器上跑，
2:38.450–2:39.770
zh沒有網路也能用。
沒有網路也能用。
2:39.770–2:41.880
zh而 GitHub 是網路上的一個網站，
而 GitHub 是網路上的一個網站，
2:41.880–2:43.830
zh專門放這種有版本紀錄的資料夾。
專門放這種有版本紀錄的資料夾。
2:43.830–2:46.710
zh這兩個名字只差三個字母，是兩個東西。
這兩個名字只差三個字母，是兩個東西。
2:46.710–2:48.750
zh一個在你電腦裡管紀錄，
一個在你電腦裡管紀錄，
2:48.750–2:51.500
zh一個在網路上管存放跟給人看。
一個在網路上管存放跟給人看。
2:51.500–2:52.220
zh怎麼開始？
怎麼開始？
2:52.220–2:53.550
zh你不用學指令。
你不用學指令。
2:53.550–2:54.820
zh不過下面每一句話，
不過下面每一句話，
2:54.820–2:57.360
zh都要說給能直接動你電腦檔案的 AI
都要說給能直接動你電腦檔案的 AI
2:57.360–2:58.890
zh聽，像 Codex 這種。
聽，像 Codex 這種。
2:58.890–3:01.970
zh貼進一般聊天視窗，它只會教你怎麼做，
貼進一般聊天視窗，它只會教你怎麼做，
3:01.970–3:03.220
zh不會真的去做。
不會真的去做。
3:03.220–3:05.230
zh幫我把這個資料夾建立版本紀錄，
幫我把這個資料夾建立版本紀錄，
3:05.230–3:07.190
zh之後我要放到 GitHub 上。
之後我要放到 GitHub 上。
3:07.190–3:08.470
zh做完怎麼確認？
做完怎麼確認？
3:08.470–3:09.540
zh請 AI 檢查這個
請 AI 檢查這個
3:09.540–3:11.220
zh資料夾有沒有開始記版本，
資料夾有沒有開始記版本，
3:11.220–3:13.160
zh並把它查到的結果貼給你看。
並把它查到的結果貼給你看。
3:13.160–3:15.190
zh不要特地去找那個叫 .git
不要特地去找那個叫 .git
3:15.190–3:17.220
zh的資料夾，它預設是藏起來的，
的資料夾，它預設是藏起來的，
3:17.220–3:19.140
zh看不到很正常。
看不到很正常。
3:19.140–3:21.430
zhGit 裝好了，但它不會自己動。
Git 裝好了，但它不會自己動。
3:21.430–3:23.230
zh你請 AI 加一個新功能，
你請 AI 加一個新功能，
3:23.230–3:24.770
zh它動了七八個檔案。
它動了七八個檔案。
3:24.770–3:25.750
zh跑起來，壞了。
跑起來，壞了。
3:25.750–3:27.510
zh這時候的問題不是「壞了」。
這時候的問題不是「壞了」。
3:27.510–3:28.770
zh壞掉可以修。
壞掉可以修。
3:28.770–3:31.550
zh真正的問題是你不知道它剛剛動了哪幾個
真正的問題是你不知道它剛剛動了哪幾個
3:31.550–3:34.120
zh地方，也不知道要退回到哪裡才是好的。
地方，也不知道要退回到哪裡才是好的。
3:34.120–3:36.510
zh你連「半小時前」在哪都指不出來。
你連「半小時前」在哪都指不出來。
3:36.510–3:38.420
zh所以在事情還正常的時候，
所以在事情還正常的時候，
3:38.420–3:40.440
zh你要先留一個回得去的點。
你要先留一個回得去的點。
3:40.440–3:41.650
zh這個動作叫 commit。
這個動作叫 commit。
3:41.650–3:43.160
zh一次 commit 就是一個點。
一次 commit 就是一個點。
3:43.160–3:45.950
zh它記下這一刻你整個專案長什麼樣子，
它記下這一刻你整個專案長什麼樣子，
3:45.950–3:47.690
zh加上你自己寫的一句話：
加上你自己寫的一句話：
3:47.690–3:48.840
zh「第一版做好了」。
「第一版做好了」。
3:48.840–3:50.220
zh之後不管 AI 怎麼改，
之後不管 AI 怎麼改，
3:50.220–3:51.550
zh你都指得回這個點。
你都指得回這個點。
3:51.550–3:53.210
zh所以當 AI 問你「要不要
所以當 AI 問你「要不要
3:53.210–3:54.200
encommit」，
commit」，
3:54.200–3:56.030
zh它在問的是：現在這個狀態，
它在問的是：現在這個狀態，
3:56.030–3:58.110
zh值不值得留一個回得去的點？
值不值得留一個回得去的點？
3:58.110–3:59.180
zh判準很簡單：只要
判準很簡單：只要
3:59.180–4:01.890
zh接下來那件事你不確定會不會壞，就先留。
接下來那件事你不確定會不會壞，就先留。
4:01.890–4:04.640
zh要請 AI 動一個你不熟的地方，先留。
要請 AI 動一個你不熟的地方，先留。
4:04.640–4:06.340
zh要一次改很多檔案，先留。
要一次改很多檔案，先留。
4:06.340–4:08.410
zh改完覺得可以了，再留一個。
改完覺得可以了，再留一個。
4:08.410–4:10.500
zh你不用記指令，只要會講這句話：
你不用記指令，只要會講這句話：
4:10.500–4:12.900
zh這一版是好的，先幫我留一個紀錄點，
這一版是好的，先幫我留一個紀錄點，
4:12.900–4:14.450
zh說明寫「第一版做好了」。
說明寫「第一版做好了」。
4:14.450–4:15.730
zh做完怎麼確認？
做完怎麼確認？
4:15.730–4:18.370
zh這裡有第一個陷阱，而且它最不起眼。
這裡有第一個陷阱，而且它最不起眼。
4:18.370–4:19.740
zh你留的這些點，全部
你留的這些點，全部
4:19.740–4:21.720
zh都還在你自己這台電腦上。
都還在你自己這台電腦上。
4:21.720–4:23.030
zh回到開頭那些檔名。
回到開頭那些檔名。
4:23.030–4:25.580
zh你存了好幾個版本，每一版你都找得到。
你存了好幾個版本，每一版你都找得到。
4:25.580–4:27.450
zh可是對方一份都還沒收到。
可是對方一份都還沒收到。
4:27.450–4:29.790
zh你只是在自己桌上把東西整理好，
你只是在自己桌上把東西整理好，
4:29.790–4:31.230
zh你沒有把它交出去。
你沒有把它交出去。
4:31.230–4:32.400
zhcommit 就是這樣。
commit 就是這樣。
4:32.400–4:33.370
zh它不是上傳。
它不是上傳。
4:33.370–4:36.590
zh這台電腦壞掉，那些點會跟著一起消失。
這台電腦壞掉，那些點會跟著一起消失。
4:36.590–4:38.420
zh所以確認的方式是問它：
所以確認的方式是問它：
4:38.420–4:40.810
zh「這些改動現在只在我的電腦上，
「這些改動現在只在我的電腦上，
4:40.810–4:42.100
zh還是已經上去了？
還是已經上去了？
4:42.100–4:44.600
zh」那另一半怎麼辦？
」那另一半怎麼辦？
4:44.600–4:46.490
zh把你電腦上記好的那些點，送到
把你電腦上記好的那些點，送到
4:46.490–4:48.240
zhGitHub 去，這個動作叫
GitHub 去，這個動作叫
4:48.240–4:48.930
enpush。
push。
4:48.930–4:50.900
zh送上去之後你就有了三樣東西：
送上去之後你就有了三樣東西：
4:50.900–4:53.330
zh一份雲端備份、一個可以給人看的網址、
一份雲端備份、一個可以給人看的網址、
4:53.330–4:56.070
zh還有一份不會因為電腦壞掉而消失的完整
還有一份不會因為電腦壞掉而消失的完整
4:56.070–4:56.470
zh歷史。
歷史。
4:56.470–4:57.840
zh到這裡都很順。
到這裡都很順。
4:57.840–5:00.120
zh但這一段的重點在下一句：
但這一段的重點在下一句：
5:00.120–5:02.500
zh有些東西不能跟著送上去。
有些東西不能跟著送上去。
5:02.500–5:03.890
zh你請 AI 串一個服務，
你請 AI 串一個服務，
5:03.890–5:05.540
zh它可能會需要一組金鑰。
它可能會需要一組金鑰。
5:05.540–5:07.560
zh那組金鑰就像你家大門的鑰匙，
那組金鑰就像你家大門的鑰匙，
5:07.560–5:10.000
zh誰拿到誰就能用你的帳號、花你的錢。
誰拿到誰就能用你的帳號、花你的錢。
5:10.000–5:13.200
zh問題是那組金鑰通常就寫在專案的某個檔案
問題是那組金鑰通常就寫在專案的某個檔案
5:13.200–5:14.630
zh裡。 你 push 的時候，
裡。 你 push 的時候，
5:14.630–5:16.740
zh如果沒有特別交代，它會一起上去。
如果沒有特別交代，它會一起上去。
5:16.740–5:18.540
zh而 GitHub 上的東西是有紀錄的。
而 GitHub 上的東西是有紀錄的。
5:18.540–5:21.330
zh你把它刪掉，紀錄裡還留著。
你把它刪掉，紀錄裡還留著。
5:21.330–5:23.360
zh有人專門在掃這種東西，
有人專門在掃這種東西，
5:23.360–5:25.500
zh而且掃得比你想像中快。
而且掃得比你想像中快。
5:25.500–5:27.810
zh所以這裡要做一件事：告訴 Git
所以這裡要做一件事：告訴 Git
5:27.810–5:29.890
zh哪些檔案不要記帳、不要上傳。
哪些檔案不要記帳、不要上傳。
5:29.890–5:31.880
zh那份清單叫 .gitignore。
那份清單叫 .gitignore。
5:31.880–5:33.130
zh你可以直接這樣講：
你可以直接這樣講：
5:33.130–5:35.610
zh幫我檢查一遍：這個專案裡有沒有金鑰、
幫我檢查一遍：這個專案裡有沒有金鑰、
5:35.610–5:37.420
zh密碼這類不該公開的東西？
密碼這類不該公開的東西？
5:37.420–5:39.450
zh有的話幫我設成不要上傳。
有的話幫我設成不要上傳。
5:39.450–5:40.730
zh做完怎麼確認？
做完怎麼確認？
5:40.730–5:41.990
zh打開 GitHub
打開 GitHub
5:41.990–5:43.410
zh上你那個專案的頁面，
上你那個專案的頁面，
5:43.410–5:45.090
zh用眼睛看一遍檔案清單。
用眼睛看一遍檔案清單。
5:45.090–5:48.120
zh這一段值得你親眼看，因為金鑰一旦公開，
這一段值得你親眼看，因為金鑰一旦公開，
5:48.120–5:50.190
zh光把檔案刪掉也收不回來。
光把檔案刪掉也收不回來。
5:50.190–5:52.300
zh而且如果你發現它真的上去了，
而且如果你發現它真的上去了，
5:52.300–5:54.260
zh正確的做法不是把紀錄刪掉，
正確的做法不是把紀錄刪掉，
5:54.260–5:56.150
zh是立刻去把那把金鑰換掉。
是立刻去把那把金鑰換掉。
5:56.150–5:57.260
zh紀錄可以整理，但
紀錄可以整理，但
5:57.260–5:59.320
zh外流的那幾分鐘裡誰複製走了，
外流的那幾分鐘裡誰複製走了，
5:59.320–6:01.020
zh你不會知道。
你不會知道。
6:01.020–6:03.410
zh東西上去了，但它還不是「正式版本」。
東西上去了，但它還不是「正式版本」。
6:03.410–6:04.480
zhGitHub 上
GitHub 上
6:04.480–6:06.430
zh通常有一份大家公認的正本。
通常有一份大家公認的正本。
6:06.430–6:08.230
zh你送上去的是你自己那一份。
你送上去的是你自己那一份。
6:08.230–6:10.790
zh要讓你的改動變成正本的一部分，
要讓你的改動變成正本的一部分，
6:10.790–6:13.640
zh得先提出來，讓人看過，才會被收進去。
得先提出來，讓人看過，才會被收進去。
6:13.640–6:15.040
zh這個「提出來」叫 PR。
這個「提出來」叫 PR。
6:15.040–6:16.910
zh收進去的那一下叫 merge。
收進去的那一下叫 merge。
6:16.910–6:20.080
zh一個人做專案的時候，這一段常常會被跳過
一個人做專案的時候，這一段常常會被跳過
6:20.080–6:22.120
zh，AI 也可能直接幫你合併。
，AI 也可能直接幫你合併。
6:22.120–6:24.580
zh但只要有第二個人、或第二個 AI
但只要有第二個人、或第二個 AI
6:24.580–6:25.800
zh參與，這一段就是
參與，這一段就是
6:25.800–6:28.360
zh你唯一看得到「誰改了什麼」的地方。
你唯一看得到「誰改了什麼」的地方。
6:28.360–6:29.640
zh做完怎麼確認？
做完怎麼確認？
6:29.640–6:31.730
zh這是我踩過最尷尬的一次。
這是我踩過最尷尬的一次。
6:31.730–6:34.320
zh我們自己的專案裡有一支編號 708
我們自己的專案裡有一支編號 708
6:34.320–6:34.910
zh的提案。
的提案。
6:34.910–6:36.830
zh它被收進去了，正式結案。
它被收進去了，正式結案。
6:36.830–6:38.410
zh結案之後，同一天晚上，
結案之後，同一天晚上，
6:38.410–6:40.610
zh我又往同一個地方推了幾次。
我又往同一個地方推了幾次。
6:40.610–6:43.410
zh每一次都成功，沒有錯誤訊息，沒有警告，
每一次都成功，沒有錯誤訊息，沒有警告，
6:43.410–6:44.380
zh什麼都沒有。
什麼都沒有。
6:44.380–6:46.930
zh然後我回報：推上 708 了。
然後我回報：推上 708 了。
6:46.930–6:48.470
zh那支提案早就關閉了。
那支提案早就關閉了。
6:48.470–6:50.700
zh後面那幾次不屬於任何一個提案，
後面那幾次不屬於任何一個提案，
6:50.700–6:52.400
zh永遠不會進到正本裡面。
永遠不會進到正本裡面。
6:52.400–6:53.630
zh推送本來就會成功，
推送本來就會成功，
6:53.630–6:56.250
zh因為它只負責把東西送到 GitHub，
因為它只負責把東西送到 GitHub，
6:56.250–6:58.500
zh不負責判斷「你送的地方還收不收」。
不負責判斷「你送的地方還收不收」。
6:58.500–7:00.330
zh而 AI 也不會提醒你，
而 AI 也不會提醒你，
7:00.330–7:02.960
zh它照著你說的做，做完回你成功，
它照著你說的做，做完回你成功，
7:02.960–7:05.490
zh因為對它來說那確實成功了。
因為對它來說那確實成功了。
7:05.490–7:07.680
zh所以確認的方式是多問一句：
所以確認的方式是多問一句：
7:07.680–7:09.230
zh這個提案還開著嗎？
這個提案還開著嗎？
7:09.230–7:11.420
zh幫我確認我剛剛推上去的那個 PR
幫我確認我剛剛推上去的那個 PR
7:11.420–7:12.540
zh現在是什麼狀態。
現在是什麼狀態。
7:12.540–7:13.720
zh如果已經 merge
如果已經 merge
7:13.720–7:16.720
zh了，那我後來推的東西是不是還在外面。
了，那我後來推的東西是不是還在外面。
7:16.720–7:18.480
zh到目前為止都是你一個人。
到目前為止都是你一個人。
7:18.680–7:20.080
zh很多人在這裡誤會，
很多人在這裡誤會，
7:20.080–7:22.040
zh是因為AI回報「已commit」的時候
是因為AI回報「已commit」的時候
7:22.040–7:24.840
zh，那個語氣聽起來就像事情辦完了。
，那個語氣聽起來就像事情辦完了。
7:24.840–7:27.220
zh它辦完的是一半：在你這裡辦完了。
它辦完的是一半：在你這裡辦完了。
7:27.220–7:28.560
zh所以整條路是四段，
所以整條路是四段，
7:28.560–7:30.860
zh你記這四段就好：在你電腦上留點，
你記這四段就好：在你電腦上留點，
7:30.860–7:33.080
zh送到GitHub，提出來，被收進去。
送到GitHub，提出來，被收進去。
7:33.080–7:34.220
zh只有最後一段完成，
只有最後一段完成，
7:34.220–7:36.460
zh你的改動才算是正式版本的一部分。
你的改動才算是正式版本的一部分。
7:36.460–7:38.980
zh前面三段做完，東西都還在旁邊等。
前面三段做完，東西都還在旁邊等。
7:38.980–7:40.540
zh這件事的重點是：
這件事的重點是：
7:40.540–7:42.820
zh這個系統在那個情況下不會提醒任何人。
這個系統在那個情況下不會提醒任何人。
7:42.820–7:44.700
zh你不用會判斷，你只要會問。
你不用會判斷，你只要會問。
7:44.700–7:46.900
zh現在假設有第二個人要加進來。
現在假設有第二個人要加進來。
7:46.900–7:49.290
zh他要先把東西拿到自己電腦上，
他要先把東西拿到自己電腦上，
7:49.290–7:52.340
zh而這件事有兩個名字，差別只在第幾次。
而這件事有兩個名字，差別只在第幾次。
7:52.340–7:54.500
zh第一次整包拿走，叫 clone。
第一次整包拿走，叫 clone。
7:54.500–7:57.020
zh之後每次拿別人的新進度，叫 pull。
之後每次拿別人的新進度，叫 pull。
7:57.020–7:59.030
zh這裡有個很多人會踩的地方：
這裡有個很多人會踩的地方：
7:59.030–8:00.200
zh第一次拿的時候，
第一次拿的時候，
8:00.200–8:01.800
zh不要在網頁上按「下載」。
不要在網頁上按「下載」。
8:01.800–8:04.070
zh下載拿到的是一包死檔案，
下載拿到的是一包死檔案，
8:04.070–8:07.250
zh沒有紀錄、沒有歷史，改完也送不回去。
沒有紀錄、沒有歷史，改完也送不回去。
8:07.250–8:08.300
zhclone 拿到
clone 拿到
8:08.300–8:10.490
zh的才是連同整本紀錄的完整專案。
的才是連同整本紀錄的完整專案。
8:10.490–8:13.730
zh合作的循環就是四步：拉下來、改、留點、
合作的循環就是四步：拉下來、改、留點、
8:13.730–8:14.630
zh送上去。
送上去。
8:14.630–8:16.740
zh現在，那個「別人」常常不是人，
現在，那個「別人」常常不是人，
8:16.740–8:18.170
zh而是另一個 AI。
而是另一個 AI。
8:18.170–8:19.290
zh而 AI 不會跟
而 AI 不會跟
8:19.290–8:21.810
zh你說一聲它拉了什麼、改了什麼。
你說一聲它拉了什麼、改了什麼。
8:21.810–8:23.630
zh然後就會遇到最麻煩的那一種：
然後就會遇到最麻煩的那一種：
8:23.630–8:24.990
zh兩邊改到同一個地方。
兩邊改到同一個地方。
8:24.990–8:26.830
zhGit 這時候會停下來，跳出
Git 這時候會停下來，跳出
8:26.830–8:28.920
zhconflict，中文叫衝突。
conflict，中文叫衝突。
8:28.920–8:30.250
zh意思很直白：同一段
意思很直白：同一段
8:30.250–8:32.240
zh內容出現了兩個不同的版本，
內容出現了兩個不同的版本，
8:32.240–8:34.990
zh它不知道該聽誰的，所以它不猜，它問你。
它不知道該聽誰的，所以它不猜，它問你。
8:34.990–8:37.630
zh現在的 AI 遇到衝突通常會自己處理。
現在的 AI 遇到衝突通常會自己處理。
8:37.630–8:39.790
zh它會看懂兩邊各自想做什麼，
它會看懂兩邊各自想做什麼，
8:39.790–8:41.940
zh然後幫你合：有時候是二選一，
然後幫你合：有時候是二選一，
8:41.940–8:43.380
zh有時候是兩邊都留，
有時候是兩邊都留，
8:43.380–8:46.430
zh有時候是乾脆重寫一段把兩邊的功能接
有時候是乾脆重寫一段把兩邊的功能接
8:46.430–8:46.890
zh起來。
起來。
8:46.890–8:48.160
zh做完怎麼確認？
做完怎麼確認？
8:48.160–8:50.720
zh這裡是我覺得最值得你記住的一件事。
這裡是我覺得最值得你記住的一件事。
8:50.720–8:52.740
zhAI 卡住的時候其實很安全，
AI 卡住的時候其實很安全，
8:52.740–8:54.350
zh因為它會停下來問你。
因為它會停下來問你。
8:54.350–8:55.880
zh危險的是它沒有卡住。
危險的是它沒有卡住。
8:55.880–8:58.900
zh它沒有你的產品規劃，它只看得到程式碼。
它沒有你的產品規劃，它只看得到程式碼。
8:58.900–9:00.830
zh所以它可能很順地選了一邊，
所以它可能很順地選了一邊，
9:00.830–9:02.600
zh而那一邊剛好是你不要的，
而那一邊剛好是你不要的，
9:02.600–9:04.480
zh然後回你一句「衝突已解決」。
然後回你一句「衝突已解決」。
9:04.480–9:05.910
zh畫面上什麼警告都沒有。
畫面上什麼警告都沒有。
9:05.910–9:07.150
zh所以合併完之後，
所以合併完之後，
9:07.150–9:09.100
zh你要問的不是「解決了嗎」，是：
你要問的不是「解決了嗎」，是：
9:09.100–9:10.970
zh這次衝突你是怎麼解的？
這次衝突你是怎麼解的？
9:10.970–9:12.670
zh兩邊各自原本想做什麼，
兩邊各自原本想做什麼，
9:12.670–9:14.310
zh你留了哪一邊、為什麼？
你留了哪一邊、為什麼？
9:14.310–9:17.560
zh重點不是它答不答得出來，是它講的那兩邊
重點不是它答不答得出來，是它講的那兩邊
9:17.560–9:18.930
zh，你自己各試一次。
，你自己各試一次。
9:18.930–9:21.860
zh少了一邊，就叫它重做。
少了一邊，就叫它重做。
9:21.860–9:24.020
zh接下來會發生一件很自然的事：
接下來會發生一件很自然的事：
9:24.020–9:25.450
zh你會想同時開兩個。
你會想同時開兩個。
9:25.450–9:27.550
zh一個在幫你改版面，你在旁邊等，
一個在幫你改版面，你在旁邊等，
9:27.550–9:30.440
zh你會想那我為什麼不順便開另一個去處理
你會想那我為什麼不順便開另一個去處理
9:30.440–9:30.860
zh別的。
別的。
9:30.860–9:32.070
zh問題在於，這兩個
問題在於，這兩個
9:32.070–9:34.320
zh視窗會直接改同一個資料夾，而
視窗會直接改同一個資料夾，而
9:34.320–9:35.450
zhGit 不會攔。
Git 不會攔。
9:35.450–9:36.760
zh剛剛那個衝突警告，
剛剛那個衝突警告，
9:36.760–9:38.990
zh只在合併兩份紀錄時才會出現。
只在合併兩份紀錄時才會出現。
9:38.990–9:41.660
zh同一份東西，兩個人同時在上面動手，
同一份東西，兩個人同時在上面動手，
9:41.660–9:43.720
zh這件事你在辦公室裡見過。
這件事你在辦公室裡見過。
9:43.720–9:47.170
zh兩個人各自打開同一份共用檔案，各自改，
兩個人各自打開同一份共用檔案，各自改，
9:47.170–9:47.880
zh各自存。
各自存。
9:47.880–9:49.020
zh最後存的那個人，
最後存的那個人，
9:49.020–9:50.900
zh蓋掉前一個人的所有修改。
蓋掉前一個人的所有修改。
9:50.900–9:52.710
zh而前一個人不會收到通知，
而前一個人不會收到通知，
9:52.710–9:55.660
zh他要到很久以後才會發現自己那半天不見
他要到很久以後才會發現自己那半天不見
9:55.660–9:58.140
zh了。 在專案裡一樣，只是更難察覺，
了。 在專案裡一樣，只是更難察覺，
9:58.140–9:59.620
zh因為兩邊都是 AI，
因為兩邊都是 AI，
9:59.620–10:01.760
zh它們不會抬頭跟你說一聲。
它們不會抬頭跟你說一聲。
10:01.760–10:02.760
zh這時候 AI 可能
這時候 AI 可能
10:02.760–10:04.440
zh會問你要不要開一個分支。
會問你要不要開一個分支。
10:04.440–10:06.800
zh分支的意思是「跟正本隔開來做」，
分支的意思是「跟正本隔開來做」，
10:06.800–10:08.540
zh改壞了整條丟掉就好。
改壞了整條丟掉就好。
10:08.540–10:11.720
zh那是好東西，但它解決不了現在這個問題。
那是好東西，但它解決不了現在這個問題。
10:11.720–10:12.870
zh因為分支再多，你
因為分支再多，你
10:12.870–10:15.490
zh電腦上那個資料夾還是只有一個，兩個
電腦上那個資料夾還是只有一個，兩個
10:15.490–10:17.720
zhAI 還是站在同一張桌子前面。
AI 還是站在同一張桌子前面。
10:17.720–10:20.650
zh真正解決這件事的做法只有一個：給第二個
真正解決這件事的做法只有一個：給第二個
10:20.650–10:22.050
zhAI 第二個資料夾。
AI 第二個資料夾。
10:22.050–10:23.650
zh這個做法叫 worktree。
這個做法叫 worktree。
10:23.650–10:25.920
zh它在你硬碟上多開一個資料夾，
它在你硬碟上多開一個資料夾，
10:25.920–10:27.310
zh裝的是同一個專案，
裝的是同一個專案，
10:27.310–10:29.160
zh但跟原本那個各自獨立。
但跟原本那個各自獨立。
10:29.160–10:31.480
zh一個 AI 待一個，互不干擾。
一個 AI 待一個，互不干擾。
10:31.480–10:32.760
zh做完怎麼確認？
做完怎麼確認？
10:32.760–10:34.050
zh分別問這兩個 AI：
分別問這兩個 AI：
10:34.050–10:35.600
zh你現在在哪個資料夾？
你現在在哪個資料夾？
10:35.600–10:38.090
zh兩個答案不一樣，才是真的分開了。
兩個答案不一樣，才是真的分開了。
10:38.090–10:39.540
zh沒做到的時候會發生什麼，
沒做到的時候會發生什麼，
10:39.540–10:41.230
zh我們是用最貴的方式知道的。
我們是用最貴的方式知道的。
10:41.230–10:42.870
zh有一次，我們有兩個 AI
有一次，我們有兩個 AI
10:42.870–10:45.490
zh同時在做事，而它們沒有各自的資料夾，
同時在做事，而它們沒有各自的資料夾，
10:45.490–10:46.570
zh用的是同一個。
用的是同一個。
10:46.570–10:49.010
zh其中一個想看「原本的版本長什麼樣」，
其中一個想看「原本的版本長什麼樣」，
10:49.010–10:50.240
zh就下了兩道指令。
就下了兩道指令。
10:50.240–10:51.390
zh這兩道指令，一個
這兩道指令，一個
10:51.390–10:53.460
zh人單獨工作的時候完全正常。
人單獨工作的時候完全正常。
10:53.460–10:55.060
zh你不用會下這兩道指令，
你不用會下這兩道指令，
10:55.060–10:57.770
zh你只要知道它們做了什麼：把桌面收乾淨，
你只要知道它們做了什麼：把桌面收乾淨，
10:57.770–10:59.950
zh然後把資料夾換成另一個版本。
然後把資料夾換成另一個版本。
10:59.950–11:01.710
zh但那天不是一個人在工作。
但那天不是一個人在工作。
11:01.710–11:04.370
zh那兩道指令的作用範圍，涵蓋了另一個
那兩道指令的作用範圍，涵蓋了另一個
11:04.370–11:06.140
zhAI還沒有存好的東西。
AI還沒有存好的東西。
11:06.140–11:09.030
zh大約五百七十行被掃掉了，是另一個 AI
大約五百七十行被掃掉了，是另一個 AI
11:09.030–11:10.660
zh還沒留下紀錄的工作。
還沒留下紀錄的工作。
11:10.660–11:11.670
zh而它不會報錯。
而它不會報錯。
11:11.670–11:14.860
zh指令成功執行，畫面上什麼都沒有。
指令成功執行，畫面上什麼都沒有。
11:14.860–11:17.100
zh要等到另一邊回頭找自己的東西，
要等到另一邊回頭找自己的東西，
11:17.100–11:17.840
zh才會發現。
才會發現。
11:17.840–11:19.000
zh如果那個人是你，
如果那個人是你，
11:19.000–11:21.420
zh你的第一個念頭會是自己記錯了。
你的第一個念頭會是自己記錯了。
11:21.420–11:23.650
zh所以這一段你要帶走的只有一句：
所以這一段你要帶走的只有一句：
11:23.650–11:24.770
zh不要讓兩個 AI
不要讓兩個 AI
11:24.770–11:26.470
zh在同一個資料夾裡動手。
在同一個資料夾裡動手。
11:26.470–11:28.670
zh我要同時開兩個來做不同的事，
我要同時開兩個來做不同的事，
11:28.670–11:31.040
zh幫我各開一個獨立的工作資料夾，
幫我各開一個獨立的工作資料夾，
11:31.040–11:33.630
zh不要讓它們共用同一個。
不要讓它們共用同一個。
11:33.630–11:36.000
zh最後講你每天都在怕的那一刻：AI
最後講你每天都在怕的那一刻：AI
11:36.000–11:37.370
zh真的把東西改壞了。
真的把東西改壞了。
11:37.370–11:39.800
zh分兩種情況，而且分法只有一個問題：
分兩種情況，而且分法只有一個問題：
11:39.800–11:41.350
zh你有沒有留過點。
你有沒有留過點。
11:41.350–11:42.860
zh第一種，你還沒留點。
第一種，你還沒留點。
11:42.860–11:44.570
zhAI 剛剛改了一堆檔案，
AI 剛剛改了一堆檔案，
11:44.570–11:46.040
zh你跑起來完全不對。
你跑起來完全不對。
11:46.040–11:48.190
zh這時候的動作叫 restore，
這時候的動作叫 restore，
11:48.190–11:50.950
zh意思是把這些還沒留過點的改動全部丟掉，
意思是把這些還沒留過點的改動全部丟掉，
11:50.950–11:51.970
zh回到上一個點。
回到上一個點。
11:51.970–11:53.900
zh就當剛剛那半小時沒發生過。
就當剛剛那半小時沒發生過。
11:53.900–11:55.750
zh第二種，你已經留過點了，
第二種，你已經留過點了，
11:55.750–11:57.890
zh而且是那個點本身有問題。
而且是那個點本身有問題。
11:57.890–12:00.050
zh這時候比較安全的做法叫 revert。
這時候比較安全的做法叫 revert。
12:00.050–12:02.410
zh它不是把歷史刪掉，是再記一筆，
它不是把歷史刪掉，是再記一筆，
12:02.410–12:04.510
zh內容是把前面那筆抵消掉。
內容是把前面那筆抵消掉。
12:04.510–12:05.720
zh為什麼要繞這一圈？
為什麼要繞這一圈？
12:05.720–12:07.200
zh因為直接刪掉歷史的話，
因為直接刪掉歷史的話，
12:07.200–12:09.420
zh跟你一起做的人手上版本會對不上，
跟你一起做的人手上版本會對不上，
12:09.420–12:11.290
zh而且他不會知道發生過什麼。
而且他不會知道發生過什麼。
12:11.290–12:14.650
zh多記一筆抵消，所有人都看得到「加錯了、
多記一筆抵消，所有人都看得到「加錯了、
12:14.650–12:16.020
zh然後被抵消了」。
然後被抵消了」。
12:16.020–12:17.840
zh這兩個你都不用記，你只要說：
這兩個你都不用記，你只要說：
12:17.840–12:19.510
zh剛剛這次的改動我不要了，
剛剛這次的改動我不要了，
12:19.510–12:21.590
zh請幫我回到上一個正常的版本。
請幫我回到上一個正常的版本。
12:21.590–12:23.550
zhAI 會自己看現在的狀態，
AI 會自己看現在的狀態，
12:23.550–12:24.900
zh決定該用哪一個。
決定該用哪一個。
12:24.900–12:26.180
zh做完怎麼確認？
做完怎麼確認？
12:26.180–12:29.340
zh這裡有兩件事是我覺得沒有人會先告訴你
這裡有兩件事是我覺得沒有人會先告訴你
12:29.340–12:31.570
zh的。 第一，restore 是不可逆的。
的。 第一，restore 是不可逆的。
12:31.570–12:33.500
zh它丟掉的東西沒有回收桶。
它丟掉的東西沒有回收桶。
12:33.500–12:35.300
zh不像刪檔案還能去垃圾桶撿，
不像刪檔案還能去垃圾桶撿，
12:35.300–12:37.240
zh那些改動是真的消失了，Git
那些改動是真的消失了，Git
12:37.240–12:38.740
zh裡面任何地方都找不到，
裡面任何地方都找不到，
12:38.740–12:40.780
zh因為它們從來沒有被記下來過。
因為它們從來沒有被記下來過。
12:40.780–12:42.780
zh剛剛那五百七十行其實不是這一種。
剛剛那五百七十行其實不是這一種。
12:42.780–12:44.140
zh那次是被暫時收起來，
那次是被暫時收起來，
12:44.140–12:45.960
zh還找得回來；restore
還找得回來；restore
12:45.960–12:47.890
zh丟掉的才是真的沒有回收桶。
丟掉的才是真的沒有回收桶。
12:47.890–12:49.540
zh但兩次的傷害是同一種：
但兩次的傷害是同一種：
12:49.540–12:51.530
zh做那件事的不是壞掉的程式，
做那件事的不是壞掉的程式，
12:51.530–12:53.010
zh是收東西的動作本身，
是收東西的動作本身，
12:53.010–12:54.930
zh而你不會知道要去哪裡找。
而你不會知道要去哪裡找。
12:54.930–12:57.310
zh所以在說「回到上一個正常版本」之前，
所以在說「回到上一個正常版本」之前，
12:57.310–12:58.260
zh值得多問一句：
值得多問一句：
12:58.260–13:00.900
zh這個動作會丟掉哪些還沒記錄的改動？
這個動作會丟掉哪些還沒記錄的改動？
13:00.900–13:01.680
zh先列給我看。
先列給我看。
13:01.680–13:04.030
zh第二件是他們很少講的第三種情況：
第二件是他們很少講的第三種情況：
13:04.030–13:05.380
zh東西已經送出去了。
東西已經送出去了。
13:05.380–13:07.580
zh這時候光救你自己的電腦沒有用，要連
這時候光救你自己的電腦沒有用，要連
13:07.580–13:09.610
zhGitHub 上那一份一起處理。
GitHub 上那一份一起處理。
13:09.610–13:12.100
zh你問 AI 的時候要把這件事講出來：
你問 AI 的時候要把這件事講出來：
13:12.100–13:13.920
zh「這批改動我已經推上去了，
「這批改動我已經推上去了，
13:13.920–13:14.920
zh也要一起處理。
也要一起處理。
13:14.920–13:16.590
zh」所以這一章的判準是：
」所以這一章的判準是：
13:16.590–13:18.500
zh在說「回到上一個版本」之前，
在說「回到上一個版本」之前，
13:18.500–13:20.800
zh先問它會丟掉什麼。
先問它會丟掉什麼。
13:20.800–13:23.110
zh救回來之後還有最後一件事，
救回來之後還有最後一件事，
13:23.110–13:25.040
zh而且跟前面幾章不一樣：
而且跟前面幾章不一樣：
13:25.040–13:28.130
zh前面都是事情沒到，這次是事情做到了，
前面都是事情沒到，這次是事情做到了，
13:28.130–13:29.190
zh但份量不對。
但份量不對。
13:29.190–13:31.260
zh這是我踩過最容易被騙的一次。
這是我踩過最容易被騙的一次。
13:31.260–13:34.280
zh有一次我叫 AI 算給我看它改了多少。
有一次我叫 AI 算給我看它改了多少。
13:34.280–13:37.120
zh它回我：刪掉兩千六百二十一行。
它回我：刪掉兩千六百二十一行。
13:37.120–13:38.260
zh兩千六百多行。
兩千六百多行。
13:38.260–13:40.820
zh而我心裡預期的是幾十行。
而我心裡預期的是幾十行。
13:40.820–13:42.710
zh我們當時真的停下來查了。
我們當時真的停下來查了。
13:42.710–13:45.170
zh實際上那次刪掉的是三十行。
實際上那次刪掉的是三十行。
13:45.170–13:47.400
zh比對兩個版本有兩種算法。
比對兩個版本有兩種算法。
13:47.400–13:49.560
zh一種是拿兩邊現在的樣子直接比。
一種是拿兩邊現在的樣子直接比。
13:49.560–13:52.000
zh另一種是先回到你們還一樣的時候，
另一種是先回到你們還一樣的時候，
13:52.000–13:54.050
zh再從那裡往後算你改了什麼。
再從那裡往後算你改了什麼。
13:54.050–13:56.250
zh當你這一份比正本少了幾次更新，
當你這一份比正本少了幾次更新，
13:56.250–13:58.930
zh第一種算法會把別人後來加進去的東西，
第一種算法會把別人後來加進去的東西，
13:58.930–14:00.290
zh全部算成你刪掉的。
全部算成你刪掉的。
14:00.290–14:03.200
zh你手上沒有，於是它就被記成你刪的。
你手上沒有，於是它就被記成你刪的。
14:03.200–14:04.050
zh而你看不出來。
而你看不出來。
14:04.050–14:06.510
zh兩個數字長得一模一樣，都是「刪掉 N
兩個數字長得一模一樣，都是「刪掉 N
14:06.510–14:08.800
zh行」，沒有任何東西告訴你這兩個 N
行」，沒有任何東西告訴你這兩個 N
14:08.800–14:09.730
zh的意思不同。
的意思不同。
14:09.730–14:12.000
zh判準是最好記的一個：不要自己算，看
判準是最好記的一個：不要自己算，看
14:12.000–14:14.220
zhGitHub 自己算的那個數字。
GitHub 自己算的那個數字。
14:14.220–14:15.300
zhGitHub 在
GitHub 在
14:15.300–14:17.460
zh每一個提案上都會顯示改了多少，
每一個提案上都會顯示改了多少，
14:17.460–14:20.020
zh那個數字用的是第二種算法，是權威值。
那個數字用的是第二種算法，是權威值。
14:20.020–14:22.260
zh這個 PR 在 GitHub
這個 PR 在 GitHub
14:22.260–14:25.200
zh上顯示的新增跟刪除行數是多少？
上顯示的新增跟刪除行數是多少？
14:25.200–14:27.290
zh跟我預期改的份量對不對得上？
跟我預期改的份量對不對得上？
14:27.290–14:28.100
zh對得上就過。
對得上就過。
14:28.100–14:30.590
zh對不上，那才是真的要查的時候。
對不上，那才是真的要查的時候。
14:30.590–14:32.940
zh你不用背數字，你只要拿它報的份量，
你不用背數字，你只要拿它報的份量，
14:32.940–14:34.760
zh跟你交代它做的事比一下。
跟你交代它做的事比一下。
14:34.760–14:37.910
zh明顯不成比例，就值得問一句。
明顯不成比例，就值得問一句。
14:37.910–14:39.260
zhAI 問你的那幾句話，
AI 問你的那幾句話，
14:39.260–14:40.700
zh你現在都答得出來了。
你現在都答得出來了。
14:40.920–14:41.900
zhAI沒有騙你。
AI沒有騙你。
14:41.900–14:43.360
zh那兩種算法都是對的，
那兩種算法都是對的，
14:43.360–14:45.000
zh它們回答的是不同的問題。
它們回答的是不同的問題。
14:45.000–14:46.880
zhAI挑了比較常見的那一種，
AI挑了比較常見的那一種，
14:46.880–14:48.740
zh而它不知道你要問的是另一個。
而它不知道你要問的是另一個。
14:48.740–14:50.440
zh其實這支片講的三次，
其實這支片講的三次，
14:50.440–14:53.420
zh全部是同一個形狀：沒有一次是AI亂來，
全部是同一個形狀：沒有一次是AI亂來，
14:53.420–14:56.000
zh每一次都是它做的事情跟你以為它在做的
每一次都是它做的事情跟你以為它在做的
14:56.000–14:57.770
zh事情，中間差了一層。
事情，中間差了一層。
14:57.770–14:59.080
zh要不要 commit，
要不要 commit，
14:59.080–15:01.370
zh問的是值不值得留一個回得去的點。
問的是值不值得留一個回得去的點。
15:01.370–15:02.480
zh要不要開分支，問
要不要開分支，問
15:02.480–15:04.480
zh的是要不要跟正本隔開來做。
的是要不要跟正本隔開來做。
15:04.480–15:05.540
zh要不要發 PR，
要不要發 PR，
15:05.540–15:07.590
zh問的是要不要正式提出去。
問的是要不要正式提出去。
15:07.590–15:09.660
zh但我更想留給你的是另一半。
但我更想留給你的是另一半。
15:09.660–15:12.410
zh這支片每一個動作我都多講了一句「做完
這支片每一個動作我都多講了一句「做完
15:12.410–15:13.390
zh怎麼確認」，因為
怎麼確認」，因為
15:13.390–15:15.660
zh那才是這套工具對你真正的用處：
那才是這套工具對你真正的用處：
15:15.660–15:18.510
zh東西是還在我電腦上，還是已經送出去了？
東西是還在我電腦上，還是已經送出去了？
15:18.510–15:20.670
zh我送去的那個地方，還收不收？
我送去的那個地方，還收不收？
15:20.670–15:23.140
zh兩個 AI 有沒有共用同一個資料夾？
兩個 AI 有沒有共用同一個資料夾？
15:23.140–15:25.690
zh它給我的份量，跟我以為的對得上嗎？
它給我的份量，跟我以為的對得上嗎？
15:25.690–15:28.530
zh四個問題，你不用會做，你只要會問。
四個問題，你不用會做，你只要會問。
15:28.530–15:30.100
zh對不寫程式的人來說，
對不寫程式的人來說，
15:30.100–15:33.230
zh版本控制真正的價值不是多學會一個工具，
版本控制真正的價值不是多學會一個工具，
15:33.230–15:35.930
zh是它把 AI 做的事情變成看得見的。
是它把 AI 做的事情變成看得見的。
15:35.930–15:38.610
zh在那之前，AI 說完成了你只能相信；
在那之前，AI 說完成了你只能相信；
15:38.610–15:40.320
zh有了之後，你可以去看。
有了之後，你可以去看。
15:40.320–15:43.350
zh而這個差別會決定你敢不敢把更大的事情
而這個差別會決定你敢不敢把更大的事情
15:43.350–15:43.960
zh交出去。
交出去。
15:43.960–15:45.180
zh你敢交，是因為你
你敢交，是因為你
15:45.180–15:47.550
zh知道出事了退得回來、看得出來。
知道出事了退得回來、看得出來。
15:47.550–15:49.840
zh這才是時間真正省下來的地方。
這才是時間真正省下來的地方。
15:49.840–15:52.280
zh你不會因為看完這支影片就不再踩到，
你不會因為看完這支影片就不再踩到，
15:52.280–15:53.440
zh我到現在還是會。
我到現在還是會。
15:53.440–15:55.670
zh差別在於現在我知道要去哪裡看。
差別在於現在我知道要去哪裡看。
15:55.670–15:57.610
zh如果你想把這幾個檢查變成習慣，
如果你想把這幾個檢查變成習慣，
15:57.610–16:00.110
zh我在免費社群裡整理了一份可以直接貼給
我在免費社群裡整理了一份可以直接貼給
16:00.110–16:01.080
zhAI 的檢查清單，
AI 的檢查清單，
16:01.080–16:02.980
zh就是這支影片講的這四個問題。
就是這支影片講的這四個問題。
16:02.980–16:04.410
zh連結在資訊欄，網址是
連結在資訊欄，網址是
16:04.410–16:05.680
enguccidgi.
guccidgi.
16:05.680–16:07.210
encom/aifree。
com/aifree。
16:07.210–16:09.640
zh不過在你去看之前，先做一件事。
不過在你去看之前，先做一件事。
16:09.640–16:11.170
zh打開你手邊那個 AI
打開你手邊那個 AI
16:11.170–16:12.700
zh幫你做到一半的東西，
幫你做到一半的東西，
16:12.700–16:15.590
zh問它一句：這些改動現在只在我的電腦上，
問它一句：這些改動現在只在我的電腦上，
16:15.590–16:16.880
zh還是已經上去了？
還是已經上去了？
16:16.880–16:17.730
zh那一次就夠了。
那一次就夠了。
16:17.730–16:19.000
zh你會知道我在講什麼。
你會知道我在講什麼。

影片筆記：AI 改壞了只能整個重做？不用｜非技術人員 Vibe Coding 必學的 GitHub

⚠️ 可先使用，仍有待修正項目

本筆記已完成可閱讀的逐字稿與時間跳轉；下列為待處理問題，建議播放原片確認。

待修正：逐字稿全文快速校讀未完成（已保留自動字幕/原始逐字稿並繼續生成筆記。；未完成的全文速讀項目可在精進模式回聽確認。）
待修正：逐字稿可先使用，但有待校正清單（segment=1 unnatural_sentence_boundary: 標點出現在句首或停在逗號位置，斷句可能不符合文法/口語；segment=6 unnatural_sentence_boundary: 標點出現在句首或停在逗號位置，斷句可能不符合文法/口語）

一句話總結

非工程師使用者應利用 Git 與 GitHub 建立版本控制系統，透過「本地提交、雲端推送、提出請求、合併」四個階段的確認機制，來管理 AI 快速修改帶來的風險，確保在出錯時能安全回退並驗證結果。

核心重點

版本控制的必要性：AI 修改速度快且易出錯，依賴檔名（如 _最終版）管理效率低且痛苦；需要一個能「回退」且能「檢視歷史」的系統。
Git 與 GitHub 的分工：

Git：本地工具，負責記錄每一次存檔時的資料夾狀態及備註，離線可用。
GitHub：雲端平台，負責存放有版本紀錄的資料夾，提供雲端備份、公開網址及完整歷史。

四個階段的確認動作：

Commit (本地提交)：建立本地回退點，確認 .git 資料夾存在。
Push (雲端推送)：上傳至 GitHub，確認金鑰未透過 .gitignore 外洩。
PR (提出請求)：供檢視後合併，確認提案狀態為「開啟」。
Merge (合併)：正式納入正本，確認衝突處理正確。

安全與衝突管理：

使用 .gitignore 隱藏金鑰、密碼等敏感資訊。
多個 AI 同時工作時，使用 worktree 建立獨立資料夾以避免覆蓋衝突。
AI 處理衝突時可能選錯方向，需親自測試。

修復與驗證：

Restore：丟棄未記錄的改動（不可逆）。
Revert：抵消已記錄的錯誤（保留歷史）。
驗證標準：以 GitHub PR 頁面顯示的行數統計為權威，而非 AI 自行計算的結果。

詳細大綱

一、為什麼需要版本控制？

現狀問題：一般使用者靠檔名（如 _最終版、_最終版2、_這版才對）管理版本，效率低且痛苦。
AI 的特性：AI 一次修改的內容多，出錯機率高，需要一個「做壞了可以回得去」的地方。
雲端 vs 本地：僅存在電腦本地會面臨換機、壞機、無法分享的風險；需要雲端備份與歷史紀錄。

二、核心工具與概念定義

Git：安裝在電腦內的程式，負責記錄每一次存檔時的資料夾狀態及備註。離線可用。
GitHub：網路網站，專門存放有版本紀錄的資料夾，提供雲端備份、公開網址及完整歷史。
兩者關係：Git 管紀錄（本地），GitHub 管存放與展示（雲端）。
Google Drive：被指出不適合存放程式碼的原因，僅備份檔案，無版本歷史。

三、版本控制的四個階段與確認動作

階段 1：本地提交 (Commit)

定義：在電腦上建立一個「回得去的點」，記錄當前專案狀態與備註。
時機：不確定是否會壞、修改不熟的地方、一次改很多檔案、改完覺得可以時。
確認動作：
檢查資料夾是否開始記版本。
確認 .git 資料夾存在（預設隱藏）。
關鍵認知：Commit 僅存在本地電腦，未上傳前，電腦壞掉則紀錄消失。

階段 2：雲端推送 (Push)

定義：將本地的 Commit 紀錄上傳至 GitHub。
風險管理 (.gitignore)：
金鑰、密碼等敏感資訊若寫在專案檔案中，Push 時會一併上傳。
GitHub 刪除紀錄後仍留有痕跡，可能被掃描。
做法：建立 .gitignore 清單，指定不記帳、不上傳的檔案。
確認動作：
檢查 GitHub 專案頁面的檔案清單，確認金鑰未公開。
若金鑰已外流，應「換掉金鑰」而非僅刪除檔案。

階段 3：提出請求 (PR - Pull Request)

定義：將自己的改動提出來，供他人檢視後再收進正本。
合併 (Merge)：正式將改動納入正本。
常見誤區：
推送成功不代表提案被接收。若提案已關閉，後續推送不會進入正本。
AI 回報成功僅代表技術上送達，不保證邏輯上被接收。
確認動作：
確認提案是否仍為「開啟」狀態。
確認 PR 狀態，檢查後續推送是否因提案關閉而未進入正本。

階段 4：協作與衝突處理

Clone vs Pull：
Clone：第一次整包下載，包含完整歷史紀錄。
Pull：之後每次拉取別人的新進度。
警告：不要在網頁按「下載」，那會得到無歷史的死檔案。
衝突 (Conflict)：
當兩邊修改同一處時發生。
AI 通常會自動處理衝突（二選一、保留兩邊或重寫）。
危險點：AI 可能選錯方向且無警告。
確認動作：詢問 AI 如何解決衝突，並親自測試兩邊版本。
多 AI 同時工作：
問題：多個 AI 視窗修改同一個資料夾，後存者會覆蓋前者，且無通知。
解決方案 (Worktree)：為第二個 AI 開啟獨立的資料夾（Worktree），讓兩者互不干擾。
確認動作：分別詢問兩個 AI 所在的資料夾路徑，確保不同。

四、錯誤修復與驗證

修復類型：

Restore：丟棄尚未留點（Commit）的改動，回到上一個點。

特性：不可逆，無回收桶。
確認：詢問會丟掉哪些未記錄的改動。

Revert：針對已留點但有問題的版本，新增一筆紀錄來抵消錯誤。

特性：保留歷史，讓協作者看到「加錯」與「抵消」。
行數統計驗證：
AI 計算的行數可能因算法不同（直接比對 vs 回到共同祖先計算）而與預期不符。
權威標準：以 GitHub 在 PR 頁面顯示的新增/刪除行數為準。
確認：比對 GitHub 顯示的份量與預期是否成比例。
案例：講者舉例中，AI 回報刪除「兩千六百二十一行」，實際比對後僅刪除「三十行」，而誤刪了「五百七十行」。

工具 / 模型 / 名詞整理

Git：本地版本控制系統，用於記錄專案歷史。
GitHub：雲端程式碼託管平台，用於備份與協作。
Codex：逐字稿中提到「像 Codex 這種」，指代能直接操作電腦檔案的 AI 模型類型。
Google Drive：僅備份檔案，無版本歷史，不適合存放程式碼。
.gitignore：用於指定不記帳、不上傳的檔案清單（如金鑰、密碼）。
Worktree：Git 功能，用於為第二個 AI 開啟獨立的資料夾，讓多個 AI 互不干擾。
Commit：本地提交，建立回退點。
Push：雲端推送，將本地紀錄上傳至 GitHub。
PR (Pull Request)：提出請求，供檢視後合併。
Clone：第一次整包下載，包含完整歷史紀錄。
Pull：之後每次拉取別人的新進度。
Restore：丟棄尚未留點的改動。
Revert：抵消已記錄的錯誤。
Gucci：影片講者。
guccidgi.com/aifree：逐字稿中的社群連結網址。

操作流程整理

初始化與設定：

安裝 Git。
建立 .gitignore 檔案，將金鑰、密碼等敏感資訊列入清單。

本地開發與提交 (Commit)：

進行程式碼修改。
在關鍵節點執行 Commit，記錄當前狀態與備註。
確認：檢查 .git 資料夾是否存在。

雲端同步 (Push)：

將本地 Commit 上傳至 GitHub。
確認：檢查 GitHub 專案頁面，確認金鑰未公開。若已外流，立即換掉金鑰。

提出請求與合併 (PR & Merge)：

建立 Pull Request (PR)。
確認：確保 PR 狀態為「開啟」。
處理衝突（若發生）。
合併 (Merge) 至正本。

多 AI 協作管理：

若有多個 AI 視窗工作，使用 Worktree 為每個 AI 分配獨立資料夾。
確認：分別確認各 AI 操作的資料夾路徑不同。

錯誤修復與驗證：

若需丟棄未記錄的改動，使用 Restore。
若需抵消已記錄的錯誤，使用 Revert。
驗證：以 GitHub PR 頁面顯示的行數統計為最終驗證標準，比對實際變更量。

值得注意的限制或風險

金鑰外洩風險：即使從 GitHub 刪除檔案，歷史紀錄中仍可能留有痕跡，需定期換掉金鑰。
AI 衝突處理盲點：AI 自動處理衝突時可能選錯方向且無警告，使用者需親自測試。
多 AI 覆蓋風險：多個 AI 修改同一資料夾，後存者會覆蓋前者且無通知，必須使用 Worktree 隔離。
行數統計誤差：AI 自行計算的行數可能因算法不同而與 GitHub 顯示的權威數據不符，應以 GitHub 顯示為準。
本地紀錄丟失：Commit 僅存在本地，若電腦壞掉且未 Push，紀錄將消失。
網頁下載陷阱：在 GitHub 網頁按「下載」會得到無歷史的死檔案，應使用 Clone 或 Pull。

逐字稿辨識疑點

segment 1, 6, 9, 16, 17, 20, 24, 25, 30, 34, 35, 37：標點出現在句首或停在逗號位置，斷句可能不符合文法/口語。
Codex：逐字稿中提到「像 Codex 這種」，指代能直接操作電腦檔案的 AI。需查證此處是否泛指特定模型或泛指具備此能力的 AI 類別。
提案_最終版、提案_最終版2、提案_這版才對：逐字稿中的檔案命名範例，保留原樣。
編號 708 的提案：講者舉例的特定提案編號，保留原樣。
guccidgi.com/aifree：逐字稿中的社群連結網址，保留原樣。
五百七十行：講者舉例中被誤刪的行數，保留原樣。
兩千六百二十一行：AI 回報的刪除行數，保留原樣。
三十行：實際比對後的刪除行數，保留原樣。
峇里島、清邁、檳城：講者旅居地點，保留原樣。

可延伸追問

對於完全不懂命令列的非技術人員，是否有更直觀的圖形介面工具可以執行上述 Git/GitHub 流程？
.gitignore 的具體寫法與常見誤區有哪些？
當 AI 處理衝突時，使用者應如何具體驗證 AI 的選擇是否正確？
Worktree 的實際操作步驟與常見錯誤是什麼？
如何定期檢查 GitHub 歷史紀錄中的金鑰洩漏情況？

尚未產生學習筆記

請在 Telegram 指令最後加上「學習」，例如：videonote 網址英文雙語學習