Tự động hóa với AI: việc nào giao cho script, việc nào cho agent

Tự động hóa với AI: gom kiểm kiểu, test và kiểm CLAUDE.md vào một lệnh, cài Git hook chạy trước mỗi commit, và cách chọn giữa script với agent.

Việc nào có đáp án đúng sai máy kiểm được thì giao cho script; việc nào cần hiểu ý và có nhiều cách đúng thì mới cần agent. Script rẻ, nhanh và cho kết quả giống nhau mỗi lần. Bạn đang lặp lại việc tay chân nào mỗi ngày? Cùng mình gom chúng lại nhé.

Mình đang lặp lại những việc gì?

Ở tập trước của Làm side project cùng AI, mình viết một file CLAUDE.md để AI nhớ quy ước của app sổ chi tiêu (một bot Telegram ghi khoản chi như "cà phê 35k" rồi trả tổng tháng). Nhưng khi nhìn lại một ngày làm việc, mình thấy vẫn còn một chuỗi việc mình làm bằng tay trước mỗi commit: chạy npm run kiem-kieu, chạy npm test, chạy npm run kiem-claude-md, rồi nghĩ ra một tin nhắn commit. Mỗi việc chỉ mất vài giây, nên rất dễ bị bỏ qua khi đang vội.

Mà lúc vội lại chính là lúc dễ làm hỏng nhất. Theo mình, việc nào con người hay bỏ qua khi vội thì nên để máy làm.

Một lệnh thay cho ba lệnh

Bước đầu tiên không cần AI gì cả. Mình viết kiem.ts, một script chạy ba bước theo thứ tự: kiểm kiểu bằng tsc (với cờ --erasableSyntaxOnly mà tập trước đã nói), chạy test, và kiểm CLAUDE.md còn khớp với dự án. Script dừng ở bước đầu tiên hỏng, vì khi kiểu đã sai thì xem test làm gì. Thêm cờ --het thì nó chạy cả ba để bạn thấy mọi lỗi cùng lúc.

Mỗi bước ở đây là một script npm có sẵn trong package.json (kiem-kieu, test, kiem-claude-md); kiem.ts chỉ chạy chúng và gom kết quả:

kiem.ts
import { spawnSync } from "node:child_process";

export const BUOC = [
  { ten: "Kiểm kiểu", lenh: "npm run kiem-kieu --silent" },
  { ten: "Test", lenh: "npm test --silent" },
  { ten: "CLAUDE.md còn khớp", lenh: "npm run kiem-claude-md --silent" },
];

// Ưu tiên các dòng nói lỗi là gì ("not ok", "error"); nếu không có dòng nào thì lấy phần cuối của output.
const duoi = (chu: string, soDong = 6) => {
  const dong = chu.trim().split(/\r?\n/);
  const loi = dong.filter((d) => /not ok|error|✗/i.test(d));
  return (loi.length > 0 ? loi : dong).slice(-soDong).map((d) => "      " + d.trim()).join("\n");
};

export function chayKiem(het: boolean, cwd = process.cwd()): { dat: boolean; dong: string[] } {
  const dong: string[] = [];
  let dat = true;
  for (const buoc of BUOC) {
    const batDau = Date.now();
    const kq = spawnSync(buoc.lenh, { cwd, shell: true, encoding: "utf8" });
    const giay = ((Date.now() - batDau) / 1000).toFixed(1);
    if (kq.status === 0) {
      dong.push(`✓ ${buoc.ten} (${giay}s)`);
      continue;
    }
    dat = false;
    dong.push(`✗ ${buoc.ten} (${giay}s)\n${duoi(kq.stdout + kq.stderr)}`);
    if (!het) break;
  }
  return { dat, dong };
}

if (process.argv[1]?.endsWith("kiem.ts")) {
  const { dat, dong } = chayKiem(process.argv.includes("--het"));
  for (const d of dong) console.log(d);
  console.log(dat ? "\nXanh: có thể commit." : "\nĐỏ: sửa rồi chạy lại.");
  process.exitCode = dat ? 0 : 1;
}

