Quy trình dùng AI làm một sản phẩm từ con số 0: từ ý tưởng tới production mà không thành AI slop
Cách nhanh nhất để có một đống AI slop là mở agent lên và gõ: "Làm cho mình một app chia tiền cho nhóm bạn đi du lịch". Mười phút sau bạn có một app chạy được, đẹp, có cả dark mode. Ba ngày sau bạn có một codebase mà không ai, kể cả AI, giải thích được vì sao chia 100.000đ cho ba người lại ra tổng 99.999đ, và mỗi lần nhờ sửa một chỗ là hỏng hai chỗ khác.
Vấn đề không nằm ở model. Có hai kết quả nghiên cứu mình thấy đáng nhớ trước khi bắt đầu:
- Một thử nghiệm có đối chứng của METR (2025) cho 16 lập trình viên open source kinh nghiệm làm 246 việc thật trên chính repo của họ. Khi được dùng AI, họ chậm hơn khoảng 19%, trong khi chính họ tin là mình nhanh hơn khoảng 20%. Nhóm nghiên cứu cũng dặn đừng suy rộng: đó là repo lớn, quen thuộc, công cụ đầu năm 2025.
- Báo cáo DORA 2025 về phát triển phần mềm có AI kết luận AI là một bộ khuếch đại: team đã có quy trình tốt thì tốt hơn, team đang lộn xộn thì lộn xộn nhanh hơn.
Nên câu hỏi không phải "dùng AI hay không", mà là dùng trong quy trình nào. Bài này là quy trình 7 bước mình gom lại từ những người đã làm thật và viết công khai: cách Harper Reed đi từ ý tưởng tới spec rồi tới plan, Spec Kit của GitHub, quy trình khám phá, lên kế hoạch, code, commit trong tài liệu của Claude Code, quy trình của Addy Osmani, và nguyên tắc review của Simon Willison. Ví dụ xuyên suốt là cái app chia tiền ở trên, làm cho đàng hoàng.
Mỗi bước có thêm một phần "Làm sâu hơn": kỹ thuật cụ thể mình dùng ở bước đó, đóng gói trong một skill của PrimeKit, bộ skill cho Claude Code, Cursor, Codex mà mình tự làm. Nói trước cho rõ để bạn tự cân nhắc: đây là sản phẩm của mình. Vì vậy phần nào mình cũng viết ra cách làm bên trong skill, để bạn áp dụng bằng tay hay bằng công cụ khác vẫn được, không cần cài gì. Ai muốn thử thì cài bằng npx @lovehlmmm/primekit init, rồi gọi /pk:<tên-skill> trong agent.
Toàn cảnh: 7 bước, mỗi bước để lại một file
1. Ý tưởng ──hỏi đáp──▶ spec.md (làm cái gì, cho ai, KHÔNG làm cái gì)
2. Luật chơi ─────────▶ AGENTS.md (stack, quy ước, lệnh test) + lint, CI
GLOSSARY.md, ADR (từ ngữ của domain, quyết định đã chốt)
3. Kế hoạch ──────────▶ plan.md (dữ liệu, API, kiến trúc, rủi ro)
4. Chia việc ─────────▶ tasks.md (việc nhỏ, mỗi việc có cách kiểm)
edge-cases.md (những trường hợp biên phải có test)
5. Vòng lặp từng việc ▶ test → code → kiểm → commit nhỏ
6. Review ────────────▶ PR mà bạn giải thích được từng dòng
7. Ship và sau đó ────▶ lỗi gặp phải biến thành kiểm tra tự động
Điểm chung của mọi quy trình mình đọc: AI viết code, người quyết định làm cái gì và kiểm cái gì. Các file ở cột phải là thứ giữ cho quyết định đó không bị trôi mất giữa các phiên làm việc, vì agent không nhớ gì từ hôm qua, còn file thì nhớ.
Bước 1: từ ý tưởng tới spec, bằng cách để AI hỏi bạn
Sai lầm phổ biến nhất là để AI đoán bạn muốn gì. Harper Reed đảo ngược chuyện đó: bắt AI hỏi bạn, mỗi lần một câu, cho tới khi đủ rõ để viết spec. Prompt mình dùng, viết lại theo ý đó:
Mình muốn làm: app chia tiền cho nhóm bạn đi chơi chung.
Hãy hỏi mình TỪNG CÂU MỘT để làm rõ ý tưởng thành một spec đủ chi tiết
để một dev khác làm được. Mỗi câu chỉ hỏi một điều, dựa trên câu trả lời trước.
Hỏi cả những thứ mình chưa nghĩ tới: trường hợp biên, ai dùng, cái gì KHÔNG làm.
Khi mình nói "xong", tổng hợp lại thành spec.md.
Hỏi từng câu nghe chậm, nhưng chính những câu như "Nếu một người trả tiền rồi rời nhóm thì sao?" hay "Tiền lẻ khi chia không đều thì ai chịu?" là chỗ bạn nhận ra mình chưa nghĩ tới. Kết quả là một spec ngắn:
# spec.md: Chia tiền nhóm
## Mục tiêu
Nhóm 2–20 người ghi lại các khoản chi chung, app tính ai nợ ai bao nhiêu.
## Người dùng
Nhóm bạn đi du lịch, dùng trên điện thoại, không muốn đăng ký tài khoản.
## Luồng chính
1. Tạo nhóm, chia sẻ link mời.
2. Thêm khoản chi: ai trả, bao nhiêu, chia cho những ai (đều hoặc theo số tiền).
3. Xem bảng "ai nợ ai", tối giản số lần chuyển khoản.
## Không làm (ở bản đầu)
- Không tích hợp thanh toán, không đa tiền tệ, không app di động riêng.
## Tiêu chí chấp nhận
- Tổng phần chia luôn đúng bằng số tiền gốc, kể cả khi chia không hết (đơn vị nhỏ nhất: 1 đồng).
- Thêm một khoản chi mất dưới 15 giây trên điện thoại.
Mục Không làm quan trọng không kém mục làm. Nó là thứ bạn chỉ vào khi AI hào hứng đề xuất thêm tính năng đăng nhập bằng Google ở bước 5.
Làm sâu hơn: phỏng vấn có luật
Prompt "hỏi từng câu" hay hỏng theo hai kiểu: AI vẫn tự bịa thêm mục vào spec, hoặc hỏi xong mười câu mới viết một lần và quên mất câu trả lời thứ ba. Skill interview-spec-extractor chặn cả hai bằng mấy luật cứng:
| Luật | Vì sao |
|---|---|
| Đọc tài liệu đang có trước khi hỏi câu nào | Không hỏi lại thứ đã viết ở README |
| Tạo khung tài liệu một lần, rồi hỏi đúng một câu mở | Câu mở ("Khi một người rời nhóm, bạn muốn điều gì xảy ra?") lấy được nhiều hơn câu có/không |
| Có câu trả lời thì ghi ngay vào đúng mục, rồi mới hỏi câu tiếp | Spec lớn dần theo cuộc hỏi đáp, không mất câu trả lời nào |
| Danh sách bạn đưa ra là tập không thứ tự; muốn xếp ưu tiên thì phải hỏi | AI không tự quyết tính năng nào quan trọng hơn |
| Giữ nguyên chữ của bạn, không thêm mục suy đoán | Spec là ý của bạn, không phải ý của model |
Ghép với skill clarify cho câu hỏi ở các bước sau: chỉ hỏi khi câu trả lời làm đổi hướng việc, còn chỗ nào có mặc định an toàn và đổi lại được thì tự chọn và ghi rõ là đã chọn. Bớt được kiểu agent hỏi "Bạn muốn nút màu gì?" giữa lúc đang làm logic tính tiền.
Bước 2: luật chơi, viết một lần, áp cho mọi phiên
Spec Kit gọi bước này là "constitution": những nguyên tắc mà mọi phần code sau đó phải tuân theo. Trong thực tế, nó là một file AGENTS.md (hoặc CLAUDE.md) ở gốc repo mà agent đọc ở đầu mỗi phiên:
# AGENTS.md
## Stack
- Next.js (App Router), TypeScript strict, PostgreSQL qua Drizzle.
## Lệnh
- Test: `pnpm test` · Lint: `pnpm lint` · Kiểu: `pnpm typecheck`
- Chạy cả ba trước khi báo xong một việc.
## Quy ước
- Tiền lưu bằng số nguyên (đồng), không bao giờ dùng số thực.
- Logic tính toán nằm trong `src/domain/`, không import React hay database.
- Không sửa test để test xanh; test sai thì hỏi lại.
Giữ file này ngắn. Mỗi dòng là một thứ agent phải nhớ trong mọi lượt, nên dòng nào kiểm được bằng máy thì chuyển thành lint rule hay test, rồi xoá khỏi file. Đây chính là ý "biến lời dặn thành kiểm tra tất định" ở bài All Code Is Slop trong series này. Ví dụ dòng "Logic tính toán không import React" nên trở thành một rule no-restricted-imports trong ESLint, để CI đỏ thay vì trông vào trí nhớ của agent.
Làm luôn ở bước này: repo có sẵn lint, typecheck, khung test, và CI chạy cả ba trên mỗi PR. Trước khi có dòng code tính năng nào.
Làm sâu hơn: từ điển domain và quyết định đã chốt
Có hai thứ agent làm hỏng rất lặng lẽ: gọi một khái niệm bằng ba tên khác nhau (debt, owed, balance trong ba file), và lật lại quyết định đã chốt (đổi tiền sang number có phần thập phân vì "cho tiện tính phần trăm"). Skill domain-modeling giữ hai file cho chuyện đó:
# GLOSSARY.md
| Từ | Nghĩa | Tên trong code |
| --- | --- | --- |
| Khoản chi | Một lần ai đó trả tiền cho cả nhóm | `Expense` |
| Phần chia | Số tiền một người phải gánh trong một khoản chi | `Share` |
| Số dư | Tổng được nhận lại trừ tổng phải gánh; dương là được nhận, âm là đang nợ | `balance` |
| Tất toán | Danh sách chuyển khoản để mọi số dư về 0 | `settle()` |
# docs/adr/0001-tien-la-so-nguyen.md
Status: Accepted
Context: Số thực làm tròn sai ở các điểm .5 và cộng dồn lệch; spec yêu cầu tổng phần chia đúng tới 1 đồng.
Decision: Mọi số tiền lưu và tính bằng số nguyên đơn vị đồng. Đồng lẻ khi chia dồn cho người đứng đầu danh sách.
Consequences: Không hỗ trợ tiền có phần lẻ (USD cent) cho tới khi có ADR mới; hiển thị mới định dạng.
Skill này làm việc theo kiểu chủ động: mỗi khi có một từ mới xuất hiện trong lúc thiết kế, nó đối chiếu với GLOSSARY.md, chất vấn nếu từ đó trùng nghĩa với một từ đã có, và ghi lại ngay khi một thuật ngữ hay một quyết định vừa được chốt. Còn một luật mình mượn từ skill phỏng vấn ở bước 1: ADR chỉ ghi quyết định bạn đã chốt, không bao giờ để AI tự viết một quyết định kiến trúc vào đó. Khi agent định làm ngược một ADR, bạn có một file để chỉ vào, thay vì cãi nhau trong khung chat.
Bước 3: kế hoạch kỹ thuật, và đọc nó như một reviewer
Giờ mới đưa spec cho AI và yêu cầu kế hoạch, chưa viết code. Trong Claude Code, đó là chế độ plan: agent đọc code và tài liệu, trả lời câu hỏi, nhưng không sửa file nào. Prompt:
Đọc spec.md, AGENTS.md, GLOSSARY.md và docs/adr. Viết plan.md gồm: mô hình dữ liệu,
các route/API, nơi đặt logic tính tiền, cách xử lý tiền lẻ, rủi ro và chỗ còn mơ hồ.
Chưa viết code. Chỗ nào spec chưa rõ thì liệt kê thành câu hỏi.
Phần việc của bạn ở bước này là đọc plan như đọc một design doc của đồng nghiệp. Những câu mình hay hỏi:
| Câu hỏi | Ví dụ trong app chia tiền |
|---|---|
| Có làm thứ spec ghi là không làm không? | Plan đề xuất bảng currencies → gạch, spec nói không đa tiền tệ |
| Chỗ khó nhất có được nói rõ không? | Tiền lẻ khi chia 100.000đ cho 3 người: ai nhận thêm 1 đồng? |
| Dữ liệu có đúng với thực tế không? | Người rời nhóm: xoá hay đánh dấu? Xoá thì mất lịch sử nợ |
| Có thêm thư viện không cần thiết không? | Một thư viện state management cho app ba màn hình |
Sửa plan rẻ hơn sửa code rất nhiều. Một dòng sai trong plan là năm file sai sau bước 5.
Làm sâu hơn: plan có phụ thuộc và cách kiểm, rồi để nó bị "vặn"
Skill plan bắt mỗi bước trong plan có đủ năm thứ: việc làm theo thứ tự, file bị đụng tới, việc phụ thuộc vào việc nào, tiêu chí chấp nhận, và lệnh kiểm chứng được kết quả. Thêm cờ --tdd thì mỗi bước mở đầu bằng một test đỏ. Một bước trong plan của app chia tiền trông thế này:
### Bước 2. Tính số dư và tất toán (phụ thuộc: Bước 1 splitEqually)
- File: src/domain/settle.ts, src/domain/settle.test.ts
- Chấp nhận: sau khi thực hiện các chuyển khoản, số dư của mọi người bằng 0;
số lần chuyển ít hơn số người trong nhóm.
- Kiểm: pnpm vitest run src/domain/settle.test.ts (gồm test thuộc tính, xem bước 5)
Sau đó đưa plan cho skill architecture-advisor để nó "vặn" plan: đọc code, rồi hỏi bạn từng câu một (không bao giờ dồn nhiều câu một lượt), đưa ra 2–3 cách khác để đạt cùng mục tiêu, kể cả "làm ít hơn" hay "không làm", và cuối cùng nói thẳng nên làm gì, nên tránh gì. Với plan này, loại câu hỏi đáng giá nhất là kiểu: "Sửa một khoản chi đã có thì số dư được tính lại từ đầu, hay cộng trừ phần chênh lệch?" Plan ban đầu không nói, và đó đúng là chỗ sẽ có bug.
Bước 4: chia thành việc nhỏ, mỗi việc kiểm được
Từ plan, nhờ AI tách ra tasks.md. Quy tắc duy nhất: mỗi việc phải có cách kiểm rằng nó xong, và đủ nhỏ để bạn review diff trong vài phút.
# tasks.md
- [ ] T1. Hàm chia đều trong src/domain/split.ts
Kiểm: test ví dụ + test thuộc tính "tổng luôn bằng số gốc"
- [ ] T2. Tính số dư và tất toán
Kiểm: test thuộc tính "tất toán xong mọi số dư về 0"
- [ ] T3. Bảng groups, members, expenses + migration
Kiểm: migration chạy trên database trống; rollback được
- [ ] T4. Form thêm khoản chi (server action) + validate
Kiểm: test số tiền âm, chia cho 0 người; E2E thêm một khoản chi
- [ ] T5. Màn hình "ai nợ ai"
Kiểm: E2E với dữ liệu mẫu ra đúng bảng mong đợi
Để ý thứ tự: phần logic thuần (T1, T2) đi trước, giao diện đi sau. Logic thuần dễ test nhất và cũng là chỗ sai đắt nhất. App chia tiền mà chia sai thì giao diện đẹp mấy cũng vô nghĩa.
Làm sâu hơn: quét trường hợp biên theo 12 chiều
"Nghĩ thêm trường hợp biên đi" là lời dặn ai cũng nghe, nhưng không ai biết khi nào là đủ. Skill edge-case-scenario-gen biến nó thành một danh sách kiểm: soát tính năng qua 12 chiều (loại người dùng, đầu vào cực trị, thời điểm và tranh chấp, quy mô, chuyển trạng thái, môi trường, lỗi dây chuyền, phân quyền, toàn vẹn dữ liệu, tích hợp, tuân thủ, logic nghiệp vụ), bỏ chiều nào thì phải ghi rõ giả định khiến mình bỏ, mỗi chiều còn lại 3–5 tình huống, gắn mức nghiêm trọng.
Một phần kết quả khi mình áp quy trình đó cho tính năng "thêm khoản chi và tất toán":
| Chiều | Tình huống | Mức |
|---|---|---|
| Đầu vào cực trị | 2 đồng chia 3 người; 0 đồng; số tiền rất lớn | Critical |
| Logic nghiệp vụ | Người trả tiền không nằm trong danh sách được chia | High |
| Logic nghiệp vụ | Sửa số tiền của khoản chi đã có sau khi đã tất toán một phần | Critical |
| Chuyển trạng thái | Một người rời nhóm khi vẫn còn nợ | High |
| Thời điểm | Hai người cùng thêm khoản chi một lúc trên hai điện thoại | High |
| Phân quyền | Ai có link mời cũng sửa được khoản chi của người khác | High |
| Toàn vẹn dữ liệu | Bấm "Lưu" hai lần, khoản chi bị ghi đôi | Medium |
| Môi trường | Tên người có dấu, emoji; màn hình 320px | Low |
Và phần bỏ qua, có ghi giả định:
Bỏ "Tích hợp": giả định không nối cổng thanh toán (spec mục Không làm).
→ Nếu sau này thêm nút "Chuyển khoản qua app ngân hàng", giả định này vỡ: ghi thành rủi ro, không phải bỏ hẳn.
Bỏ "Tuân thủ": giả định không lưu thông tin cá nhân ngoài tên hiển thị.
Luật "bỏ chiều nào phải ghi giả định" là phần mình thấy giá trị nhất: nó biến những thứ mình tưởng là không liên quan thành một dòng có thể bị thách thức sau này. Mỗi dòng Critical, High trong bảng trở thành một test trong tasks.md.
Bước 5: vòng lặp cho từng việc
Đây là chỗ AI viết phần lớn code. Mỗi việc trong tasks.md đi đúng một vòng:
phiên mới ─▶ đọc AGENTS.md + đúng 1 task ─▶ viết test trước ─▶ AI viết code
▲ │
│ ▼
commit nhỏ ◀── bạn đọc diff ◀── lint + typecheck + test xanh ◀── chạy kiểm
Ví dụ với T1, test viết trước, lấy thẳng từ tiêu chí chấp nhận trong spec:
// src/domain/split.test.ts
import { describe, expect, it } from "vitest";
import { splitEqually } from "./split";
describe("splitEqually", () => {
it("tổng các phần luôn bằng số tiền gốc", () => {
const parts = splitEqually(100_000, ["An", "Bình", "Chi"]);
expect(parts.reduce((s, p) => s + p.amount, 0)).toBe(100_000);
});
it("đồng lẻ dồn cho những người đầu tiên, mỗi người nhiều nhất 1 đồng", () => {
expect(splitEqually(2, ["An", "Bình", "Chi"]).map((p) => p.amount)).toEqual([1, 1, 0]);
});
it("từ chối số tiền không phải số nguyên", () => {
expect(() => splitEqually(10.5, ["An"])).toThrow();
});
});
Rồi mới để AI viết code cho test xanh:
// src/domain/split.ts
export function splitEqually(amount: number, members: string[]) {
if (!Number.isInteger(amount) || amount < 0) throw new Error("Số tiền phải là số nguyên không âm (đơn vị: đồng)");
if (members.length === 0) throw new Error("Cần ít nhất một người");
const base = Math.floor(amount / members.length);
let remainder = amount - base * members.length; // số đồng lẻ còn lại, luôn nhỏ hơn số người
return members.map((member) => ({ member, amount: base + (remainder-- > 0 ? 1 : 0) }));
}
Ba thói quen giữ cho vòng lặp này không trôi:
- Mỗi việc một phiên mới. Tài liệu của Claude Code nói thẳng: context đầy thì chất lượng đi xuống. Một phiên kéo dài qua năm việc là một phiên mà agent nhớ lẫn lộn chi tiết của việc 1 khi đang làm việc 5. Kết thúc việc bằng commit, mở phiên mới cho việc tiếp theo.
- Test viết trước, và AI không được sửa test để cho xanh. Đây là kiểu "gian lận" phổ biến nhất của agent: gặp test đỏ thì sửa test. Dòng cuối trong
AGENTS.mdở bước 2 là để chặn chuyện đó, và bạn vẫn phải nhìn diff của file test. - Commit nhỏ. Một việc, một commit, diff đủ ngắn để đọc hết. Commit nhỏ còn là nút quay lại rẻ nhất: AI đi sai hướng thì
git resetvề commit trước, không phải gỡ từng dòng.
Làm sâu hơn: test thuộc tính, để máy đi tìm ví dụ làm hỏng code
Ba test ví dụ ở trên kiểm đúng ba điểm. Còn số tiền 57 đồng chia 2 người, hay 99.999.998 đồng chia 17 người thì sao? Test thuộc tính (property-based testing) phát biểu một điều phải đúng với mọi đầu vào, rồi để thư viện sinh hàng trăm đầu vào ngẫu nhiên đi tìm cái làm nó sai. Skill property-based-testing có sẵn danh mục thuộc tính hay dùng (bất biến, khứ hồi, luỹ đẳng, so với một cài đặt tham chiếu) và một cảnh báo quan trọng: đừng viết thuộc tính bằng cách tính lại y hệt hàm đang test, vì sai giống nhau thì test vẫn xanh.
Hai thuộc tính cho app chia tiền, viết bằng fast-check:
import fc from "fast-check";
const amount = fc.integer({ min: 0, max: 100_000_000 });
const members = fc.uniqueArray(fc.string({ minLength: 1, maxLength: 6 }), { minLength: 1, maxLength: 20 });
it("tổng các phần bằng đúng số tiền gốc", () => {
fc.assert(fc.property(amount, members, (a, m) => {
expect(splitEqually(a, m).reduce((s, p) => s + p.amount, 0)).toBe(a);
}));
});
it("chênh lệch giữa hai người bất kỳ không quá 1 đồng", () => {
fc.assert(fc.property(amount, members, (a, m) => {
const parts = splitEqually(a, m).map((p) => p.amount);
expect(Math.max(...parts) - Math.min(...parts)).toBeLessThanOrEqual(1);
}));
});
Để thấy nó đáng giá thế nào, mình chạy đúng thuộc tính thứ nhất với bản cài đặt mà agent hay viết ra khi không ai dặn, làm tròn từng phần:
const naive = (amount: number, members: string[]) =>
members.map((member) => ({ member, amount: Math.round(amount / members.length) }));
Kết quả thật:
Error: Property failed after 1 tests
Counterexample: [57,[" ","!"]]
Shrunk 45 time(s)
Caused by: AssertionError: expected 58 to be 57
Đọc ra: fast-check tìm được lỗi ngay ở lần thử đầu tiên, rồi thu gọn 45 lần tới ví dụ nhỏ nhất còn làm hỏng: 57 đồng chia cho 2 người (tên người là chuỗi ngẫu nhiên, không quan trọng), mỗi người được làm tròn thành 29, tổng ra 58. Đây cũng chính là con bug "100.000đ cho ba người ra 99.999đ" ở đầu bài, chỉ là theo chiều ngược lại. Bản cài đặt đúng ở trên qua cả hai thuộc tính, mỗi thuộc tính 100 đầu vào ngẫu nhiên.
Hàm tất toán ở T2 có một thuộc tính còn mạnh hơn, vì nó kiểm kết quả chứ không kiểm cách tính: sinh ngẫu nhiên tới 30 khoản chi trong một nhóm 2–8 người, tính số dư, thực hiện các chuyển khoản mà settle() đề xuất, rồi khẳng định mọi số dư về 0 và số lần chuyển ít hơn số người. Thuộc tính này không cần biết thuật toán ghép cặp bên trong, nên agent có viết lại thuật toán kiểu gì thì nó vẫn giữ nguyên giá trị.
Làm sâu hơn: bàn giao giữa hai phiên
"Mỗi việc một phiên mới" có một cái giá: phiên mới không biết phiên cũ đã quyết gì. Việc nào dài hơn một phiên thì trước khi đóng, mình cho skill session-handoff-contract viết một file bàn giao trong plans/handoffs/, đủ 9 phần: mục tiêu và trạng thái, phạm vi được phép đụng, trạng thái repo (nhánh, commit, file đang sửa), quyết định đã chốt và phương án đã loại, việc đã làm, kiểm tra nào đã chạy và kiểm tra nào chưa, rủi ro còn mở, các bước tiếp theo theo thứ tự, và đường dẫn tới nguồn. Phiên mới đọc file đó thay vì đọc lại cả cuộc hội thoại cũ, và không đề xuất lại phương án mà hôm qua đã loại.
Bước 6: review như thể bạn là người sẽ bị gọi dậy lúc 3 giờ sáng
Simon Willison có một quy tắc mà mình thấy là ranh giới rõ nhất giữa "vibe coding" và làm phần mềm thật: không commit đoạn code nào mà bạn không giải thích được cho người khác. Không phải "trông có vẻ đúng", mà là giải thích được nó làm gì và vì sao.
Checklist mình dùng khi đọc diff do AI viết:
[ ] Diff chỉ đụng tới đúng việc đang làm, không "tiện tay" sửa chỗ khác
[ ] Không thêm thư viện, file, abstraction mà plan không có
[ ] File test không bị nới lỏng (bỏ assert, thêm skip, đổi giá trị mong đợi)
[ ] Trường hợp lỗi được xử lý thật, không phải try/catch nuốt lỗi
[ ] Tên hàm, tên biến đúng với GLOSSARY.md
[ ] Mình giải thích được từng khối cho đồng nghiệp
Với những dòng mình không chắc, hỏi lại chính agent: "Vì sao chỗ này cần remainder-- thay vì tính trước?" Một câu trả lời lòng vòng thường là dấu hiệu code đó nên viết lại cho đơn giản hơn.
Làm sâu hơn: reviewer mặc định nghi ngờ
Review bằng AI dễ thành "LGTM" vì model có xu hướng chiều người viết. Skill code-quality-auditor được viết để làm ngược lại, với vài nguyên tắc mình thấy nên áp dụng cả khi review tay:
- Mặc định coi code là do AI viết: không tin vì code trông gọn, comment nghe tự tin, hay test chỉ đi đường vui vẻ.
- Mỗi phát hiện phải kèm bằng chứng trong code (file, dòng, đầu vào làm hỏng), không có kiểu "có thể có vấn đề về hiệu năng".
- Phạm vi được yêu cầu là ràng buộc: không đề xuất cắt thứ bạn đã yêu cầu; nhưng code không được yêu cầu thì phải bị gọi tên kèm cái giá của nó.
- Không tuyên bố xong khi chưa có bằng chứng kiểm chứng mới: chạy lại test, build ngay trước khi nói "đã sửa".
Với bản naive ở trên, một phát hiện đạt chuẩn của skill trông thế này: "src/domain/split.ts: làm tròn từng phần làm tổng lệch số gốc. Bằng chứng: [57, 2 người] → tổng 58 (phản ví dụ từ test thuộc tính). Mức: Critical, vi phạm tiêu chí chấp nhận số 1 trong spec." Có file, có đầu vào, có lý do, có mức. Với PR trên GitHub, skill github-pr-reviewer làm việc tương tự trên diff của PR và gọi tên riêng các mẫu AI slop.
Bước 7: ship, rồi biến mỗi lỗi thành một kiểm tra
Lên production theo cách bình thường của bạn: CI xanh, bản preview cho mỗi PR, deploy, có log và cảnh báo. AI không đổi gì ở phần này, và đó là chủ ý: quy trình ship tốt là thứ khuếch đại AI theo hướng tốt, như DORA nói.
Phần AI làm khác là sau khi ship. Mỗi lần gặp lỗi (do người hay do agent), hỏi bốn câu theo thứ tự trong bài All Code Is Slop: lỗi này có thể chặn bằng kiểu dữ liệu không, bằng lint rule không, bằng test không, hay đành ghi vào AGENTS.md. Ví dụ: một lần agent dùng parseFloat cho số tiền. Thay vì thêm dòng nhắc thứ mười vào AGENTS.md, thêm một lint rule cấm parseFloat trong src/domain/. Lần sau, không agent nào, không người nào lặp lại được lỗi đó mà CI không đỏ.
Làm sâu hơn: ship có cổng, và đọc lịch sử để tìm lỗi lặp
Skill branch-shipper-pr gom chặng cuối thành một đường cố định: chạy test, review, commit, push, mở PR, và chỉ merge khi review xong và CI xanh. Giá trị không nằm ở chỗ tiết kiệm vài lệnh gõ, mà ở chỗ không bước nào bị bỏ qua những hôm vội.
Còn câu hỏi "lỗi nào đang lặp lại?" thì đừng trả lời bằng trí nhớ. Skill sprint-retro-generator đọc lịch sử git của một giai đoạn và rút ra số liệu: 10 file bị sửa nhiều nhất, độ churn (thêm rồi xoá bao nhiêu so với phần còn lại), tỷ lệ thay đổi ở file test so với file code, nhịp commit, và gợi ý dựa trên đúng các số đó. Một file nằm trong top bị sửa nhiều nhất mà churn cao, test ít, là ứng viên hàng đầu cho câu hỏi "chặn được bằng kiểu dữ liệu hay lint rule không?".
Theo thời gian, codebase tích luỹ một bộ kiểm tra ngày càng dày, và AI viết code trong một hàng rào ngày càng chặt. Đó là cách khối lượng code tăng mà chất lượng không giảm.
Bảng tóm tắt
| Bước | Bạn làm | AI làm | Để lại | Skill PrimeKit |
|---|---|---|---|---|
| 1. Spec | Trả lời, chốt cái không làm | Hỏi từng câu, ghi ngay | spec.md |
interview-spec-extractor, clarify |
| 2. Luật chơi | Chọn stack, quy ước, chốt quyết định | Gợi ý cấu hình, giữ từ điển | AGENTS.md, GLOSSARY.md, ADR, CI |
domain-modeling |
| 3. Plan | Đọc như reviewer, trả lời câu vặn | Đề xuất thiết kế, vặn chỗ yếu | plan.md |
plan, architecture-advisor |
| 4. Tasks | Duyệt danh sách biên | Tách việc, quét 12 chiều | tasks.md, edge-cases.md |
edge-case-scenario-gen |
| 5. Vòng lặp | Duyệt test, đọc diff | Viết code cho test xanh, tìm phản ví dụ | Commit nhỏ, file bàn giao | property-based-testing, session-handoff-contract |
| 6. Review | Giải thích được từng dòng | Tìm lỗi kèm bằng chứng | PR | code-quality-auditor, github-pr-reviewer |
| 7. Sau ship | Biến lỗi thành kiểm tra | Ship qua cổng, đọc lịch sử | Hàng rào ngày càng chặt | branch-shipper-pr, sprint-retro-generator |
Skill không làm thay được gì
Dùng skill nhiều, mình càng thấy rõ ranh giới. Không skill nào trong danh sách trên làm được những việc này:
- Quyết định sản phẩm làm cái gì và không làm cái gì. Skill phỏng vấn chỉ ghi lại ý của bạn; nó được viết để không tự thêm ý.
- Chọn thuộc tính đáng kiểm. fast-check tìm phản ví dụ rất giỏi, nhưng "tổng các phần bằng số gốc" là câu bạn phải nghĩ ra từ spec.
- Chịu trách nhiệm về code được merge. Reviewer AI giảm số lỗi lọt qua, không thay được việc bạn giải thích được từng dòng.
- Biết khi nào nên bỏ quy trình. Mục dưới đây là phán đoán của người, không phải của skill.
Những lúc được phép bỏ bớt bước
Quy trình đầy đủ là cho sản phẩm sẽ sống lâu và có người dùng thật. Không phải lúc nào cũng cần:
- Sửa một lỗi nhỏ, rõ ràng: bỏ bước 1, 3, 4; vẫn giữ test và review. Tài liệu của Claude Code cũng nói plan là chi phí thừa với việc nhỏ đã rõ.
- Prototype để thử một ý tưởng, sẽ vứt đi: vibe code thoải mái, Simon Willison cũng bênh chuyện này. Chỉ cần thật sự vứt nó đi, đừng để prototype lén thành production.
- Codebase lớn, quen thuộc: đây đúng là bối cảnh trong nghiên cứu của METR. Có khi tự viết nhanh hơn, và đo thử trên chính công việc của mình là cách duy nhất để biết.
Checklist một trang
[ ] Spec có mục "Không làm" và tiêu chí chấp nhận đo được
[ ] AGENTS.md ngắn; quy ước kiểm được bằng máy đã thành lint, test
[ ] GLOSSARY.md cho các khái niệm domain; ADR cho quyết định đã chốt
[ ] Lint, typecheck, test, CI có trước dòng code tính năng đầu tiên
[ ] Plan có phụ thuộc, tiêu chí chấp nhận, lệnh kiểm; được đọc và sửa trước khi code
[ ] Đã quét trường hợp biên; chiều nào bỏ thì có ghi giả định
[ ] Mỗi task nhỏ, có cách kiểm; logic thuần đi trước giao diện
[ ] Logic quan trọng có test thuộc tính, không chỉ test ví dụ
[ ] Mỗi task một phiên mới; việc dài có file bàn giao
[ ] Không để AI sửa test cho xanh
[ ] Không merge code mà mình không giải thích được
[ ] Mỗi lỗi sau khi ship để lại một kiểm tra tự động
Thử ngay: lấy một ý tưởng nhỏ bạn đang để dành, mở agent lên, dán prompt ở bước 1 và trả lời câu hỏi trong 15 phút. Chưa cần viết dòng code nào. Chỉ riêng cái spec.md đó thường đã cho bạn thấy ý tưởng còn bao nhiêu chỗ chưa nghĩ tới. Rồi lấy một hàm quan trọng nhất trong project hiện tại, viết cho nó đúng một test thuộc tính. Bạn đang dùng quy trình nào khi làm việc với AI, và bước nào hay bị bỏ nhất? Comment cho mình biết với.
Tài liệu để đọc thêm
- My LLM codegen workflow atm, Harper Reed: quy trình ý tưởng → spec → plan → thực thi
- Spec Kit, GitHub và bài giới thiệu spec-driven development
- Best practices cho Claude Code, Anthropic: khám phá, lên kế hoạch, code, commit; giữ context gọn
- My LLM coding workflow going into 2026, Addy Osmani
- Not all AI-assisted programming is vibe coding, Simon Willison và Vibe engineering
- Nghiên cứu năng suất của METR (2025)
- Báo cáo DORA 2025: State of AI-assisted Software Development
- fast-check: thư viện test thuộc tính cho JavaScript, TypeScript
- PrimeKit và danh sách skill: bộ skill mình tự làm, dùng trong các phần "Làm sâu hơn"
Series khác của mình
- Dùng AI hiệu quả trong công việc: kinh nghiệm thực chiến của dev: viết prompt đủ ngữ cảnh, bắt AI bịa API, giao việc cho agent, review code AI viết, debug, đọc codebase lạ, đóng gói quy trình thành skill.
- Front End thực chiến: những cú lừa của production mà tutorial không kể 🐧: ngày giờ và giờ mùa hè, tầng dữ liệu theo hợp đồng API, chart, in ấn và accessibility, Outlook Add-in, E2E, Remix trên Cloudflare Workers, Supabase và Prisma.
- DevOps thực chiến: Docker, Portainer và Azure Pipelines từ máy dev lên server: Dockerfile, Compose, secret trong container, Portainer, pipeline Azure, deploy có rollback, dựng server Ubuntu.
- SQL thực chiến: Những bài học mình ước đã biết sớm hơn: viết query dễ đọc, đọc execution plan, lỗi NULL và N+1 không báo lỗi, schema và transaction, phân trang bằng con trỏ.
- Backend .NET thực chiến: những case hay gặp trên production: async/await làm treo API, HttpClient hết socket, EF Core kéo cả bảng, idempotency, outbox, caching, bảo mật API.
All rights reserved