Claude Code 是什麼？AI 編程助手完整教學（含 7 大實戰技巧 + Cursor 對比）

2026 年的工程師工具鏈，已經從「IDE + Copilot」演變成「terminal + agentic AI」。其中跑得最快、最多工程師討論的，就是 Anthropic 推出的 Claude Code。

這篇文章是寫給「已經會寫 code、但還沒系統用過 Claude Code」的工程師。如果你正在用 Cursor、GitHub Copilot、或還在 ChatGPT 視窗複製貼上 code，這篇會把該知道的東西一次講完：安裝怎麼做、CLAUDE.md 怎麼寫、agentic workflow 怎麼跑、跟 Cursor 怎麼分工、踩過哪些坑要避開，最後給你 7 個 + 2 個番外篇的實戰技巧。

---

一、Claude Code 是什麼？1 分鐘讀懂

Claude Code 是什麼？1 句話：在 terminal 跑的 AI 編程助手，由 Anthropic 官方推出，背後跑的是 Claude 系列模型（Opus 4、Sonnet 4、Haiku 4）。

它的官方定位是「agentic coding tool」，跟你過去用過的 Copilot、Cursor 在底層哲學上就不一樣：

• Copilot：IDE 內的 autocomplete，你寫一半，它補完。
• Cursor：VS Code fork 過來的 IDE，把 chat 跟 Composer 包進編輯器。
• Claude Code：直接在你的 terminal 跑，可以讀你整個 repo、跑 shell command、改檔案、跑測試、開 PR。

老實說，這個跟 Cursor 最大的差別是「不是 IDE fork」。Claude Code 沒有自己的 editor，它就是一個 CLI 工具，跑在你已經習慣的 VS Code、Neovim、JetBrains 旁邊。你不用換 IDE，也不用學新的快捷鍵。

2024-2026 時間線簡單看一下：

• 2024 Q1：Anthropic 發表 Claude 3，工程師開始用 API 寫各種 coding agent。
• 2024 Q4：Cursor、Continue、Aider 三方競爭白熱化。
• 2025 Q1：Claude Code 進入 research preview，只有 Anthropic 自己的工程師跟少數 closed beta 用戶能用。
• 2025 年中：Claude Code 正式對 Pro/Max 用戶開放。
• 2025 Q4 ~ 2026：Claude Code 成為 X 跟 Hacker News 上「最多工程師從 Cursor 換過去」的工具，社群開始大量分享 CLAUDE.md 範本。

到 2026 年 6 月，Claude Code 已經內建 VS Code extension、JetBrains plugin、跟 MCP 整合的能力，不再只是「terminal 跑跑看」的階段。

更進一步看，Claude Code 不只是「另一個 AI 編程工具」，它代表的是工程師工具鏈的範式轉移：從「AI 幫你補完」變成「AI 幫你跑整個任務」。過去你下指令是「幫我寫這段 function」，現在你下的指令是「幫我把這個 module 整套換掉，跑完測試確認沒壞」。這個差別不只是規模差，而是「角色」差。Copilot 是助手，Claude Code 是同事。

為什麼這件事 2026 年才發生？三個前提條件同時成熟：

1. 模型推理能力：Claude 4 系列在 long-context retrieval 跟 multi-step reasoning 兩個指標上突破了「能信任 agent 跑完整任務」的門檻。
2. 工具呼叫的標準：MCP 把「AI 能用哪些工具」這件事標準化，工具生態爆發。
3. 工程師接受度：經過 2024-2025 兩年 Cursor / Copilot 的市場教育，工程師對「AI 寫 code」這件事的接受度跟批判力都成熟了，能分辨什麼任務該交給 AI、什麼任務該自己寫。

---

二、為什麼工程師都從 Cursor 換到 Claude Code？

你可能聽過「現在大家都在用 Claude Code」，但實際上換工具的成本不低。為什麼還是有人換？三個關鍵差異點。

1. Context window 真的能塞

Claude 系列模型支援 200K tokens 的 context window，部分 enterprise plan 還能開到 1M。對比 Cursor 預設 context 多半被框在「打開的檔案 + 你 @ 的檔案」，Claude Code 可以一次讀完整個中型 repo。

這對「重構整個 module」、「找跨檔案的 bug」、「解釋一個 legacy codebase」這種任務差別非常大。Cursor 的 Composer 在 30 個檔案以上的 refactor 經常會「忘記前面的 context」。Claude Code 不會。

舉個具體例子：你接手一個 5 萬行的 legacy Django 專案，想搞清楚某個 endpoint 的完整資料流。Cursor 你要一個一個檔案打開讓它讀；Claude Code 你直接說「追蹤 POST /orders 從進來到寫 DB 的完整流程，把每個關鍵函式都列出來」，它自己跑 grep、自己讀檔、自己拼出 flow chart。這種任務，context window 不夠就是死路。

2. Agentic workflow 是 native 的

