# Mẹo tránh chạm hạn mức Claude Code khi code mỗi ngày

> Toàn bộ cách tối ưu hạn mức Claude Code: quản lý ngữ cảnh, chọn model, ăn cache, cưỡng chế bằng hooks, đẩy việc sang subagent và model rẻ hơn.

Nguồn: https://camnangai.com/ung-dung-ai/lap-trinh-vien/tranh-cham-han-muc-claude-code  
Xuất bản: 2026-08-14  
Cập nhật: 2026-10-24

**Hạn mức Claude Code** (usage limits) chạy trên hai bộ đếm độc lập: một **cửa sổ lăn 5 giờ**
  (rolling window) để kiểm soát những đợt làm việc dồn dập, và một **hạn mức tuần** tính theo giờ
  tính toán chủ động

Chạm ngưỡng ở bất kỳ bộ đếm nào, bạn sẽ bị chặn cho tới lần reset tiếp theo.

Nếu bạn đang dùng Claude Code như một trình soạn thảo thông thường
thay vì tận dụng nó như một agent, bạn đang phí tài nguyên và sớm muộn cũng chạm trần. Tối ưu
không phải là cố gõ ít đi. Mấu chốt là đừng bắt Claude tiêu tốn tài nguyên cho những phần ngữ cảnh mà nó vốn chẳng cần.