Hàm duoi ở giữa file có một lý do. Bản đầu của mình in sáu dòng cuối của output cho bước hỏng, và với test thì sáu dòng cuối của node --test chỉ là phần tổng kết (# tests 11, # pass 10, # fail 1), không nói lỗi gì. Mình sửa để ưu tiên các dòng có chữ not ok hoặc error.

Trong package.json, mình thêm "kiem": "node kiem.ts" vào mục scripts. Chạy npm run kiem trên dự án đang ổn:

node kiem.ts
✓ Kiểm kiểu (0.5s)
✓ Test (0.8s)
✓ CLAUDE.md còn khớp (0.4s)

Xanh: có thể commit.

Giờ mình làm hỏng dự án một chỗ, đúng lỗi mà tập trước nhắc: thêm một dòng enum Loai { An, Uong } vào cuối src/phan-loai.ts. Node chạy .ts ở chế độ strip-only không hiểu enum. Mình chạy node kiem.ts --het để thấy mọi bước:

node kiem.ts --het (sau khi thêm enum)
✗ Kiểm kiểu (0.5s)
      src/phan-loai.ts(71,6): error TS1294: This syntax is not allowed when 'erasableSyntaxOnly' is enabled.
✗ Test (0.5s)
      # SyntaxError [ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX]: TypeScript enum is not supported in strip-only mode
      not ok 2 - src\\phan-loai.test.ts
      error: 'test failed'
✓ CLAUDE.md còn khớp (0.4s)

Đỏ: sửa rồi chạy lại.

Hai bước đỏ cùng một nguyên nhân gốc, và bước kiểm kiểu nói nó rõ nhất (dòng 71). Khi chạy không có --het thì bạn chỉ thấy bước đầu và dừng, ít chữ hơn để đọc.

Git hook: để Git tự chạy

Một lệnh vẫn là một lệnh bạn phải nhớ gõ. Bước tiếp theo là để Git tự chạy nó. Git có cơ chế hook: nếu có một file tên pre-commit trong thư mục hook, Git chạy nó trước mỗi commit, và nếu file thoát với mã khác 0 thì commit bị hủy. Có hai file ngắn trong thư mục hooks/ của dự án (mình để hook trong dự án chứ không để trong .git/hooks/, vì thư mục .git không được chia sẻ qua clone):

hooks/pre-commit
#!/bin/sh
# Git chạy file này trước mỗi commit; thoát khác 0 thì commit bị hủy.
node kiem.ts
hooks/commit-msg
#!/bin/sh
# Git chạy file này sau khi bạn gõ xong tin nhắn commit; $1 là đường dẫn file chứa tin nhắn.
node kiem-commit-msg.ts "$1"

Để Git dùng thư mục đó, mỗi người chạy một lần git config core.hooksPath hooks. Hook commit-msg gọi kiem-commit-msg.ts, một bộ kiểm hình thức cho dòng đầu của tin nhắn. Nó kiểm đúng ba điều: có dạng kiểu(phạm vi): mô tả (cùng quy ước với bài viết commit message cùng AI), không quá 72 ký tự, và không phải kiểu "fix", "ok", "xong", "wip".

kiem-commit-msg.ts
import { readFileSync } from "node:fs";

const KIEU = /^(feat|fix|docs|test|refactor|chore|perf|build|ci|style)(\([\w-]+\))?!?: \S.*/;
const MO_HO = /^(fix|ok|xong|update|sua|sửa|test|wip|\.+)$/i;

export function kiemTieuDe(tieuDe: string): string[] {
  const loi: string[] = [];
  if (tieuDe.startsWith("Merge ") || tieuDe.startsWith("Revert ")) return loi; // Git tự sinh, không bắt người viết
  if (MO_HO.test(tieuDe.trim())) loi.push(`"${tieuDe}" không nói gì về thay đổi.`);
  else if (!KIEU.test(tieuDe)) loi.push("Dòng đầu phải có dạng kiểu(phạm vi): mô tả, ví dụ fix(bot): sửa tổng tháng khi xóa khoản chi.");
  if (tieuDe.length > 72) loi.push(`Dòng đầu dài ${tieuDe.length} ký tự, nên tối đa 72.`);
  if (tieuDe.endsWith(".")) loi.push("Dòng đầu không nên kết thúc bằng dấu chấm.");
  return loi;
}

if (process.argv[1]?.endsWith("kiem-commit-msg.ts")) {
  const file = process.argv[2];
  if (!file) throw new Error("Cần đường dẫn file tin nhắn commit");
  const tieuDe = readFileSync(file, "utf8").split(/\r?\n/).find((d) => d.trim() !== "" && !d.startsWith("#")) ?? "";
  const loi = kiemTieuDe(tieuDe);
  for (const l of loi) console.error("✗ " + l);
  process.exitCode = loi.length > 0 ? 1 : 0;
}

Điều bộ kiểm này làm được và không làm được cần nói rõ. Nó biết "fix" là mơ hồ, nhưng nó không biết fix(bot): sửa lỗi có đúng với thay đổi hay không. Viết một tin nhắn nói đúng điều đã đổi cần hiểu thay đổi đó, nên đó là việc của người hoặc của AI, không phải của một biểu thức chính quy.

Thử hook trên một kho Git thật

Để thấy hook làm gì, mình viết thu-hook.ts: nó dựng một kho Git tạm với bản sao của dự án, cài hook, rồi commit bốn lần. Phần đáng chú ý là hàm thu (làm một commit rồi in kết quả) và bốn lần gọi nó. Phần dựng kho (git init, git config, chép file) lược đi vì chỉ là thủ tục:

thu-hook.ts (phần đáng chú ý)
const git = (...args: string[]) => spawnSync("git", args, { cwd: kho, encoding: "utf8" });
git("config", "core.hooksPath", "hooks"); // từ đây Git chạy file trong hooks/ thay vì .git/hooks/

function thu(nhan: string, tinNhan: string, ...them: string[]) {
  git("add", "-A");
  const kq = git("commit", "-m", tinNhan, ...them);
  console.log(`\n${nhan}\n$ git commit -m "${tinNhan}"\n  → ${kq.status === 0 ? "COMMIT ĐƯỢC TẠO" : "COMMIT BỊ CHẶN"}`);
  // ... in output của hook, trừ các dòng "[main abc123]" và "create mode" của Git
}

const FILE = join(kho, "src", "phan-loai.ts");
appendFileSync(FILE, "\nenum Loai { An, Uong }\n");
thu("1. Code hỏng (có enum), tin nhắn tốt", "fix(bot): thêm kiểu Loai");
git("checkout", "HEAD", "--", "src/phan-loai.ts"); // bỏ enum, trả file về như lúc commit đầu
appendFileSync(FILE, "\n// thêm một dòng chú thích\n");
thu("2. Code ổn, tin nhắn mơ hồ", "fix");
thu("3. Code ổn, tin nhắn đúng dạng", "docs(bot): thêm chú thích");
appendFileSync(FILE, "\nenum Loai { An, Uong }\n");
thu("4. Code hỏng nhưng bỏ qua hook", "feat(bot): kiểu Loai", "--no-verify");

Bạn chạy node thu-hook.ts trong thư mục dự án:

node thu-hook.ts
1. Code hỏng (có enum), tin nhắn tốt
$ git commit -m "fix(bot): thêm kiểu Loai"
  → COMMIT BỊ CHẶN
    ✗ Kiểm kiểu (0.5s)
          src/phan-loai.ts(71,6): error TS1294: This syntax is not allowed when 'erasableSyntaxOnly' is enabled.
    
    Đỏ: sửa rồi chạy lại.

2. Code ổn, tin nhắn mơ hồ
$ git commit -m "fix"
  → COMMIT BỊ CHẶN
    ✓ Kiểm kiểu (0.5s)
    ✓ Test (0.8s)
    ✓ CLAUDE.md còn khớp (0.4s)
    
    Xanh: có thể commit.
    ✗ "fix" không nói gì về thay đổi.

3. Code ổn, tin nhắn đúng dạng
$ git commit -m "docs(bot): thêm chú thích"
  → COMMIT ĐƯỢC TẠO
    ✓ Kiểm kiểu (0.5s)
    ✓ Test (0.8s)
    ✓ CLAUDE.md còn khớp (0.4s)
    
    Xanh: có thể commit.

4. Code hỏng nhưng bỏ qua hook
$ git commit -m "feat(bot): kiểu Loai" --no-verify
  → COMMIT ĐƯỢC TẠO

Lần 1: tin nhắn tốt nhưng code hỏng, nên hook pre-commit chặn. Lần 2: code ổn nhưng tin nhắn là "fix", nên hook commit-msg chặn. Mình có hai nhận xét về lần này. Một, dòng "Xanh: có thể commit." vẫn hiện ra dù commit sau đó bị chặn, vì pre-commit chạy trước và nó chỉ biết về code. Dòng đó dễ gây hiểu nhầm, và mình để nguyên để bạn thấy. Hai, bộ kiểm code chạy hết rồi mới tới lượt kiểm tin nhắn, mất khoảng 1,7 giây trước khi bạn biết tin nhắn sai. Lần 3: cả hai đều đạt nên commit được tạo.

Lần 4 là điều khiến mình không dám gọi hook là "bảo vệ". Cờ --no-verify bỏ qua cả hai hook, và một commit với code hỏng vẫn được tạo. Hook là sự hỗ trợ, không phải hàng rào: nó giúp người tử tế khỏi quên, nhưng không ngăn được ai cố tình, hay người đang vội và gõ --no-verify cho nhanh. Muốn chắc chắn thì kiểm tra phải chạy lại ở nơi không ai bỏ qua được, tức là CI trên máy chủ; chủ đề đó có trong series xây blog với Next.js.

Việc nào giao cho script, việc nào giao cho agent?

Giờ quay lại câu hỏi ở tiêu đề. Mình dùng hai câu để phân loại một việc lặp lại. Thứ nhất: có phải mọi lần câu trả lời đều giống nhau không? Thứ hai: máy có tự kiểm được kết quả là đúng hay sai không? Nếu cả hai đều có, đó là việc của script. Nếu việc cần hiểu ý, hoặc có nhiều đáp án đúng khác nhau, đó mới là chỗ để một agent giúp.

Sáu việc lặp lại trong ngày làm việc của mình, phân loại theo hai câu đó (đây là nhận định của mình, chưa chạy thử trên agent nào):

  • Chạy kiểm kiểu và test: script. Kết quả luôn giống nhau với cùng code, và máy tự biết đỏ hay xanh.
  • Kiểm CLAUDE.md còn khớp: script. Cũng là so sánh thứ có thể so sánh được (lệnh có tồn tại không, đường dẫn có còn không).
  • Kiểm dạng tin nhắn commit: script. Dạng là quy tắc cứng.
  • Viết nội dung tin nhắn commit: agent hoặc người. Phải hiểu thay đổi để nói đúng, và có nhiều cách viết đều đúng.
  • Sửa lỗi khi npm run kiem đỏ: agent làm được, nhưng nên là việc có người xem. Mỗi lỗi một khác, và sửa sai có thể che lỗi thật.
  • Nhắc AI cùng vài quy ước ở mỗi phiên: không phải script hay agent mà là CLAUDE.md, như tập trước.

Có một chỗ hai bên gặp nhau mà mình thấy đáng thử: cho agent chạy npm run kiem và đọc kết quả, rồi tự sửa tới khi xanh. Claude Code có cơ chế hook riêng của nó, chạy một lệnh sau mỗi lần AI sửa file (loại PostToolUse), và hướng dẫn hooks của Claude Code có ví dụ. Mình chưa cấu hình nó ở tập này và chưa chạy một agent nào, nên mình không nói được nó giúp được bao nhiêu hay khi nào nó gây rối. Điều mình chắc là: npm run kiem là bước nền mà cả người và AI đều dùng được, và đó là lý do mình làm nó trước.

Để dự án nhớ điều đó, mình thêm một dòng vào CLAUDE.md: "Kiểm kiểu, test và CLAUDE.md một lượt, chạy trước khi commit: npm run kiem. Git hook trong hooks/ cũng chạy lệnh này (cài bằng git config core.hooksPath hooks)." Bộ kiểm CLAUDE.md của tập trước báo 0 lỗi, 0 cảnh báo, tức là các lệnh và đường dẫn trong dòng mới đều còn thật.

Giữ các script này bằng test

Chín test mới của tập này kiểm các điều bài đã nói. Với kiem.ts, mình dùng một dự án giả chỉ có ba script thoát với mã mình chọn, để không phải chạy tsc thật: cả ba xanh thì dat là true, mặc định dừng ở bước đầu tiên hỏng, --het chạy đủ ba và báo từng bước, và bước hỏng hiện đúng dòng chứa not ok. Với kiem-commit-msg.ts: dòng đúng dạng thì qua, sáu kiểu mơ hồ ("fix", "ok", "xong", "WIP", "update", "...") đều bị báo, thiếu kiểu hoặc thiếu mô tả thì báo sai dạng, quá 72 ký tự hoặc có dấu chấm cuối thì báo, và commit Merge, Revert do Git sinh thì bỏ qua. Bạn chạy bằng npm test (file test nằm trong repo demo, bài này mình không dán), và lệnh này chạy cả test của tập trước nên tổng là 30:

npm test (phần tổng kết)
# tests 30
# pass 30
# fail 0

Những điều bài này chưa làm

Mình nói thẳng giới hạn. Một, không có AI hay agent nào chạy ở tập này; phần "việc nào cho agent" là nhận định, không phải kết quả thử. Hai, hook pre-commit chạy trên cây làm việc, không phải đúng thứ bạn đã git add. Nếu bạn chỉ stage một nửa thay đổi, hook vẫn kiểm cả phần chưa stage, nên có thể báo xanh cho thứ không được commit, hoặc đỏ vì thứ bạn không định commit; mình chưa làm bản chỉ kiểm phần đã stage. Ba, mình chỉ thử trên Windows (Git for Windows chạy hook bằng sh của nó). Trên Linux và macOS file hook cần quyền thực thi (chmod +x hooks/*), và mình đã thêm .gitattributes để Git giữ hook ở dạng LF, vì một file .sh có ký tự CRLF ở dòng đầu thường không chạy được. Bốn, kiem.ts mất khoảng 1,7 giây trên dự án nhỏ này. Với dự án lớn mà hook chậm cả chục giây, người ta sẽ quen tay gõ --no-verify, và khi đó hook không còn tác dụng.

Tự động hóa rồi, còn cách mình làm việc với AI thì sao?

Mười hai bài đầu của series này đã đi từ viết spec tới kiểm chứng, bảo mật, đưa AI vào chính app và giữ quy ước bằng CLAUDE.md. Giờ có thêm lớp tự động hóa dưới chân. Nhưng khi mọi thứ nhanh hơn, có một câu hỏi mình chưa trả lời: mình còn hiểu code mà AI viết ra không, hay chỉ bấm cho qua vì máy báo xanh? Nhìn lại cách mình làm việc với AI trong suốt các tập qua, và giữ cho mình vẫn là người hiểu, là việc của các bài viết sau.

Bạn theo dõi cả hành trình ở Làm side project cùng AI. Các câu hỏi về dùng AI khi lập trình nằm trong ngân hàng câu hỏi phỏng vấn.

Nhận bài tiếp theo qua email.

Một email mỗi tuần, chỉ khi có điều đáng đọc. Không spam.