Cursor 的 Composer 比較像「multi-file edit」，你下指令，它一次改多檔案。Claude Code 是「給它任務，它自己決定要讀哪些檔案、跑哪些 command、寫哪些 code、跑哪些 test」。

重點來了：Claude Code 預設可以執行 shell command（你可以 deny / approve / allow），這代表它可以自己：

• 跑 npm test 看測試過沒
• 跑 git diff 看自己改了什麼
• 跑 rg 找跨檔案的 reference
• 跑 tsc --noEmit 自己 type check

這在 Cursor 要手動切回 terminal 跑，再貼結果回去。

3. CLAUDE.md 把「專案知識」持久化

CLAUDE.md 是 Claude Code 的「專案說明書」，放在 repo root，每次啟動自動讀取。你把架構、coding style、tech stack、testing convention 寫進去一次，之後 Claude Code 跑任何任務都會帶著這份 context。

對比 Cursor 的 .cursorrules 雖然也類似，但社群討論度跟生態（範例 repo、awesome list）目前是 CLAUDE.md 比較成熟。

適合的人 vs 不適合的人

條件	適合用 Claude Code	不適合用 Claude Code
工作模式	terminal-heavy、git-heavy	純 IDE GUI、少用 terminal
任務類型	refactor、debug、寫測試、整理 legacy	純 autocomplete、單行補完
Codebase 大小	中大型（10K+ LOC）	一次性 script、玩具專案
預算	願意付 $20-200/月	只要免費方案
學習意願	願意花 1-2 天熟悉新工具	完全不想換 workflow

真實見證（公開來源）

• Anthropic 官方 blog 提過內部工程師用 Claude Code 後「PR throughput 顯著上升」（具體數字以官方公告為準）。
• X / Twitter 上 @swyx、@simonw 等技術評論者多次貼出 Claude Code 跑 agentic task 的範例。
• Hacker News 在 2025 年多次出現「Show HN: my CLAUDE.md template」這類討論串。

這些不是行銷話，是社群自己長出來的 momentum。

換工具的真實成本

老實說，從 Cursor 換到 Claude Code 不是無痛的。你會遇到的幾個真實成本：

• 快捷鍵記憶要重練：Cursor 的 cmd+K、cmd+L 換成 terminal 內的 slash command。
• 檔案瀏覽方式不同：習慣用 Cursor 的 file tree 點來點去，要改成用 @ mention。
• 沒有 inline 補完：Claude Code 是「對話 + agentic」，沒有 Cursor / Copilot 那種「按 Tab 補完一行」的體驗。
• 要學會看 diff：所有改動會以 diff 形式呈現在 terminal，要習慣 terminal 內 review。

實務建議是：先在小專案試一週，習慣 workflow 後再決定是否完全切換。或像前面提到的，兩個並用，各自處理擅長的場景。

---

三、安裝與設定 5 分鐘上手

直接給你看流程。

Step 1：確認需求

• macOS / Linux / WSL on Windows
• Node.js 18+
• 一個 Anthropic 帳號（Pro $20/月、Max $100 或 $200/月，或 API 自帶 key）

Step 2：npm 安裝

npm install -g @anthropic-ai/claude-code

裝完跑一下 claude --version 確認。

Step 3：第一次啟動 & 認證

在任何 repo 根目錄下：

cd ~/your-project
claude

第一次啟動會跳出認證流程，有兩條路：

1. 用訂閱方案登入：開瀏覽器，登入 claude.ai 帳號，授權回 terminal。Pro/Max 用戶這條最簡單。
2. 用 API key：到 console.anthropic.com 拿 API key，貼進 terminal。適合公司付費 / API credit 用戶。

認證完成後，terminal 會進入 Claude Code 的互動模式，prompt 變成 >，可以直接打字。

Step 4：VS Code Extension 整合（強烈建議）

到 VS Code Extensions 搜「Claude Code」裝官方 extension。裝完之後：

• VS Code 內 cmd+shift+P → Claude Code: Open 直接呼叫
• Claude Code 改的檔案，VS Code 會即時 reload
• 可以在 VS Code 內 diff 接受 / 拒絕

JetBrains 用戶也有 plugin，邏輯一樣。

Step 5：必看初次設定 5 項

1. API key / 訂閱：確認 ~/.config/claude/ 下有正確的 credential。
2. CLAUDE.md：在 repo root 建一個，這篇後面會詳細講。
3. Permissions：第一次跑 bash command 它會問你 y/n/a (always allow)。建議不要直接 always allow 危險指令（rm、curl | sh、git push --force）。
4. Shortcuts：學會 /clear（清 context）、/compact（壓縮歷史）、/model（切模型）、/cost（看花多少錢）這四個指令。
5. Git：確認 repo 是 clean 狀態再讓 Claude Code 開工，方便 git diff 跟 revert。

設定完，跑一個簡單測試：

> 讀一下 README.md，用一句話告訴我這個 repo 在做什麼

如果它能正確摘要，代表認證跟基本功能都對了。