![Hai bộ đếm song song kiểm soát hạn mức Claude Code: một cửa sổ lăn 5 giờ cho các đợt làm việc dồn dập và một hạn mức tuần tính theo giờ tính toán chủ động](https://camnangai.com/articles/tranh-cham-han-muc-claude-code/01-infographic-vn.webp)

## Hạn mức Claude Code đếm cái gì, và vì sao context đầy không phải hết hạn mức

Hệ thống có hai bộ đếm riêng biệt:

1. **Cửa sổ lăn 5 giờ (rolling window):** giới hạn số lượt prompt dựa trên độ dài ngữ cảnh và model
   bạn chọn. Bộ đếm reset sau 5 giờ, tính từ prompt đầu tiên của phiên.
2. **Hạn mức tuần (weekly cap):** tính theo "giờ tính toán chủ động" (active compute hours). Chỉ
   thời gian model thực sự xử lý [token](https://camnangai.com/kien-thuc-ai/token-ai-la-gi) hoặc đang suy luận mới bị
   tính vào hạn mức; lúc bạn ngồi đọc code hay để máy không thì không.

![So sánh cửa sổ ngữ cảnh và hạn mức sử dụng: cửa sổ ngữ cảnh là bộ nhớ trong một phiên, đầy thì Claude tự nén; hạn mức sử dụng là ngân sách theo thời gian, hết thì bạn bị chặn cho tới lần reset](https://camnangai.com/articles/tranh-cham-han-muc-claude-code/02-vn.webp)

Bạn cần phân biệt rõ hai thứ này, vì đây là chỗ nhiều người nhầm nhất. Khi Claude Code báo
[cửa sổ ngữ cảnh](https://camnangai.com/kien-thuc-ai/context-window) sắp đầy, nó sẽ tự nén (auto-compact) để giải phóng
chỗ. Đây là giới hạn bộ nhớ của model trong một phiên, **không phải** dấu hiệu cho thấy bạn đã dùng hết
hạn mức gói đăng ký. Tài liệu của Anthropic nói rõ: cảnh báo context hay auto-compact đều không phải
usage limit. Hai vấn đề này biểu hiện khác nhau, nên cách xử lý cũng chẳng giống nhau.

Anthropic **không công bố hạn ngạch token chính xác** cho từng gói. Thay vào đó, họ chỉ công bố hệ số
nhân (Pro 1x, Max 5x, Max 20x). Những con số bạn thấy trong cộng đồng chỉ là **ước tính**, không phải
thông số chính thức, và còn thay đổi tùy độ dài ngữ cảnh lẫn model đang dùng:

| Gói             | Ước tính mỗi cửa sổ 5 giờ | Ghi chú                             |
| --------------- | ------------------------- | ----------------------------------- |
| Pro ($20/tháng) | ~10–45 lượt prompt        | Có Sonnet 5, Opus 4.8 và Opus 5     |
| Max 5x ($100)   | ~50–225 lượt prompt       | Thêm khoảng 15–35 giờ Opus mỗi tuần |
| Max 20x ($200)  | ~200–900 lượt prompt      | Khoảng 24–40 giờ Opus mỗi tuần      |

Một điểm nữa rất dễ bị bỏ qua: ngân sách này **dùng chung** cho Claude Code, Claude.ai và Cowork.
Nếu bạn dành cả buổi sáng chat trên web, hạn mức còn lại cho Claude Code vào buổi chiều cũng sẽ
giảm tương ứng.

Và có một lời khuyên cũ bạn nên bỏ qua: **"tránh giờ cao điểm" không còn là cách xử lý vấn đề nữa.**
Tháng 5/2026, Anthropic tăng gấp đôi hạn mức cửa sổ 5 giờ cho các gói trả phí, đồng thời **bỏ hẳn
việc cắt giảm theo giờ cao điểm** đối với Pro và Max. Những hướng dẫn vẫn khuyên bạn ngồi code lúc
nửa đêm để tiết kiệm quota đã lỗi thời. Theo tôi, giờ đây chạm trần gần như luôn là vấn đề của quy
trình làm việc, chứ chẳng phải do bạn chọn sai giờ ngồi vào máy.

## Vì sao hạn mức tụt nhanh dù bạn gõ rất ít

Thủ phạm chính là **tích tụ ngữ cảnh** (context accumulation). Claude Code gửi lại toàn bộ lịch sử hội
thoại, định nghĩa công cụ và nội dung các file đang mở trong **mỗi** lượt chat mới. Vì vậy, đến lượt
thứ 50, dù bạn chỉ hỏi một câu một dòng, Claude vẫn phải mang theo cả 49 lượt trước đó. Tin nhắn ngắn
không có nghĩa là rẻ.

![Tích tụ ngữ cảnh qua từng lượt chat: lượt đầu chỉ gửi một câu hỏi, tới lượt thứ 50 mỗi tin nhắn mới vẫn phải kéo theo toàn bộ lịch sử hội thoại phía trước](https://camnangai.com/articles/tranh-cham-han-muc-claude-code/03-vn.webp)

Cách nghĩ hữu ích nhất ở đây là: **thứ quyết định chi phí không phải số tin nhắn, mà là sức nặng ngữ cảnh**,
tức toàn bộ lịch sử, file, bộ nhớ và định nghĩa công cụ mà Claude phải mang theo ở lượt tiếp theo.
Bạn đưa một file log vào lượt đầu tiên của phiên dài 30 lượt thì không phải chỉ trả tiền cho nó một
lần, mà là trả 30 lần.

Có vài thứ ngốn quota nhanh hơn hẳn những thứ còn lại:

- **Agent Teams** ngốn token gấp khoảng **7 lần** một phiên thường khi các teammate chạy ở plan mode
  (chế độ lập kế hoạch), vì mỗi [teammate](https://camnangai.com/ung-dung-ai/lap-trinh-vien/mastering-claude-agent-teams)
  đều duy trì một cửa sổ ngữ cảnh riêng. Bạn phải bật tính năng này thủ công bằng biến môi trường
  `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`.
- **Dán file trực tiếp** vào khung chat tốn tài nguyên hơn nhiều so với việc chỉ đường dẫn để Claude tự
  đọc những phần cần thiết. Nội dung bạn dán sẽ nằm nguyên trong ngữ cảnh cho tới hết phiên.
- **Lạm dụng Opus** cho những việc lặt vặt. Model này đắt hơn Sonnet vài lần cho mỗi lượt. Dùng nó để
  sửa typo là cách nhanh nhất để đốt sạch hạn mức trong ngày.

Ngoài ra còn có những khoản ngốn quota âm thầm: phần tóm tắt hội thoại chạy nền phục vụ tính năng
resume và các lượt kiểm tra trạng thái. Từng khoản không lớn, nhưng chúng vẫn tồn tại ngay cả khi bạn
không gõ gì.

## Giữ phiên nhẹ: dọn đúng lúc và trỏ đúng file

Quản lý ngữ cảnh cho gọn là cách tiết kiệm hiệu quả nhất, mà cũng ít tốn công nhất để bắt đầu.

![Ba thói quen giữ phiên nhẹ: /clear để dừng mang theo việc cũ, /compact để nén lịch sử mà vẫn đi tiếp, và trỏ đúng đường dẫn file thay vì dán cả file vào khung chat](https://camnangai.com/articles/tranh-cham-han-muc-claude-code/04-vn.webp)

**Dùng `/clear` thường xuyên.** Khi chuyển sang một đầu việc không liên quan, hãy reset sạch phiên.
Có một phép thử khá đơn giản: nếu câu lệnh sắp gửi vẫn hoàn toàn hợp lý trong một terminal mới tinh,
thì bạn nên chạy `/clear` trước. File `CLAUDE.md` và các file dự án vẫn còn nguyên, chỉ có lịch sử hội
thoại bị xoá. Tuy nhiên, `/clear` không hoàn tác được, nên nếu còn thông tin nào trong lịch sử cần
giữ lại, hãy chép ra ngoài trước.

Bạn sẽ dễ xác định lúc nào cần `/clear` hơn nếu chia công việc thành từng chặng: xong phần nghiên cứu,
bắt đầu viết; xong kế hoạch, bắt đầu code; sửa xong bug này, chuyển sang bug khác; xong bản nháp,
bắt đầu rà soát. Không cần cứ năm phút lại dọn một lần. Hãy dọn khi một đơn vị công việc đã khép lại.

Một chỗ khác cũng hay bị hiểu sai: `/clear` không hoàn lại phần hạn mức bạn đã tiêu. Lệnh này
cũng không reset cửa sổ 5 giờ. Nó chỉ giúp các lượt **sau đó** không phải gánh thêm lịch sử cũ.
Dọn sớm thì tiết kiệm được kha khá; đợi đến khi chạm trần mới dọn thì chẳng cứu vãn được gì.

**Dùng [`/compact` có chiến thuật.](https://camnangai.com/ung-dung-ai/lap-trinh-vien/lenh-compact-chong-context-rot)**
Nếu đang làm dở mà vẫn cần tiếp tục, `/compact` sẽ nén lịch sử thành bản tóm tắt thay vì xoá sạch.
Đừng cứ thế chạy lệnh rồi để Claude tự quyết định giữ gì: hãy nói rõ phần nào cần được giữ lại, chẳng
hạn `/compact tập trung vào logic API và schema database`. Cứ nhớ quy tắc này: `/clear` để **dừng**
mang theo việc cũ, còn `/compact` để **đi tiếp** việc đang làm.

Nếu muốn có một khuôn dùng lại mỗi lần nén, đây là danh sách những thứ nên giữ và những thứ có thể bỏ:

```text
/compact Chỉ giữ lại:
1. Mục tiêu hiện tại và tiêu chí hoàn thành
2. Các quyết định đã chốt
3. File đã đọc hoặc đã sửa, kèm đường dẫn
4. Link nguồn hoặc trích dẫn phải giữ
5. Lệnh và test đã chạy, kèm kết quả
6. Rủi ro và việc còn treo
7. Bước tiếp theo, càng cụ thể càng tốt

Bỏ đi:
- các phương án đã loại
- phần giải thích lặp lại
- bản nháp cũ
- log dài
- kiến thức nền đã nằm trong file dự án
```

Có hai mốc thực tế bạn nên nhớ khi nén: cân nhắc `/compact` khi phiên vượt khoảng 30 lượt, và **đừng nén giữa
một thay đổi nhiều file chưa commit**, vì sau khi nén, model dễ mất dấu file nào đã sửa. Nếu muốn
để hệ thống tự xử lý sớm hơn, biến `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=50` sẽ kéo mốc auto-compact về
50% cửa sổ, thay vì đợi đến lúc gần đầy.

**Trỏ đích danh file.** Đừng có thói quen dùng `@` để nạp cả thư mục. Tiền tố `@` đưa **nguyên** file
cùng cả cây `CLAUDE.md` của nó vào ngữ cảnh, nên nếu muốn tiết kiệm token, hãy viết đường dẫn trần
rồi chỉ rõ phần cần xem, chẳng hạn "xem hàm `validateToken` trong `src/auth.ts`". Với log và stack trace,
hãy cắt lấy 20–30 dòng liên quan trước khi dán.

**Kết mỗi giai đoạn bằng một file bàn giao.** Đây là thứ giúp bạn dùng `/clear` mà không lo mất dấu
công việc đang làm: một bản brief nghiên cứu, một file kế hoạch, một báo cáo rà soát hoặc một ghi chú
ngắn. Trong đó nên có mục tiêu, phần đã xong, file đã sửa, file đã đọc, lệnh đã chạy, quyết định,
rủi ro, bước kế tiếp và những gì **không** cần làm lại. Có một phép thử nhanh: nếu một đầu việc không
thể tiếp tục sau một lần `/clear`, nghĩa là nó đang phụ thuộc quá nhiều vào bộ nhớ hội thoại.

**Quay lại phiên cũ bằng bản tóm tắt.** Cache của gói đăng ký sống một giờ. Nếu bạn nghỉ lâu hơn rồi
mới mở lại một phiên lớn, lượt tiếp theo sẽ phải nạp lại toàn bộ ngữ cảnh với mức giá không cache
(cache miss). Hãy chọn resume từ bản tóm tắt để tránh khoản chi phí đó.

## Viết prompt sao cho không phải trả tiền hai lần

Phần lớn quota bị đốt vào chuỗi sửa đi sửa lại sau câu hỏi ban đầu, chứ không hẳn do câu hỏi khó.

**Đừng nối chuỗi chỉnh sửa.** Kiểu hội thoại "làm cái này" → "không, ý tôi là..." → "à mà thêm..."
khiến Claude phải gánh cả prompt sai đầu tiên, kết quả sai, lời chỉnh sửa, kết quả sai thứ hai rồi
lại đến lời chỉnh tiếp theo. Cách tiết kiệm hơn nhiều là viết lại yêu cầu cho gọn rồi gửi một lần.
Một brief có cấu trúc (người đọc, mục tiêu, giọng, bắt buộc phải có, tránh gì, định dạng đầu ra)
trông có vẻ dài hơn, nhưng lại xử lý đúng phần mơ hồ vốn khiến bạn phải sửa đi sửa lại.

**Gộp các yêu cầu liên quan vào một lượt.** Yêu cầu "Đổi tên biến `userId` và tách phần validate ra thành
helper" chỉ khiến Claude phải gánh lịch sử một lần, thay vì hai. Tuy nhiên, gộp cũng phải đúng cách:
chỉ gộp những việc **dùng chung ngữ cảnh**. Đừng gộp hai dự án khác nhau, đừng gộp những việc cần
model khác nhau, và cũng đừng yêu cầu kiểu "đọc cả repo rồi trả lời" nếu thứ bạn thực sự cần chỉ là
một hàm.

**Vẽ thay vì tả.** Với kiến trúc, một sơ đồ Mermaid sáu dòng có thể truyền tải đúng lượng thông tin
của ba đoạn văn, và Claude đọc trực tiếp được sơ đồ đó.

**Một lượt đúng rẻ hơn năm lượt tạm được.** Đây là điều cần nhớ khi áp dụng các mẹo hạ cấp model bên
dưới: nếu chọn model yếu hơn khả năng cần thiết của công việc để tiết kiệm, bạn chỉ đang chuyển chi
phí sang phần sửa lại. Bộ nguyên tắc kiểu
Karpathy trong `CLAUDE.md` (nghĩ trước khi
code, ưu tiên phương án đơn giản, sửa đúng chỗ cần sửa, làm theo mục tiêu rõ ràng) giúp tiết kiệm
gián tiếp nhưng đáng kể, vì nó cắt bớt những vòng hỏi lại và viết lại.

## Chọn model và mức effort đúng với việc

Sau khi dọn ngữ cảnh, phối hợp model đúng cách là đòn bẩy lớn thứ hai để tiết kiệm quota.

![Phân tầng model theo độ khó công việc: Haiku cho việc cơ học, Sonnet cho việc code hằng ngày, Opus cho lập kế hoạch và các thay đổi trải rộng](https://camnangai.com/articles/tranh-cham-han-muc-claude-code/05-vn.webp)

**Sonnet là lựa chọn mặc định** cho phần lớn công việc code hằng ngày: thêm tính năng, viết test, sửa lỗi đã khoanh vùng hay refactor thông thường. **Opus** dành cho những lúc bạn thực sự bế tắc hoặc cần thay đổi trên diện rộng, chẳng hạn debug khó, refactor xuyên nhiều module hay quyết định kiến trúc. Còn **Haiku** hợp với các việc cơ học như đổi tên, sinh boilerplate hay giải thích regex. Nếu muốn có cách nghĩ hệ thống hơn về chuyện chọn model, bạn có thể xem [cách chọn mô hình AI phù hợp](https://camnangai.com/kien-thuc-ai/cach-chon-mo-hinh-ai-phu-hop).

Nhìn vào chênh lệch giá sẽ thấy vì sao tôi cho rằng chọn đúng model đáng để bận tâm. Theo bảng giá API, Opus đắt khoảng **1,7 lần** Sonnet trên mỗi token, còn Sonnet đắt khoảng **3 lần** Haiku. Tính ra, Opus ngốn tầm **5 lần** chi phí của Haiku cho cùng một việc. Dùng Opus sửa một dòng CSS chẳng khác nào đốt khoản ngân sách đủ để sửa năm lần như thế bằng Haiku.

Cách phối hợp đáng dùng nhất là **lập kế hoạch bằng Opus, thực thi bằng Sonnet**. Một bản kế hoạch chỉ tốn vài trăm token, trong khi một bản diff 400 dòng đi sai hướng rồi phải revert và làm lại có thể ngốn gấp nhiều lần: hai lượt thực hiện, chưa kể các lượt giải thích xem sai ở đâu. Chế độ `/model opusplan` lo sẵn việc phân chia này: Opus phụ trách lập kế hoạch, Sonnet thực thi. Bạn cũng có thể đổi model ngay giữa phiên mà không mất hội thoại.

Tuy nhiên, cách này chỉ đáng tiền khi bản kế hoạch đủ chi tiết để model rẻ hơn không phải tự đoán. Đừng cứ để Opus viết một mạch từ đầu đến cuối. Hãy bắt nó **hỏi ngược bạn** cho đến khi cả những điều hai bên chưa biết cũng lộ ra, rồi mới chốt thiết kế, các thành phần, interface và luồng dữ liệu. Mỗi lần lập kế hoạch cho một tính năng, bạn cũng nên yêu cầu nó xuất kèm một bản ghi quyết định kiến trúc (ADR, architecture decision record), cập nhật file thuật ngữ (glossary) của dự án rồi commit cả hai vào repo. Những file này giúp các phiên sau trả lời được hai câu hỏi: "vì sao làm thế" và "từ này nghĩa là gì". Mỗi phiên đọc lại chúng chỉ tốn vài trăm token, thay vì bắt Claude đọc lại code rồi tự suy ra. Bộ [skill của Matt Pocock](https://camnangai.com/ung-dung-ai/lap-trinh-vien/ban-do-mattpocock-skills) đã dựng sẵn quy trình này (`CONTEXT.md` làm từ điển thuật ngữ, ADR làm sổ quyết định).

Một khoản quota cũng dễ bị bỏ quên là các **subagent**: chúng vẫn ngốn quota, trong khi mặc định không chạy model rẻ. Biến `CLAUDE_CODE_SUBAGENT_MODEL` cho phép ghim toàn bộ subagent xuống một bậc model rẻ hơn trên cả máy, khỏi phải sửa từng file agent. Những việc như nghiên cứu, rà soát hay quét code gần như chẳng cần đến model mạnh nhất.

Về **Fable 5**: người dùng Pro và Team Standard phải bật usage credits mới dùng được model này, còn gói Max đã có sẵn nhưng bị giới hạn ở khoảng 50% hạn mức tuần.

Cuối cùng, đừng quên **mức effort**. Token suy luận (extended thinking) cũng bị tính như token đầu ra. Với việc đơn giản, bạn có thể hạ `/effort` xuống hoặc tắt hẳn phần suy luận sâu. Trên các model có ngân sách suy nghĩ cố định, biến môi trường `MAX_THINKING_TOKENS` có tác dụng; còn model suy luận thích ứng (adaptive-reasoning) sẽ bỏ qua biến này, nên với nhóm đó, `/effort` mới là núm điều chỉnh thực sự.

## Ăn cache thay vì trả giá đầy mỗi lượt

[Prompt caching](https://camnangai.com/kien-thuc-ai/prompt-caching-ngung-tra-qua-tien) giúp tính phần đầu trùng khớp của request với mức giá rẻ hơn nhiều. Nhưng có một điểm ít người tận dụng: bạn **quyết định được** request có ăn cache hay không, chỉ bằng cách sắp xếp thứ tự nội dung.

Nguyên tắc khá đơn giản: giữ phần đầu (prefix) ổn định, đẩy phần hay thay đổi xuống cuối. Các khối file, tài liệu và bối cảnh dài nên nằm trước, còn câu hỏi cụ thể để sau. Nếu bạn hỏi ba câu về cùng một bộ file, lượt đầu phải trả giá đầy đủ, nhưng hai lượt sau chỉ tốn một phần nhỏ cho prefix đã cache. Ngược lại, nếu chèn câu hỏi hoặc timestamp lên đầu, bạn sẽ tự phá cache mỗi lượt mà chẳng nhận ra.

Theo cùng logic đó, bất cứ thứ gì khiến phần đầu request thay đổi liên tục đều làm bạn tốn thêm tiền: bật/tắt MCP giữa phiên, sửa `CLAUDE.md` liên tục hay chèn nội dung động vào đầu prompt. Một số proxy nén thương mại còn dành riêng một thành phần chỉ để giữ prefix ổn định, giúp cache khớp. Chừng đó cũng đủ thấy đây là khoản rò rỉ chi phí có thật, chứ không phải chuyện tiểu tiết.

## Cắt phần chi phí cố định bạn trả mỗi lượt

Có một khoản bạn phải trả ngay cả trước khi gõ chữ đầu tiên: system prompt, định nghĩa công cụ và tất cả những gì được nạp tự động mỗi phiên. Đây là phần đáng cắt nhất, bởi chi phí của nó lặp lại trong **mọi** lượt chat.

![Khoản chi phí cố định trả mỗi lượt chat: CLAUDE.md luôn được nạp sẵn, Skills chỉ nạp khi được gọi, còn các MCP server đang bật thì chiếm chỗ thường trực](https://camnangai.com/articles/tranh-cham-han-muc-claude-code/06-vn.webp)

**Giữ [`CLAUDE.md`](https://camnangai.com/ung-dung-ai/lap-trinh-vien/claude-md-best-practices) gọn.** File này được nạp vào mọi phiên, nên mỗi dòng thừa đều thành một khoản thuế cố định. Mốc thực tế nên nhắm tới là dưới 200 dòng. Khi muốn thêm một lưu ý, hãy đợi đến lúc bạn phải sửa Claude **lần thứ hai** về cùng một chuyện rồi mới ghi vào, vì lần đầu có thể chỉ là ngẫu nhiên. Cứ vài tuần, bạn nên đọc lại cả file và xoá những gì không còn đúng. Một ghi chú lỗi thời đôi khi còn hại hơn không có ghi chú nào, bởi nó chủ động dẫn Claude đi sai hướng.

Nếu file đã phình to, cách xử lý không phải là ngồi xoá bớt chữ, mà là biến nó thành **mục lục** (progressive disclosure, tức hé lộ dần): giữ một phần lõi ngắn luôn được nạp, kèm các con trỏ tới tài liệu sâu hơn để Claude chỉ mở khi cần đúng việc. Theo Paul Iusztin (Decoding AI, 2026), OpenAI giữ `AGENTS.md` cho một codebase khoảng một triệu dòng do Codex viết ở mức chừng 100 dòng, dùng nó như bản đồ trỏ vào một cây tài liệu có linter kiểm tra tự động.

Có một cái bẫy bạn nên biết: **`@` import không làm file rẻ đi**. Tài liệu Claude Code ghi rõ file được import sẽ nạp cùng lúc với `CLAUDE.md` gọi tới nó. Vì vậy, import chỉ giúp sắp xếp nội dung, chứ không giảm token. Muốn tách thành các tầng thực sự, hãy dùng những thứ chỉ nạp theo nhu cầu: `CLAUDE.md` đặt trong thư mục con, file quy tắc có trường `paths` (chỉ nạp khi Claude làm việc với file khớp mẫu), hoặc một đường dẫn để trần trong backtick để Claude tự mở bằng công cụ đọc file khi cần.

Một biến thể đáng làm là **file quy tắc theo stack**: `.claude/rules/react.md`, `.claude/rules/flutter.md`. Mỗi file chỉ cần mở đầu bằng đúng một dòng "gọi skill này trước", sau đó liệt kê vài lỗi Claude thường lặp lại trong chính codebase của bạn. Danh sách phải xuất phát từ những lần bạn thực sự gặp lỗi, chứ không phải sao chép từ hướng dẫn có sẵn. Chính vì vậy, nó mới ngắn gọn và đáng để giữ lại.

**Chuyển hướng dẫn chuyên biệt sang [Skills](https://camnangai.com/kien-thuc-ai/agent-skills-la-gi).** Những quy trình như review PR hay migration database không cần chiếm chỗ thường trực trong ngữ cảnh. Skills chỉ nạp khi được gọi, nhờ vậy phần nền của bạn gọn hơn.

Tuy nhiên, Skills **không miễn phí**, và đây là chỗ hầu hết bài viết thường bỏ qua: phần `description` của mọi skill nằm trong ngữ cảnh suốt phiên, bất kể bạn có dùng skill đó hay không, bởi Claude dựa vào chính phần mô tả này để quyết định có nạp skill hay không. Đặc tả giới hạn `description` ở 1024 ký tự, danh sách `/skills` chỉ hiển thị tối đa 250 ký tự, còn toàn bộ ngân sách này chiếm khoảng 2% cửa sổ ngữ cảnh (có thể chỉnh qua biến `SLASH_COMMAND_TOOL_CHAR_BUDGET`). Vì vậy, cách làm thực tế là viết `description` thật gọn, dùng đúng những động từ bạn thường gõ như "viết", "review", "chạy test", và đừng giữ hai mươi skill trong khi bạn chỉ dùng ba.

Có một quy tắc ngắn gọn để quyết định thứ gì nên đóng gói thành Skill: **cái gì bạn đã phải giải thích tới lần thứ hai thì đưa vào file.** Quy ước test, luồng deploy, cách log hay style code đều vậy. Nếu thứ Hai nào bạn cũng phải giải thích lại, tức là bạn đang trả tiền mỗi tuần cho cùng một đoạn văn.

**Giảm overhead MCP.** Tool search của Claude Code hiện bật mặc định, nên khi mở phiên, nó chỉ nạp tên công cụ và phần chỉ dẫn của từng server; định nghĩa đầy đủ của công cụ chỉ vào ngữ cảnh khi Claude tìm đến nó. Nhờ vậy, MCP rẻ hơn trước rất nhiều, nhưng chi phí chưa về 0, vì mỗi server vẫn góp tên và chỉ dẫn vào ngữ cảnh. Nếu đặt `ENABLE_TOOL_SEARCH=false`, toàn bộ định nghĩa công cụ sẽ lại được nạp sẵn như trước.

Bạn có thể chạy `/mcp` để xem những gì đang được cấu hình rồi tắt các server không phục vụ công việc hiện tại. Nếu đã có CLI như `gh`, `aws`, `gcloud`, dùng thẳng CLI sẽ tiết kiệm hơn vì chúng không thêm gì vào ngữ cảnh. Tốt hơn nữa, hãy **cài theo phạm vi**: [MCP server](https://camnangai.com/kien-thuc-ai/mcp-la-gi) chỉ phục vụ một dự án thì nên cài ở phạm vi project hoặc local, còn phạm vi user chỉ dành cho những thứ bạn thực sự muốn dùng ở mọi nơi. Danh sách MCP nên cố tình nhàm chán, càng ít thứ không cần thiết càng tốt.

**Cắt cả những công cụ có sẵn mà bạn không bao giờ dùng.** Trong khoản chi phí nền, thứ ngốn nhiều nhất thường không phải `CLAUDE.md` mà là định nghĩa các công cụ dựng sẵn. Iusztin đã công bố số đo trên máy của chính mình sau khi cắt tỉa, với cửa sổ 1 triệu token: tổng cộng 21.400 token thường trực, trong đó system prompt chiếm 4.300, công cụ hệ thống chiếm 11.600, 17 skill chiếm 2.700, còn 46 công cụ MCP gần như không tốn gì nhờ tool search.

Claude Code có một cách chính thức để cắt phần này: dùng luật `deny` ghi **trần tên công cụ** (không kèm ngoặc) để gỡ hẳn công cụ đó khỏi ngữ cảnh, khiến Claude không còn nhìn thấy nó nữa. Nếu bạn không bao giờ cần Claude sửa notebook hay tự tìm web, hãy khai báo trong `settings.json`:

```json
{
  "permissions": {
    "deny": ["NotebookEdit", "WebSearch"]
  }
}
```

Có hai điểm cần để ý. Thứ nhất, hãy đặt luật này trước khi mở phiên, đừng đợi đến giữa chừng mới thêm, vì thay đổi danh sách công cụ cũng làm thay đổi phần đầu request và phá cache. Thứ hai, nếu `CLAUDE.md` đã có quy ước commit và PR riêng, hãy khoá `includeGitInstructions: false` để bỏ phần hướng dẫn git dựng sẵn khỏi system prompt, tránh để hai bộ luật giẫm chân nhau.

Ở đầu bên kia là các [harness](https://camnangai.com/ung-dung-ai/lap-trinh-vien/harness-engineering) (lớp vỏ điều khiển bao quanh model) tối giản như Pi, vốn khởi đầu gần như trống và chỉ thêm tính năng qua plugin. Cách này dành cho những ai muốn tự quyết từng dòng trong khoản chi phí nền. Dù chọn cách nào, bạn cũng nên mở `/context` trước và sau khi cắt để nhìn thấy con số thực tế.

**Cân nhắc tắt bộ nhớ tự động.** Auto memory là các ghi chú Claude tự viết vào `MEMORY.md`. Claude Code nạp 200 dòng đầu (hoặc 25 KB đầu) của file này vào **mọi** phiên. Bạn không viết nó, cũng ít khi đọc lại, nhưng vẫn phải trả tiền cho nó trong từng lượt chat.

Bạn có thể tắt bằng nút gạt trong `/memory` (lưu thành `autoMemoryEnabled: false`) hoặc dùng biến `CLAUDE_CODE_DISABLE_AUTO_MEMORY=1`. Tuy nhiên, chỉ nên tắt khi những thông tin cần duy trì giữa các phiên đã nằm trong các file do bạn kiểm soát và đã commit, tức `CLAUDE.md`, file bàn giao, ADR và file thuật ngữ. Bài [vì sao nên xoá memory.md tự động](https://camnangai.com/ung-dung-ai/lap-trinh-vien/xoa-memory-md-tu-dong-claude-code) phân tích kỹ hơn phần này.

## Đẩy việc nặng ra khỏi phiên chính

Những việc tạo ra output dài như chạy test, đọc log vạn dòng hay quét tài liệu, tôi khuyên bạn đẩy sang [subagent](https://camnangai.com/ung-dung-ai/lap-trinh-vien/mastering-subagents-in-claude-code). Toàn bộ phần output ồn ào nằm lại trong ngữ cảnh của subagent, còn phiên chính chỉ nhận về một bản tóm tắt. Với những tác vụ quét đơn giản, bạn có thể cấu hình subagent chạy Haiku để tiết kiệm thêm.

Một subagent có thể ngốn hàng chục nghìn token để đọc, nhưng cuối cùng chỉ trả về chừng 1.000–2.000 token tóm tắt cho phiên chính. Iusztin đã dùng đúng cách này để phân cụm toàn bộ kho bài viết của Decoding AI: các subagent Haiku và Sonnet đảm nhiệm việc đọc, Opus chỉ nhận bản tóm tắt, nên ngữ cảnh của phiên chính gần như không nhích.

![Đẩy việc nặng sang subagent: toàn bộ output dài từ chạy test hay đọc log nằm lại trong ngữ cảnh của subagent, phiên chính chỉ nhận về một bản tóm tắt ngắn](https://camnangai.com/articles/tranh-cham-han-muc-claude-code/07-vn.webp)

Cách xác định việc nào nên đẩy đi khá đơn giản: **những việc sinh ra thứ bạn sẽ không đọc lại lần thứ hai.** Quét codebase tìm chỗ gọi hàm, audit dependency, dò một file 800 dòng để biết chỗ nào xử lý xác thực: cứ đẩy hết. Nhưng bạn cũng cần biết **không** nên đẩy việc gì: chính là file bạn đang sửa. Nếu giao nó cho subagent, những lượt sau trong phiên chính sẽ dễ hỏng việc, vì phiên chính không còn biết bạn vừa thay đổi những gì.

Một subagent viết cho đúng cần tự giới hạn đầu ra ngay trong phần system prompt:

```markdown
---
name: codebase-scan
description: Tìm mọi chỗ gọi một hàm hoặc một pattern trong repo. Dùng khi được hỏi thứ gì đó được gọi, định nghĩa hoặc import ở đâu.
model: haiku
---

Quét codebase theo pattern được yêu cầu.
Trả về: tổng số chỗ khớp, 3 thư mục nhiều nhất, mỗi thư mục một ví dụ.
Không trích quá 20 dòng code.
```

Hai chi tiết trong file trên đều giúp tiết kiệm token. Dòng `description` chính là điều kiện kích hoạt: subagent không được gọi bằng slash command, mà Claude sẽ tự đọc mô tả rồi quyết định giao việc. Vì vậy, hãy dùng những động từ bạn vẫn thường gõ. Còn câu "không trích quá 20 dòng" sẽ chặn subagent đổ nguyên đống rác về phiên chính, khiến bạn mất trắng phần token vừa tiết kiệm.

Bạn còn có thể tiết kiệm thêm một tầng nữa bằng **hook tiền xử lý**. Thay vì để Claude đọc nguyên file log chỉ để tìm lỗi, một hook `PreToolUse` có thể lọc trước và chỉ trả về phần cần thiết, kéo một yêu cầu từ hàng chục nghìn token xuống còn vài trăm. Khai báo trong `settings.json`:

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [{ "type": "command", "command": "~/.claude/hooks/filter-output.sh" }]
      }
    ]
  }
}
```

Tiếp theo là script tương ứng, cắt output test xuống chỉ còn phần lỗi:

```bash
#!/bin/bash
input=$(cat)
cmd=$(echo "$input" | jq -r '.tool_input.command')

if [[ "$cmd" =~ ^(npm test|pytest|go test) ]]; then
  filtered_cmd="$cmd 2>&1 | grep -A 5 -E '(FAIL|ERROR|error:)' | head -100"
  echo "{\"hookSpecificOutput\":{\"hookEventName\":\"PreToolUse\",\"permissionDecision\":\"allow\",\"updatedInput\":{\"command\":\"$filtered_cmd\"}}}"
else
  echo "{}"
fi
```

## Có nên thay việc đọc file bằng một đồ thị code?

Có, nhưng chỉ với một số codebase nhất định. Đây cũng là chỗ giới thực hành đang chia thành hai phe. Những câu hỏi kiểu "hàm này được gọi ở đâu", "kiến trúc chỗ này ra sao", "xác thực được xử lý ở đâu" ngốn token nhất nếu bạn bắt Claude trả lời bằng cách đọc file, bởi nó phải mở hàng chục file mới rút ra được vài dòng kết luận. Cách ít tốn kém hơn là index codebase thành một đồ thị có thể truy vấn (tree-sitter phân tích AST, tức cây cú pháp của mã nguồn, rồi lưu lại cục bộ) và hỏi trực tiếp đồ thị đó.

Chênh lệch không hề nhỏ: với cùng năm câu hỏi về cấu trúc, truy vấn qua đồ thị tốn khoảng 3.400 token, trong khi dò từng file ngốn tầm 412.000 token. Bài [giảm 90% token Claude Code bằng code graph](https://camnangai.com/ung-dung-ai/lap-trinh-vien/giam-90-token-claude-code-bang-code-graph) và bài về [Graphify](https://camnangai.com/ung-dung-ai/lap-trinh-vien/graphify) đi sâu hơn vào phần cài đặt.

Muốn cách này thực sự tiết kiệm, bạn cần đáp ứng hai điều kiện. Thứ nhất, **index một lần rồi dùng lại**, chỉ chạy phát hiện thay đổi sau khi code đổi đáng kể, vì nếu index lại sau mỗi câu hỏi thì bạn chỉ chuyển chi phí sang chỗ khác. Thứ hai, dùng đồ thị để **định vị**, rồi mới mở đúng những file nó chỉ ra. Đồ thị trả lời câu hỏi "ở đâu" rất rẻ, nhưng muốn biết "sửa thế nào" thì Claude vẫn phải đọc code thật.

Phe còn lại phản đối thẳng, và theo tôi, lập luận của họ đáng để nghe. Đồ thị code là **bản sao thứ hai** của codebase, mà bản sao nào rồi cũng có thể lệch khỏi bản gốc. Mỗi lần refactor là một lần phải index lại; nếu quên index, đồ thị sẽ chỉ sai chỗ nhưng trông vẫn rất chắc chắn, còn nguy hiểm hơn cả việc không có đồ thị. Iusztin lấy chính thiết kế của Claude Code và Codex làm bằng chứng: cả hai đều chọn tìm kiếm lúc chạy bằng `glob` và `grep` thay vì duy trì một index. Nhờ vậy, kết quả luôn khớp với code hiện tại và bạn chẳng phải lo đồng bộ.

Theo phe này, chính cấu trúc code mới là đồ thị mà agent cần: **module rõ ranh giới, interface hẹp, luồng dữ liệu đi một chiều**. Khi mỗi module có thể tự đứng vững (phép thử là nhấc nó sang dự án khác xem có chạy không?), một mục lục ngắn trong `CLAUDE.md` cộng vài lệnh `grep` đã đủ để Claude tìm đúng chỗ. Bạn cũng đừng nhầm đồ thị code với file thuật ngữ hay ADR: hai thứ đó ghi lại khái niệm và quyết định, chứ không mô tả code, nên code có đổi thì bạn cũng không phải sửa chúng.

|                 | Đồ thị code                                       | `grep` lúc chạy + module gọn          |
| --------------- | ------------------------------------------------- | ------------------------------------- |
| Chi phí ban đầu | Index cả repo, rồi index lại sau mỗi thay đổi lớn | Gần như bằng 0                        |
| Độ tươi         | Lệch dần cho tới lần index kế tiếp                | Luôn khớp code hiện tại               |
| Mạnh nhất khi   | Repo lớn, lạ, kế thừa; câu hỏi xuyên module       | Repo bạn tự viết, ranh giới module rõ |
| Rủi ro          | Kết quả cũ dẫn sai mà trông vẫn đúng              | Tốn nhiều lượt đọc nếu cấu trúc bừa   |

Nhìn vào công việc thực tế, nếu bạn đang đọc một codebase lớn do người khác viết, phải đọc nhiều hơn sửa, thì tôi nghiêng về phương án cài đồ thị. Còn với repo của chính mình, tôi sẽ đầu tư công sức tách module cho sạch trước, vì khoản đầu tư đó sinh lợi lâu hơn một cái index phải liên tục nuôi.

## Cưỡng chế thay vì nhắc suông

Đây là ý tôi thấy thuyết phục nhất, nhưng cũng dễ bị bỏ qua nhất: Claude luôn đi theo con đường ít trở lực nhất, nên một hook chặn hẳn thói quen tốn kém có tác dụng hơn một nghìn chữ trong `CLAUDE.md`. Bạn có thể viết "hãy dùng code graph trước khi đọc file" vào hướng dẫn, Claude sẽ tuân thủ được vài lượt rồi lại quay về đọc file. Còn nếu chặn hẳn thì nó không thể cứ thế làm tiếp.

Dưới đây là vài mẫu [hook](https://camnangai.com/kien-thuc-ai/ai-agent-hooks) đáng để bạn dựng:

- **Cổng chặn khám phá.** Một hook `PreToolUse` khớp `Read|Grep|Glob` chặn **lượt đầu tiên** của phiên, kèm một câu nhắc dùng đồ thị code; một hook `PostToolUse` đánh dấu (touch một file cờ trong `/tmp` theo PPID) ngay khi công cụ đồ thị được gọi. Khi thấy cờ đó, cổng tự mở cho phần còn lại của phiên. Chặn một lần là đủ để đổi hành vi, mà không khiến bạn mắc kẹt cả buổi.
- **Chặn các lệnh đọc thô qua Bash.** `cat`, `head`, `tail`, `grep`, `rg`, `find`, `wc` chạy qua Bash sẽ đi thẳng vào ngữ cảnh mà không qua bất kỳ tầng nén nào. Vì vậy, một hook `PreToolUse` cho Bash nên chặn các lệnh này và buộc Claude dùng công cụ có kiểm soát, kể cả các pipe kiểu `| head`, `| tail`, bởi output vẫn tràn vào ngữ cảnh trước khi bị cắt. Nhớ luôn chừa một cửa thoát (một file unlock trong `/tmp`, tự hết hạn sau mười phút) để dùng khi bạn thực sự cần.
- **Nhắc lại luật sau mỗi lần dọn.** Một hook `SessionStart` khớp `startup|resume|clear|compact` sẽ bơm lại quy ước vào phiên, để `/clear` không xoá luôn cả phần kỷ luật.
- **Máy quét chặn lỗi sau mỗi lần sửa.** Một hook `PostToolUse` trên `Edit|Write` chạy linter hoặc một script kiểm tra quy ước, rồi đẩy mọi vi phạm thẳng lại cho Claude sửa ngay. Cách này cắt đúng vòng tốn kém nhất: commit, CI đỏ, giải thích lại, sửa lại.

## Giao phần việc I/O cho một model rẻ hơn

Phần lớn công việc Claude làm cho bạn là I/O chứ không phải suy nghĩ: đọc năm file để trả lời một câu hỏi, sinh một file test mà 80% là boilerplate, hay viết lại tài liệu sau một buổi làm việc. Những việc này tốn kém, nhưng gần như chẳng cần đến trí tuệ của model mạnh nhất.

Công cụ Bash của Claude Code có thể chạy mọi thứ nằm trong `PATH`. Điều đó có nghĩa là chỉ cần một script chừng 60 dòng gọi API của một model rẻ (bất cứ model nào tương thích OpenAI, cửa sổ ngữ cảnh lớn), bạn đã có thể biến việc "đọc 5 file, tốn 8.000 token" thành "đọc một bản tóm tắt 400 token". Không cần MCP server, cũng chẳng cần plugin.

Thông thường, hai công cụ là đủ: một công cụ nhận danh sách đường dẫn cùng một câu hỏi rồi trả về bản tóm tắt; công cụ còn lại nhận đặc tả cùng file tham chiếu, sau đó ghi thẳng file kết quả ra đĩa để Claude chỉ việc soát lại. Nhưng thứ quyết định thành bại không phải script, mà là **luật định tuyến trong `CLAUDE.md`**, đặc biệt là phần quy định khi nào **không** giao việc:

```markdown
## Định tuyến sang model phụ

Giao đi: đọc nhiều file để trả lời một câu hỏi, sinh test/config/tài liệu lặp mẫu.

KHÔNG giao đi:

- việc dưới ~2.000 token (chi phí điều phối không đáng)
- quyết định kiến trúc, debug, code liên quan an toàn
- bất cứ việc cần suy luận cẩn thận
- khi cần số dòng chính xác để sửa file
```

Nếu thiếu vế thứ hai, Claude sẽ đẩy tất cả sang model rẻ, kể cả những việc nó cần tự xử lý. Theo tôi, ranh giới nên nói thẳng ngay từ đầu: **Claude lo phần suy nghĩ, model rẻ lo phần bốc xếp.** Đã có người thử giao cả phần debug và nhận về đúng những lỗi bề mặt, trong khi bug thực sự là một race condition mà chỉ model mạnh mới nhìn ra.

Khoản tiết kiệm lớn nhất thường nằm ở **tài liệu**. Bạn trích phần hội thoại người-đọc-được từ file transcript JSONL của phiên, đưa cho model rẻ cùng với tài liệu hiện có, rồi yêu cầu nó đề xuất những sửa đổi cụ thể để Claude chỉ việc áp dụng. Nhờ vậy, một lần cập nhật tài liệu giảm từ khoảng 5.000 token xuống còn cỡ 200.

Có hai cái bẫy bạn nên biết trước. Thứ nhất, nếu model phụ có chế độ suy luận, hãy đặt `max_tokens` đủ lớn cho cả phần suy nghĩ lẫn phần trả lời. Nếu không, nó có thể tiêu hết ngân sách vào phần suy nghĩ ẩn rồi trả về **rỗng**, chẳng kèm theo lỗi nào. Thứ hai, phần rà soát chéo nên giao cho một model **khác nhà**: đổi nhà cung cấp giúp bắt được những điểm mù mà model cùng dòng thường bỏ qua, đồng thời không ngốn quota Claude của bạn.

## Bốn tầng nén output

Ngoài hook lọc đã nói ở trên, cộng đồng còn dựng sẵn các tầng nén tại bốn vị trí khác nhau trong đường ống. Mỗi tầng xử lý một việc riêng, không trùng nhau, nên bạn cũng chẳng cần cài đủ cả bốn.

1. **Đóng hộp output công cụ.** Thay vì để output đổ thẳng vào hội thoại, tầng này chạy lệnh trong
   một tiến trình cách ly, index toàn bộ output vào một kho tìm kiếm cục bộ rồi chỉ trả về bản tóm
   tắt; khi cần, bạn vẫn tra được phần đầy đủ. Đây cũng là chỗ áp dụng mẹo gộp lệnh: chạy hàng loạt
   trong một lệnh thay vì gọi công cụ riêng lẻ tới ba mươi lần. Cùng nhóm này còn có kiểu "fetch rồi index"
   cho URL, tức là nạp một trang web về, index rồi chỉ trả preview vài KB thay vì nhét cả trang vào.
2. **Nén output shell tại chỗ.** Một binary nhỏ đứng ra chặn output CLI, loại bỏ boilerplate, gộp các
   dòng lặp và cắt gọn có chọn lọc, đặc biệt hợp với `git status`, `npm install` và kết quả test ngắn.
   [RTK](https://camnangai.com/ung-dung-ai/lap-trinh-vien/rust-token-killer-cat-80-token-shell) là ví dụ rõ nhất cho tầng
   này.
3. **Nén ở tầng API.** Một proxy nằm giữa Claude Code và API, nén **toàn bộ** payload gửi đi, từ lịch sử
   hội thoại, system prompt, định nghĩa công cụ cho tới cả `CLAUDE.md`. Đây là tầng duy nhất đụng được
   vào chính khoản chi phí cố định đã nói ở trên. Còn có một biến thể khá lạ: render những khối cồng
   kềnh thành ảnh PNG với chữ dày đặc rồi để model đọc bằng thị giác, vì token ảnh được tính theo kích
   thước ảnh. Đổi lại, thị giác không đáng tin nếu chuỗi cần chính xác từng ký tự: hash, ID và secret
   vẫn nên giữ ở dạng chữ trong các lượt gần nhất.
4. **Nén chính lời Claude nói.** Đây là tầng ít được nhắc tới nhất, dù lập luận đằng sau rất dễ hiểu:
   output của Claude trở thành input của lượt sau, nên độ dài dòng của nó cộng dồn. Một
   output style theo kiểu "nói ngắn" sẽ bỏ hết phần rào trước đón sau, nhưng giữ nguyên code và
   thông báo lỗi; plugin [Caveman](https://camnangai.com/ung-dung-ai/lap-trinh-vien/caveman-la-gi) là phiên bản phổ biến
   nhất của cách làm này. Và nếu áp dụng cùng cách nén lên chính `CLAUDE.md`, bạn sẽ tiết kiệm token
   ở mọi phiên về sau.

Có hai lời cảnh báo tôi nghĩ bạn không nên bỏ qua. **Thứ nhất, chi phí khởi động là có thật:** mỗi MCP server, plugin và hook đều nạp định nghĩa vào mọi phiên. Với một câu hỏi lẻ, một máy được "gia cố" kỹ thậm chí có thể tốn **hơn** bản Claude Code mặc định; chỉ khi khối lượng công việc đủ lớn để bù khoản cố định đó thì bạn mới bắt đầu tiết kiệm. Nếu `/context` cho thấy phần nền tăng vọt, hãy cắt bớt trước khi cài thêm.

**Thứ hai, những công cụ này đều nhìn thấy mọi thứ:** proxy nén, MCP server và hook có thể đọc prompt, code, log lẫn dữ liệu phiên của bạn; các chế độ giảm hỏi quyền cũng đồng nghĩa với việc con người có ít chốt kiểm tra hơn; còn file bộ nhớ dự án phải được gitignore vì chúng rất dễ chứa secret. Đừng cứ copy-paste cả cụm công cụ lên máy đang có dữ liệu nhạy cảm.

## Tìm đúng chỗ rò bằng /usage và /context

Hai lệnh này không tự tiết kiệm token cho bạn. Chúng chỉ ra chỗ đang rò, mà thường thì thủ phạm lại chẳng nằm ở nơi bạn nghĩ tới.

![Kết quả lệnh /usage trong Claude Code: thanh mức dùng của phiên và của tuần, kèm danh sách những đặc điểm đang ngốn hạn mức nhiều nhất như ngữ cảnh trên 150k, nhiều phiên chạy song song và các skill nặng](https://camnangai.com/articles/tranh-cham-han-muc-claude-code/08.webp)

`/usage` hiển thị bảng phân bổ mức tiêu thụ theo skill, subagent, plugin và từng server MCP, kèm tỷ lệ phần trăm của mỗi mục. Nhấn `d` để xem 24 giờ gần nhất, `w` để xem 7 ngày. Khi một mục chiếm từ 10% trở lên, Claude Code sẽ gắn cờ hành vi (behavior flag) cho mục đó; nguyên nhân thường là ngữ cảnh quá dài hoặc cache miss.

Có một điểm bạn cần nhớ: số liệu này chỉ tính từ lịch sử phiên **trên máy này**, nên hoạt động trên máy khác hay trên claude.ai đều không nằm trong đó. Muốn xem con số đầy đủ, bạn phải vào trang Usage trong phần Cài đặt trên claude.ai.

Trong khi đó, `/context` soi riêng phiên hiện tại, từ tin nhắn, file, công cụ, skill, file bộ nhớ cho tới phần chỗ trống còn lại. Đây là cách nhanh nhất để tìm ra những file chẳng liên quan nhưng vẫn đang chiếm chỗ trong ngữ cảnh.

Nếu muốn kiểm soát chặt hơn, hãy **đo trước và sau mỗi thay đổi**. Có những CLI đọc log phiên của Claude Code rồi dựng báo cáo theo ngày, tuần và phiên, chia nhỏ số liệu theo model, cache, dự án và từng khối 5 giờ; ngoài ra còn có dashboard để so chi phí giữa nhiều công cụ AI. Không có số liệu thì bạn chỉ đang đoán theo cảm giác, mà cảm giác thường khiến ta tìm sai chỗ. Bạn cũng nên dựng một status line hiển thị sẵn phần trăm ngữ cảnh, mức dùng 5 giờ và 7 ngày, để biết trần đang đến gần mà không cần gõ thêm lệnh nào.

Thủ phạm thường nằm ở cấu trúc hệ thống chứ không phải thứ bạn vừa gõ. Có người phát hiện một quy trình tự động hoá WordPress chạy nền mới là thứ ngốn phần lớn hạn mức tuần của mình. Nếu không mở `/usage` ra kiểm tra, gần như chẳng có cách nào nhận ra chuyện đó.

Bạn có thể tự soi nhanh bằng bốn câu hỏi dưới đây. Chỉ mất ba mươi giây là đủ để khoanh vùng chỗ đang rò:

1. Phiên gần nhất của bạn dùng model mặc định nào? Nếu là Opus, phần định tuyến đang rò.
2. Có bao nhiêu lượt đọc file hoặc grep thô đổ thẳng vào phiên chính? Nếu quá hai lượt, khâu giao việc đang có vấn đề.
3. Bạn có đang gõ lại thứ mà một Skill lẽ ra phải nhớ hộ không? Nếu có, bạn đang rò ở khâu đóng gói kiến thức.
4. Hội thoại hiện tại có cũ hơn đầu việc bạn đang làm không? Nếu có, vấn đề nằm ở kỷ luật dọn dẹp.

Nếu chỉ sửa được một thứ, tôi sẽ chỉnh phần định tuyến model trước, vì việc này chỉ tốn một dòng lệnh đầu ngày mà kết quả đã thấy ngay trong hôm đó. Còn nếu nhiều chỗ cùng rò, chuyển việc sang subagent là cách giúp bạn đổi được nhiều ngân sách nhất so với công sức bỏ ra.

## Sắp xếp buổi làm việc theo cửa sổ 5 giờ

Cửa sổ lăn có một hệ quả mà ít người tận dụng: phần hạn mức bạn tiêu lúc 9 giờ sáng sẽ **rơi ra khỏi cửa sổ** vào khoảng 2 giờ chiều. Nếu dồn hết việc vào buổi sáng, bạn đang tự bỏ phí phần dung lượng có thể dùng trong thời gian còn lại của ngày. Thay vào đó, hãy chia công việc thành hai hoặc ba đợt, giãn cách nhau để mỗi lần quay lại, bạn có thêm phần hạn mức đã hồi.

Đi cùng cách chia đợt là một mốc dừng rõ ràng: khi đã dùng khoảng **80–90%** phần cửa sổ hữu dụng, đừng bắt đầu đầu việc mới nữa. Hãy dành phần còn lại để kiểm tra những gì vừa làm, ghi bàn giao và để lại một điểm tiếp tục thật gọn. Bị chặn giữa lúc đang sửa nhiều file mà chưa commit sẽ tốn kém hơn nhiều so với việc chủ động dừng sớm mười phút.

## Khi đã chạm hạn mức thì làm gì?

Trước tiên, hãy xác định chính xác bạn đã chạm hạn mức nào. Thông báo lỗi sẽ ghi thời điểm reset. Nếu là hạn mức phiên, cửa sổ 5 giờ sẽ mở lại; còn nếu là hạn mức tuần, bạn phải đợi đến ngày reset cố định của tài khoản.

Đổi model **không** cứu được tình huống này, vì cửa sổ phiên và hạn mức tuần áp dụng chung cho mọi model. Vì vậy, lệnh `/model` không thể mở lại quyền truy cập. Ngoại lệ duy nhất là khi bạn nhận thông báo riêng cho Opus; lúc đó, chuyển sang Sonnet hoặc Haiku vẫn cho phép bạn làm việc tiếp.

Nếu cần làm tiếp ngay, bạn có thể bật **usage credits**. Bạn vẫn tiếp tục công việc, nhưng phần vượt hạn mức sẽ được tính theo giá API tiêu chuẩn. Sau khi `/login` bằng tài khoản đăng ký, chạy `/usage-credits` để mở trang cấu hình. Nhớ đặt hạn mức chi tiêu tháng tại đó, bởi một script vô tình chạy lặp có thể khiến hoá đơn tăng vọt rất nhanh.

Tuy nhiên, usage credits còn đi kèm một cái bẫy: thời gian sống của cache giảm từ **1 giờ xuống 5 phút** khi bạn đang dùng chúng. Điều đó đồng nghĩa với việc cache miss xảy ra thường xuyên hơn hẳn, khiến bạn phải trả nhiều hơn cho cùng một khối lượng công việc. Đặt biến `ENABLE_PROMPT_CACHING_1H=1` để giữ lại mức một giờ.

Nếu bị chặn giữa chừng, đừng cứ gõ tiếp cho tới khi hết hạn mức. Tôi sẽ xử lý theo thứ tự này:

1. Dừng hỏi thêm trong phiên đó.
2. Ghi một file bàn giao, gồm mục tiêu, file đã sửa, quyết định và bước kế tiếp.
3. Mở `/context` để xem phần nào đã cũ và không còn tác dụng.
4. Chạy `/compact` nếu vẫn phải tiếp tục cùng đầu việc; chạy `/clear` nếu đã chuyển sang việc khác.
5. Chuyển các khối dán tay thành file rồi trỏ đường dẫn đến chúng.
6. Kiểm tra `/mcp`, tắt những gì không dùng.
7. Hạ model cho phần việc đơn giản còn lại.

Và hãy nhớ thứ tự ưu tiên: **usage credits là dây an toàn, không phải cách sửa.** Nâng gói cũng vậy. Nếu quy trình vẫn bừa bộn, hạn mức tăng thêm chỉ giúp bạn tiếp tục bừa thêm vài ngày.

## Nếu bạn còn dùng Claude trên web

Vì ngân sách dùng chung, những gì bạn làm trên claude.ai cũng ảnh hưởng trực tiếp đến phần hạn mức còn lại cho terminal. Có bốn thói quen đáng áp dụng:

- **Sửa lại prompt gốc thay vì gửi tin nhắn chỉnh.** Trên web, nút sửa ở tin nhắn của bạn cho phép viết lại nội dung rồi sinh lại câu trả lời, nên lượt sai sẽ bị **thay thế** thay vì cộng thêm vào lịch sử. Đây chính là phiên bản web của quy tắc "đừng nối chuỗi chỉnh sửa" đã nói ở trên.
- **Mở hội thoại mới sau khoảng 15–20 lượt.** Nếu cần giữ lại ngữ cảnh, hãy xin một bản tóm tắt rồi dán nó làm tin nhắn đầu tiên của phiên mới. Như vậy, bạn vẫn giữ được những gì cần biết mà không phải gánh cả phần lịch sử đã phình ra.
- **Đưa file dùng lại nhiều lần vào Projects.** Upload một lần vào đó thay vì đính kèm lại trong từng hội thoại.
- **Tắt những gì không dùng.** Hãy tắt web search, research mode, connectors và để extended thinking **tắt mặc định**, chỉ bật khi bạn thật sự cần model suy nghĩ lâu hơn. Những thông tin về bản thân như "tôi làm nghề gì, viết theo giọng nào" nên nằm trong Memory hoặc một file `.md`, thay vì bắt bạn gõ lại mỗi lần mở chat.

## Nên bắt đầu từ ba thói quen nào?

Bài này khá dài, nên nếu chỉ chọn ba việc để làm ngay hôm nay, tôi sẽ bắt đầu bằng những thứ sau: gõ `/clear` ngay khi hoàn thành một đơn vị công việc; để Sonnet làm mặc định và chỉ gọi Opus khi lập kế hoạch; dùng plan mode (`Shift+Tab`) trước mỗi thay đổi lớn, vì một kế hoạch bị bác bỏ luôn rẻ hơn một bản diff sai phải làm lại. Khi đã duy trì được ba thói quen này, bạn hãy quay lại xử lý phần hook và cắt khoản nền cố định, bởi đó mới là những chỗ có thể giúp tiết kiệm thêm nhiều hơn.

Khác biệt thực sự nằm ở cách bạn hình dung về công cụ này. Người liên tục chạm trần thường dùng Claude Code như một khung chat: kéo dài một hội thoại suốt cả tuần, dùng một model mặc định cho mọi việc và đổ tất cả vào cùng một cửa sổ. Ngược lại, người ít chạm trần xem nó như một bộ điều phối: định tuyến công việc theo độ khó, đẩy phần ồn ào sang subagent, đóng gói kiến thức lặp lại vào file và coi mỗi phiên là một tờ nháp có thể bỏ đi.


  Chênh lệch đủ lớn để một gói Pro dùng đúng cách thường đi xa hơn một gói Max 5x dùng sai cách.


Nhưng điều đáng nhớ nhất không nằm ở một lệnh cụ thể nào. Phần lớn những trường hợp "mới trưa đã hết hạn mức" không phải vì bạn hỏi quá nhiều, mà vì dự án chưa được sắp xếp để Claude biết cần đọc gì, nên nó phải tự đi tìm. Nói cách khác, đây là vấn đề về cấu trúc dự án trước khi là vấn đề về model.

## Tài liệu tham khảo

- [Manage costs effectively — Claude Code Docs](https://code.claude.com/docs/en/costs)
- [Models, usage, and limits in Claude Code — Claude Help Center](https://support.claude.com/en/articles/14552983-models-usage-and-limits-in-claude-code)
- [Manage usage credits for paid Claude plans — Claude Help Center](https://support.claude.com/en/articles/12429409-manage-usage-credits-for-paid-claude-plans)
- [Auto mode is now the default in Claude Code for Pro, Max, and Team plans — Anthropic](https://claude.com/blog/auto-mode-default-in-claude-code)
- [Claude Usage Limits 2026: Every Change, Dated and Explained — explainx.ai](https://explainx.ai/blog/claude-usage-limits-2026-timeline-explained)
- [Claude Code Usage Limits and Pricing, Explained (August 2026) — CC for Everyone](https://ccforeveryone.com/guides/claude-code-limits-and-pricing)
- [Claude Code Rate Limits & Usage Quotas Explained (2026) — TrueFoundry](https://www.truefoundry.com/blog/claude-code-limits-explained)
- [What Actually Helps Me Stop Hitting Claude Code Usage Limits — AI Maker](https://aimaker.substack.com/p/claude-code-usage-limits-token-saving)
- [I Was Burning Through Claude Code's Weekly Limit in 3 Days. Here's How I Fixed It. — Kunal Bhardwaj](https://medium.com/@kunalbhardwaj598/i-was-burning-through-claude-codes-weekly-limit-in-3-days-here-s-how-i-fixed-it-0344c555abda)
- [How I Cut Claude Code Token Usage by 90%+ With 5 Tools, Custom Hooks, and Enforcement — Abid Abdul Gafoor](https://medium.com/@abdulgafoorabid/how-i-cut-claude-code-token-usage-by-90-with-4-tools-custom-hooks-and-enforcement-d3f8d2488cd6)
- [Cut Claude Code Token Costs by 60–90% with Free Open-Source Tools — Santosh Yadav](https://santoshyadav979439.medium.com/cut-claude-code-token-costs-by-60-90-with-free-open-source-tools-2026-2823e9968463)
- [I Stopped Hitting Claude Usage Limits — 10 Workflow Changes That Actually Help — GenAI Unplugged](https://genaiunplugged.substack.com/p/stop-hitting-claude-usage-limits)
- [How I Stopped Hitting Claude's Usage Limits — Artificial Corner](https://artificialcorner.com/p/claude-limits-fix)
- [If You're Still Hitting the Claude Code 5-Hour Wall, You're Doing It Wrong — Data Science Collective](https://medium.com/data-science-collective/if-youre-still-hitting-the-claude-code-5-hour-wall-you-re-doing-it-wrong-25133be04524)
- [Paste This Into Claude, Never Hit a Token Limit Again — Nate B Jones](https://www.youtube.com/watch?v=Y8vAQ1FgNbM)
- [11 Tips to Run Coding Agents 24/7 on One Subscription — Paul Iusztin, Decoding AI](https://www.decodingai.com/p/11-context-engineering-tips-cut-coding-agent-tokens)
- [How Claude remembers your project — Claude Code Docs](https://code.claude.com/docs/en/memory)
- [Configure permissions — Claude Code Docs](https://code.claude.com/docs/en/permissions)
- [Connect Claude Code to tools via MCP — Claude Code Docs](https://code.claude.com/docs/en/mcp)