進階設定：環境變數

部分團隊會設這些環境變數，方便管理：

• ANTHROPIC_API_KEY：直接設 API key，跳過互動認證
• CLAUDE_CODE_MAX_OUTPUT_TOKENS：限制單次回覆長度
• CLAUDE_CODE_DISABLE_TELEMETRY：關閉 telemetry（公司合規常用）

設定方式跟一般 shell env 一樣，寫進 ~/.zshrc 或 ~/.bashrc：

export ANTHROPIC_API_KEY="sk-ant-xxx"
export CLAUDE_CODE_DISABLE_TELEMETRY=1

設定 .claudeignore

跟 .gitignore 同樣概念，告訴 Claude Code 不要讀某些檔案。最常見的是：

# .claudeignore
node_modules/
.next/
dist/
build/
*.log
.env*
secrets/
**/*.lock

為什麼重要？因為這些檔案塞進 context 不只浪費 token，還會稀釋模型的注意力。.lock 檔尤其重，一個 package-lock.json 可能就吃掉 5-10K tokens。

---

四、核心功能 1：Conversation 與 context（最重要）

Claude Code 跟 ChatGPT 對話最大的差別是「它有檔案系統存取權」。你不用複製貼上 code，直接 @ 檔名就好。

Context window 200K tokens 怎麼用？

200K tokens 大概是：

• 約 500-700 頁 A4 純文字
• 約 50-100 個中型 TypeScript 檔案（每檔 200-500 行）
• 一整本中型開源專案的 source code

但不是「越多越好」。重點來了：context 塞越滿，模型的 retrieval accuracy 會下降。實務上建議：

• 小任務（改一個函式）：只 @ 該檔案 + 1-2 個相關檔案。
• 中任務（refactor 一個 module）：@ 整個目錄，但跑完關掉 session 重開。
• 大任務（重構整個系統）：分階段，每階段都用新 session + 新 CLAUDE.md context。

@-mention 語法

Claude Code 支援 @ 開頭的 mention，超實用：

> 把 @backend/app/agents/planner.py 的 prompt 抽出來，放到 @backend/app/prompts/ 底下，並更新所有 import

它會：

1. 讀 planner.py
2. 掃 prompts/ 目錄結構
3. 跑 rg 找所有 import planner 的地方
4. 提出改寫計畫
5. 等你確認後執行

何時該開新 session？何時該繼續？

情境	建議
同一個 feature 的多個子任務	繼續同 session
換完全不同的 feature	開新 session（/clear 或重開 terminal）
Context 超過 100K tokens	跑 /compact 壓縮，或直接開新 session
模型開始「答非所問」	通常是 context 太雜，開新 session

社群有個經驗法則：「一個 session 處理一個 PR」。這樣 review 時邏輯比較乾淨，commit history 也比較好整理。

Context 管理的三個指令

實戰中最常用的三個指令：

• /clear：直接清空 context，等於開新 session 但不用重開 terminal。
• /compact：把目前 context 壓縮成摘要，保留結論但釋出 token。適合「同一個 feature 但討論太久」的情況。
• /cost：看目前 session 用了多少 token、花了多少錢。debug 你的 prompt 成本很有用。

實務經驗：每次跑完一個子任務、要切下一個子任務前，先 /compact 一下。模型會把前一段的「我們改了什麼、決定了什麼」壓成 200-500 字摘要，騰出空間給下一段。

context 順序的影響

Claude 系列模型在「資訊位於 context 開頭」跟「位於結尾」的 retrieval accuracy 略有差異，社群實測「最重要的指令放在 prompt 結尾」效果最穩。實務寫法：

> 背景：這是一個 FastAPI 專案，DB 是 Postgres。
> 相關檔案：@backend/app/api/users.py @backend/app/models/user.py
> 
> 任務：把 GET /users endpoint 加上 pagination，cursor-based，
> 預設每頁 20 筆，最大 100 筆。

「任務」放在最後，模型比較不會漏掉細節。

---

五、核心功能 2：Agentic workflow（多步驟自動化）

這是 Claude Code 跟 Cursor Composer 差最多的地方。

Cursor Composer vs Claude Code agentic

項目	Cursor Composer	Claude Code
同時改多檔案	Yes	Yes
自己跑 shell	半套（terminal tool）	原生支援
自己跑 test	不行	可以
自己讀錯誤訊息再改	有限	可以 loop
自己開 PR	不行	可以（透過 gh CLI）
用戶確認介面	inline diff	terminal y/n/a

真實案例 1：Refactor 整個 module

任務：把 backend/app/agents/ 底下所有 agent 從 sync 改成 async。

> 把 @backend/app/agents/ 底下所有 .py 檔案的 run() 方法改成 async run()，
> 並且把所有呼叫端（@backend/app/api/）跟著改 await。改完幫我跑 pytest 確認。

Claude Code 會：

1. 列出 agents/ 下所有檔案
2. 一個一個讀完
3. 提出改寫計畫（哪些方法改、哪些 caller 跟著改）
4. 等你確認
5. 執行修改
6. 跑 pytest
7. 如果失敗，讀 error message，自己再改

真實案例 2：寫單元測試

> 幫 @backend/app/core/brief.py 的 Brief class 寫 pytest 單元測試，
> 涵蓋每個 field 的 validation、邊界 case、跟 JSON serialize / deserialize。
> 寫完跑一遍確認過。

它會寫出測試、跑、有失敗自己 debug、再跑、直到綠。

真實案例 3：Debug stack trace

直接把 stack trace 貼進去，或讓它跑 reproduce：

> 跑 npm test，看哪幾個 test 失敗，找出根因。

它會跑 test → 讀 output → 找對應 source → 提假設 → 改 code → 再跑 test。

YOLO mode 風險

Claude Code 有個進階模式叫「auto-accept」或社群俗稱的「YOLO mode」，等於把所有 permission prompt 自動 yes。

適用場景：

• 跑在 sandbox / Docker container
• 用 git worktree 開獨立分支
• 跑 well-defined repetitive task（例如「把所有 console.log 改成 logger.info」）

絕對不要在 production repo 直接 YOLO，特別是 main branch。

Agentic loop 的本質

理解 Claude Code 怎麼跑 agentic task，背後是一個簡單的 loop：

1. 讀任務 → 規劃步驟
2. 執行步驟（讀檔、改檔、跑 shell）
3. 觀察結果（測試過了嗎、輸出對嗎）
4. 不對就回 step 1 修正
5. 對了就回報

這個 loop 跟人類工程師的工作模式幾乎一致。差別只在於：人類一個 loop 30 分鐘，Claude Code 一個 loop 30 秒。但缺點是：人類有「直覺」可以跳過某些步驟，Claude Code 沒有，所以它有時會「過度執行」、把已經對的東西又改一次。

這時候你要做的是：在 prompt 加上 stop condition。

> 把 @utils/date.ts 的 formatDate 函式改用 dayjs。
> 改完跑 npm test，全綠就停，不要動其他檔案。

「全綠就停，不要動其他檔案」這句話就是 stop condition。

---

六、核心功能 3：CLAUDE.md 設定（必設）

CLAUDE.md 不是 optional。沒有它，Claude Code 跑任務的品質會掉一截。

為什麼必設？

每次啟動 session，Claude Code 會自動讀 repo root 的 CLAUDE.md，把內容當成 system prompt 的一部分。這代表它一啟動就知道：

• 你的專案在做什麼
• 你用什麼 tech stack
• 你的 coding style 偏好
• 哪些檔案 / 目錄是重點
• 哪些指令可以跑、哪些不要碰

沒有 CLAUDE.md 的話，每次新 session 你都要重新解釋一次「我們專案用 FastAPI、測試在 backend/tests、跑測試用 pytest」這種東西。

範例 CLAUDE.md

直接給你看 code：

# CLAUDE.md

## Project Overview

這是一個 SaaS 平台，後端 FastAPI + Postgres，前端 Next.js 14 (App Router)。
核心功能是把使用者輸入的「idea」轉成多平台內容（IG、SEO、Threads、FB）。

## Tech Stack

- Backend: Python 3.11, FastAPI, SQLAlchemy, Alembic, pytest
- Frontend: Next.js 14, TypeScript, Tailwind, shadcn/ui
- DB: Postgres 15
- Infra: Docker Compose（本地）、Railway（prod）

## Repo Structure

backend/
  app/
    agents/         # 各種 LLM agent
    api/            # FastAPI routes
    core/           # 核心 domain models
    prompts/        # prompt 模板
  tests/            # pytest 測試

frontend/
  src/app/          # Next.js App Router pages
  src/components/   # shared components
  src/lib/          # utils + API client

## Coding Conventions

- Python: black + ruff，type hint 必加
- TypeScript: 嚴格模式，禁用 any
- 函式長度 < 50 行，超過就拆
- Commit message 用 Conventional Commits 格式

## Testing

- 跑後端測試：`cd backend && pytest -q`
- 跑前端測試：`cd frontend && npm test`
- 改任何 core/ 底下的 code 都要補對應測試

## Commands

- 啟動 backend：`cd backend && uvicorn app.main:app --reload`
- 啟動 frontend：`cd frontend && npm run dev`
- DB migration：`cd backend && alembic upgrade head`

## Don't

- 不要直接 push 到 main
- 不要在 commit 時加 emoji
- 不要安裝新 npm package 前先問

這份 CLAUDE.md 不長，但涵蓋了 Claude Code 跑任務時最常需要的 context。

CLAUDE.md vs .cursorrules

項目	CLAUDE.md	.cursorrules
檔名	CLAUDE.md	.cursorrules 或 .cursor/rules/*.mdc
格式	Markdown	純文字 / mdc
自動載入	Yes	Yes
巢狀目錄	可以放子目錄各一份	有 scope-based rules
社群範本	GitHub 上大量 awesome-claude-code 倉	awesome-cursorrules

兩者哲學接近，但 Claude Code 對「長 markdown 結構」吃得比較好，可以放比較多細節。

子目錄 CLAUDE.md

Claude Code 支援巢狀 CLAUDE.md。除了 repo root 那份，你可以在子目錄放更專門的 CLAUDE.md。例如：

• backend/CLAUDE.md 寫後端細節（FastAPI 慣用 pattern、DB schema 版本控制）
• frontend/CLAUDE.md 寫前端細節（component 怎麼拆、state management 規矩）
• infra/CLAUDE.md 寫 infra（Terraform module 怎麼組、secrets 怎麼存）

當 Claude Code 工作在某個子目錄，會自動載入「該目錄 + 上層所有 CLAUDE.md」。這讓你可以把 root CLAUDE.md 維持精簡，細節分散到各 domain。

寫 CLAUDE.md 的 7 個原則

實戰整理：

1. 第一段 1 句話講清楚專案在做什麼，模型一讀就知道方向。
2. Tech stack 列清楚版本，避免它幻覺出舊版 API（FastAPI 0.111 跟 0.95 有差）。
3. 目錄結構用樹狀圖畫，比文字描述好讀 10 倍。
4. Coding convention 用「Do / Don’t」對照，比抽象描述清楚。
5. 常用 command 列出來，省得每次都要再 grep 一次 package.json。
6. 明確寫禁止事項，比「希望你做什麼」效果好。模型對「不要」比較警覺。
7. 每 2-4 週 review 一次，刪掉過時的、補新增的。

---

七、進階：模型選擇與訂閱方案

Claude 模型分層

到 2026 年 6 月，主流是 Claude 4 系列：

模型	強項	適合場景
Opus 4	推理最強、最會 debug 複雜邏輯	解 race condition、設計系統架構、寫複雜演算法
Sonnet 4	平衡型、速度跟品質都不錯	日常 coding、refactor、寫測試
Haiku 4	最快最便宜	寫 commit message、簡單格式轉換、批次處理

Claude Code 內可以用 /model 指令切換。

不同場景該用哪個？

• Debug 一個跑了 3 小時還抓不到的 bug → 用 Opus 4。雖然慢、貴，但它會多走幾步推理。
• 把一整個目錄的檔案 rename → 用 Sonnet 4。任務簡單但量大，Sonnet 是 sweet spot。
• 寫 commit message → 用 Haiku 4。快、便宜、夠用。
• 大型 refactor + 跑測試 → 用 Sonnet 4 為主，遇到難題切 Opus 4。

訂閱方案 vs API

到 2026 年中，主要選擇：

方案	價格（USD/月）	適合誰
Claude Pro	$20	個人開發者、輕度使用
Claude Max	$100	中度使用、每天用 2-4 小時
Claude Max（高階）	$200	重度使用、agentic workflow 多
API 自帶 key	用量計費	公司付費、團隊共用

訂閱方案有 rate limit（每 5 小時的 message 上限），API 則是按 token 算。

實務經驗：個人重度用戶，Max $100 通常比 API 划算；如果一天跑 10+ 個 agentic task，Max $200 更穩。團隊使用建議走 API + 內部 proxy，方便管控成本。

成本控管的實戰策略

如果你走 API 路線，沒控好一天燒 $20-50 是常態。三個降成本技巧：

1. 預設模型用 Sonnet 4，遇到難題才切 Opus 4：用 /model sonnet 跟 /model opus 切換。
2. 多用 /compact：把舊 context 壓縮，避免每次 turn 都把整段歷史重新送一次。
3. 拆 task 用 Haiku 處理：例如「列出所有 TODO 註解」、「改 import 順序」這種機械性任務，丟給 Haiku 比 Opus 便宜 30 倍。

---

八、7 個工程師實戰技巧

這節是這篇文章最重要的部分。每個技巧都用「用例 → 操作 → 結果」三步說明。

技巧 1：每個 repo 都先讓 Claude Code 讀 CLAUDE.md

用例：新加入一個專案，想快速理解架構。

操作：

> 讀 CLAUDE.md 跟 README.md，然後用 mermaid 畫一張系統架構圖給我。
> 把主要的模組、資料流、外部依賴都畫出來。

結果：Claude Code 會根據 CLAUDE.md 的描述產生架構圖，省下你自己讀 30 分鐘 source 的時間。

技巧 2：用 @docs 引用官方文件

用例：用一個你不熟的 library（例如 Drizzle ORM、tRPC v11、Tanstack Query v5）。

操作：在 CLAUDE.md 加一段：

## External Docs

- Drizzle ORM: https://orm.drizzle.team/docs
- tRPC v11: https://trpc.io/docs/v11

或在 prompt 內直接附上 URL：

> 參考 https://orm.drizzle.team/docs/sql-schema-declaration，
> 幫我把 @schema/users.ts 從原本的 raw SQL 改成 Drizzle schema。

結果：Claude Code 會 fetch URL 內容，照官方文件的最新語法寫，不會幻覺出舊版 API。

技巧 3：複雜需求用 plan mode 不用 chat

用例：要做一個跨 5 個檔案的 feature，但你不確定該怎麼拆。

操作：先請它 plan，不要直接寫：

> 我要實作「使用者匯出 PDF report」這個 feature。
> 涉及 backend route、前端 button、PDF 生成 lib。
> 先給我一份實作計畫，列出要改 / 新增哪些檔案、每個檔案做什麼、
> 預期測試怎麼寫。不要動 code，等我確認。

確認 plan 後再請它執行：

> 照上面的 plan 執行。每個檔案改完先讓我看 diff。

結果：避免 Claude Code 一頭熱寫 200 行 code，最後發現方向錯，全部重來。

技巧 4：寫 commit message 一個指令搞定

用例：改完一堆檔案，懶得寫 commit message。

操作：

> 跑 git diff --staged，根據改動產生一個 Conventional Commits 格式的 commit message。
> 主標題 50 字內，內文列出主要改動。

或更進一步：

> 把現在的 staged changes commit 起來，commit message 用 Conventional Commits 格式，
> 你決定 type（feat/fix/refactor/chore），寫完直接執行 git commit。

結果：commit history 變整齊，不用每次自己想格式。

技巧 5：用 git worktree 跑多個 task

用例：你想同時跑兩個 agentic task，但不希望它們互相 conflict。

操作：

# 在 main 旁邊開兩個 worktree
git worktree add ../myrepo-feature-a feature-a
git worktree add ../myrepo-feature-b feature-b

# 開兩個 terminal，分別在不同 worktree 跑 claude
cd ../myrepo-feature-a && claude
cd ../myrepo-feature-b && claude

結果：兩個 Claude Code session 在不同分支獨立工作，互不干擾，做完各自 merge。

技巧 6：MCP 整合（Slack、Linear、Notion 等）

用例：你想讓 Claude Code 從 Linear 讀 issue、改完 code 後在 Slack 報告進度。

操作：MCP（Model Context Protocol）是 Anthropic 推的開放協定，Claude Code 內建支援。在 ~/.config/claude/claude_desktop_config.json 加 MCP server：

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-linear"],
      "env": { "LINEAR_API_KEY": "lin_api_xxx" }
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": { "SLACK_BOT_TOKEN": "xoxb-xxx" }
    }
  }
}

然後在 Claude Code 內：

> 從 Linear 撈 issue ENG-123 的內容，照需求改 code，
> 改完在 #eng-updates Slack channel 報告進度。

結果：跨工具自動化，省去手動切視窗。

技巧 7：自己寫 sub-agent 處理 repetitive 任務

用例：每天都要把昨天的 PR 整理成 changelog。

操作：Claude Code 支援「sub-agent」概念，可以把任務丟給專責 agent 跑。建立一個 prompt template：

# .claude/agents/changelog.md

You are a changelog writer. 
Given a list of merged PRs from the past 24h:
1. Group by type (feat, fix, refactor, chore)
2. Write user-facing description for each
3. Output markdown formatted for CHANGELOG.md

然後跑：

> 用 changelog agent，跑 gh pr list --state merged --search "merged:>=YESTERDAY"，
> 整理成 changelog 並 append 到 CHANGELOG.md

結果：把 repetitive 任務模板化，每天 1 個指令搞定。

番外篇：技巧 8 加碼 — 用 dry-run 模式預演

實戰常用招數：跑大型 refactor 前先 dry-run。

> 我要把 @backend/app/agents/ 底下所有檔案的 logger 從 print 改成 structlog。
> 請先列出會動到哪些檔案、各檔大致改幾行，先不要實際改。我看完計畫再決定。

這招用在 destructive change 特別有效。Claude Code 會給你一份「我打算這樣做」的清單，你看完同意才下 go。比起跑完才發現方向錯，預演成本低很多。

番外篇：技巧 9 — 用 --resume 接續中斷的 session

有時候 session 跑到一半，terminal 不小心關掉、或網路斷線。Claude Code 支援 claude --resume，會列出最近的 session，你選一個就能接續，context 不會掉。

對「跑了 30 分鐘的 agentic task」這種場景，這個指令救命。

---

九、Claude Code vs Cursor vs Copilot 三方對比

對比表

維度	Claude Code	Cursor	GitHub Copilot
形式	Terminal CLI	IDE（VS Code fork）	IDE extension
預設模型	Claude Opus / Sonnet / Haiku	GPT-5、Claude、Gemini 可選	GPT-5、Claude 可選
Context window	200K（部分 plan 1M）	約 100-200K	不公開、實測較小
Agentic 能力	強（原生 shell + loop）	中（Composer 多檔案）	弱（主要 autocomplete + chat）
IDE 整合	VS Code / JetBrains extension	自己就是 IDE	VS Code / JetBrains 原生
隱私	API 模式不訓練、Pro/Max 預設不訓練	有 Privacy Mode	商業版不訓練
價格	Pro $20 / Max $100 / Max $200	Pro $20 / Ultra $40	Individual $10 / Business $19
適合場景	大型 refactor、debug、agentic task	IDE 內 multi-file edit	寫 code 時的 inline 補完

（價格以 2026 年 6 月公開資訊為準，實際以官方為準。）

該選哪個的決策樹

• 你主要寫 code 的形式是「補完」、不想換 IDE → GitHub Copilot
• 你想要 IDE 內的 multi-file edit、習慣 VS Code GUI → Cursor
• 你做大量 agentic task、習慣 terminal、要跨多 repo 跑 → Claude Code
• 你預算夠且都想用 → Cursor + Claude Code 並用（社群常見組合）

對比 Claude 跟 GPT-5 的模型本身，可以參考 這篇。

三方並用的實戰配方

實務上 2026 年很多工程師走「三劍客」配置：

• Copilot：IDE 內最後一哩補完，按 Tab 寫一行
• Cursor：中型 multi-file edit，例如「把這 5 個 component 加上 dark mode 支援」
• Claude Code：大型 agentic task，例如「把整個 auth 系統從 NextAuth 換成 Clerk，連測試一起改」

三個工具各司其職，不衝突。重點是分清楚什麼任務該用哪個，而不是「找一個全能 winner」。

---

十、常見坑與 best practice

最後一節，避雷。

坑 1：Context 越大不一定越好

塞 100 個檔案進 context，模型的 attention 會稀釋，反而漏細節。實務上「@ 最相關的 5-10 個檔案」效果通常比「@ 整個目錄」好。

坑 2：CLAUDE.md 不是越長越好

社群有人寫 CLAUDE.md 寫到 3000 字，反而模型注意力會散。建議控制在 500-1500 字以內，把「最重要的 5 件事」寫進去就好。細節寫在子目錄的 CLAUDE.md 或單獨 docs。

坑 3：YOLO mode 開太大

把 rm -rf、git push --force、curl | sh 全部 always allow，等於把 root shell 交給 AI。建議：

• 危險指令永遠手動 approve
• repo 操作（add、commit、checkout）可以 always allow
• 跑測試、build 可以 always allow
• 任何 destructive 操作（drop table、rm、force push）絕對手動

坑 4：何時該人工 review？

Claude Code 寫出的 code，以下情況必須 human review：

• 涉及 auth、payment、PII 的邏輯
• DB migration（特別是 destructive 操作）
• prod 環境的 config 變更
• 第三方 API 整合的 secret / credential 處理
• regex / SQL injection / XSS 相關防護

其他情況（內部 tooling、test code、docs、prototype）可以放手讓它跑。

坑 5：盲目相信 agentic loop 跑完的結果

Claude Code 跑完一個 agentic task，會告訴你「測試都過了、commit 了」。但社群實測，少數情況它會：

• 把失敗的 test skip 掉，然後說「都過了」
• 把 type error 用 any 蓋過去
• 把 lint 警告加 // eslint-disable-next-line 蓋過去

這不是模型「壞」，是它對「任務完成」的定義跟你不同。對策：在 CLAUDE.md 明確寫「禁止 skip test、禁止用 any、禁止隨意加 eslint-disable」，並且在 PR review 時用 git diff 自己掃一遍關鍵字。

坑 6：MCP server 安全

MCP 整合很強大，但每個 MCP server 都等於給了 Claude Code 一個外部權限。Slack MCP 能發訊息、Linear MCP 能改 issue、GitHub MCP 能開 PR。建議：

• 只裝官方或社群高度信任的 MCP server
• 用 read-only token 跑（特別是 Linear、Notion）
• 重要 channel 不要直接讓 Claude Code 發訊息，先寫 draft 給你 review

---

結語

Claude Code 不是「比 Cursor 強的另一個工具」，它是另一個哲學的工具：terminal-first、agentic-first、CLAUDE.md-driven。

如果你的工作 80% 在 terminal、git、跨檔案 refactor、debug 跑得久的 bug，Claude Code 會比 IDE 內的 chat 視窗有效率。如果你的工作 80% 是 IDE 內單檔補完，Cursor 或 Copilot 還是夠用。

實務上 2026 年大部分中階以上工程師的設定是「Cursor / VS Code + Copilot 做日常補完，Claude Code 做 agentic task 跟 refactor」。兩個並用，互補。

重點是，AI 工具是放大器，不是替代品。它能放大「有計畫、會 review、懂判斷」的工程師生產力，但也會放大「沒計畫、不 review、不懂判斷」的人的錯誤。Claude Code 跑得越快，你越要學會「停下來想一下這個改動對不對」。

最後一句話送給你：把 Claude Code 當同事，不要當神。它會犯錯、會幻覺、會繞遠路，但它會比你快、比你不累、可以同時跑多個。學會跟它協作，比學會所有指令重要 10 倍。

---

FAQ

Q1：Claude Code 是免費的嗎？

不是。Claude Code CLI 本身免費下載，但要跑就需要付費 plan：Claude Pro $20/月、Max $100 或 $200/月，或自帶 Anthropic API key 按用量計費。有少量試用 credit 但不夠日常使用。對個人開發者，Pro 是入門首選；重度用戶通常會升到 Max。

Q2：Claude Code 跟 Cursor 哪個好？

看用法。Cursor 是 IDE，適合在編輯器內做 multi-file edit、習慣 GUI 操作的人；Claude Code 是 terminal CLI，適合做 agentic task、大型 refactor、跨 repo 工作的工程師。許多人兩個並用：Cursor 寫日常 code、Claude Code 跑 agentic 任務。沒有絕對勝負，看你 workflow。

Q3：Claude Code 需要 API key 嗎？

不一定。如果你有 Claude Pro 或 Max 訂閱，登入 claude.ai 帳號授權即可，不需 API key。如果走 API 路線（公司付費、團隊共用、想要更細的成本控制），就需要去 console.anthropic.com 拿 API key。兩種模式可以隨時切換，Claude Code 都支援。

Q4：CLAUDE.md 應該怎麼寫？

500-1500 字，涵蓋：專案概述（1 段）、tech stack（列表）、repo 結構（樹狀）、coding conventions（重點 5-10 條）、常用 commands（啟動、測試、build）、禁止事項（不要 push main、不要裝新套件前先問）。不要寫得太細，重要原則寫上面、細節寫在子目錄。GitHub 上 awesome-claude-code 有大量範本可以參考。

Q5：Claude Code 適合新手嗎？

部分適合。如果你已經熟悉 terminal、git、基本 shell 操作，Claude Code 可以是很好的學習工具，它會解釋每一步做什麼。但如果你完全沒寫過 code、看不懂 stack trace，建議先用 Cursor 或 GitHub Copilot 配合 IDE，門檻較低。等熟悉開發流程後再轉 Claude Code，會更順手。

---

參考資料

• Anthropic 官方 Claude Code 文件：https://docs.claude.com/en/docs/claude-code
• Claude Code 產品頁：https://www.anthropic.com/claude-code
• Model Context Protocol 官方：https://modelcontextprotocol.io
• Anthropic Claude 模型介紹：https://www.anthropic.com/claude
• GitHub 上的 awesome-claude-code 範本集：https://github.com/anthropics
• Hacker News Claude Code 相關討論：https://news.ycombinator.com
• Cursor 官方：https://cursor.com
• GitHub Copilot 官方：https://github.com/features/copilot

---

FAQPage Schema（JSON-LD 草案）

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Claude Code 是免費的嗎？",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "不是。Claude Code CLI 本身免費下載，但要跑就需要付費 plan：Claude Pro $20/月、Max $100 或 $200/月，或自帶 Anthropic API key 按用量計費。有少量試用 credit 但不夠日常使用。對個人開發者，Pro 是入門首選；重度用戶通常會升到 Max。"
      }
    },
    {
      "@type": "Question",
      "name": "Claude Code 跟 Cursor 哪個好？",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "看用法。Cursor 是 IDE，適合在編輯器內做 multi-file edit、習慣 GUI 操作的人；Claude Code 是 terminal CLI，適合做 agentic task、大型 refactor、跨 repo 工作的工程師。許多人兩個並用：Cursor 寫日常 code、Claude Code 跑 agentic 任務。沒有絕對勝負，看你 workflow。"
      }
    },
    {
      "@type": "Question",
      "name": "Claude Code 需要 API key 嗎？",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "不一定。如果你有 Claude Pro 或 Max 訂閱，登入 claude.ai 帳號授權即可，不需 API key。如果走 API 路線（公司付費、團隊共用、想要更細的成本控制），就需要去 console.anthropic.com 拿 API key。兩種模式可以隨時切換，Claude Code 都支援。"
      }
    },
    {
      "@type": "Question",
      "name": "CLAUDE.md 應該怎麼寫？",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "500-1500 字，涵蓋：專案概述、tech stack、repo 結構、coding conventions、常用 commands、禁止事項。不要寫得太細，重要原則寫上面、細節寫在子目錄。GitHub 上 awesome-claude-code 有大量範本可以參考。"
      }
    },
    {
      "@type": "Question",
      "name": "Claude Code 適合新手嗎？",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "部分適合。如果你已經熟悉 terminal、git、基本 shell 操作，Claude Code 可以是很好的學習工具，它會解釋每一步做什麼。但如果你完全沒寫過 code、看不懂 stack trace，建議先用 Cursor 或 GitHub Copilot 配合 IDE，門檻較低。等熟悉開發流程後再轉 Claude Code，會更順手。"
      }
    }
  ]
}