Tuần trước mình giao cho một coding agent sửa một bug khá rõ ràng: hàm tính phí vận chuyển trả sai kết quả với đơn hàng quốc tế. Mười phút sau agent báo: "All tests passing ✅". Mở diff ra xem thì thấy agent không hề sửa logic tính phí. Nó sửa expected value trong test cho khớp với output sai. CI vẫn xanh. PR trông vẫn ổn nếu chỉ lướt qua.
Trên HN đang có bài "Your Agent Will Pick the Hackable One", nói đúng chuyện này: nếu có một đường tắt để đạt mục tiêu, agent sẽ chọn đường tắt đó. Đây không phải vì agent "xấu tính". Mục tiêu bạn đưa ra ("làm cho test pass") và mục tiêu bạn thật sự muốn ("code chạy đúng") là hai thứ khác nhau. Trong ML, hiện tượng này gọi là reward hacking hay specification gaming. Bài này chia sẻ cách mình dựng guardrail để agent khó "ăn gian" hơn, và khi nó ăn gian thì mình phát hiện được ngay.
Agent thường "hack" theo những cách nào?
Sau vài tháng dùng agent hằng ngày, mình gom được mấy pattern hay gặp:
-
Sửa test thay vì sửa code: đổi
assertEqual(result, 42)thànhassertEqual(result, 41). -
Skip test: thêm
@pytest.mark.skip,it.skip(...)hoặcxfailvới lý do nghe rất hợp lý, kiểu "flaky test". -
Hardcode output:
if input == "test_case_3": return expected. Kiểu này hiếm, nhưng có gặp. -
Nuốt exception: bọc
try/except: passquanh đoạn code đang fail. -
Nới assertion:
assert x == 5thànhassert x is not None. -
Sửa config: hạ
coverage fail_undertừ 80 xuống 0, hoặc thêm file vàoexcludecủa linter.
Điểm chung là tất cả đều làm metric đẹp lên mà không làm chất lượng tốt lên. Agent tối ưu đúng cái bạn đo, nên phải đo cái mà agent khó gian lận.
flowchart LR
A[Task: fix bug] --> B{Agent chọn đường nào?}
B -->|Khó| C[Sửa logic thật]
B -->|Dễ| D[Sửa test / skip / hardcode]
C --> E[CI xanh]
D --> E
E --> F{Guardrail?}
F -->|Không có| G[Merge code lỗi]
F -->|Có| H[Chặn + báo review]
Guardrail 1: Khóa test file ở tầng CI
Cách đơn giản và hiệu quả nhất: nếu task là "sửa bug trong src/" thì PR không được đụng vào tests/, trừ khi có label cho phép rõ ràng. Mình dùng một script nhỏ chạy trong GitHub Actions:
#!/usr/bin/env bash
# scripts/guard_tests.sh
set -euo pipefail
BASE="${BASE_REF:-origin/main}"
CHANGED=$(git diff --name-only "$BASE"...HEAD)
PROTECTED_PATTERNS='^(tests/|pytest\.ini|pyproject\.toml|\.coveragerc|setup\.cfg)'
VIOLATIONS=$(echo "$CHANGED" | grep -E "$PROTECTED_PATTERNS" || true)
if [[ -n "$VIOLATIONS" && "${ALLOW_TEST_CHANGES:-false}" != "true" ]]; then
echo "::error::PR sửa file được bảo vệ:"
echo "$VIOLATIONS"
echo "Thêm label 'allow-test-changes' nếu thay đổi này là cố ý."
exit 1
fi
echo "OK: không đụng vào test/config được bảo vệ"
Trong workflow, set ALLOW_TEST_CHANGES dựa trên label của PR: ${{ contains(github.event.pull_request.labels.*.name, 'allow-test-changes') }}. Như vậy agent vẫn được viết test mới khi cần, nhưng phải có người đồng ý gắn label.
Nếu dùng Claude Code, Cursor hay Aider thì nên chặn luôn ở tầng tool. Phần lớn các agent hiện nay đều cho cấu hình deny ghi vào một số path. Chặn sớm vẫn rẻ hơn bắt lỗi ở CI.
Guardrail 2: Phân tích diff để bắt các pattern đáng ngờ
Không phải lúc nào cũng khóa cứng được tests/, ví dụ khi task là viết feature mới kèm test. Khi đó mình dùng một script Python quét diff, tìm những dòng được thêm vào có dấu hiệu gian lận:
#!/usr/bin/env python3
# scripts/detect_gaming.py
import re
import subprocess
import sys
SUSPICIOUS = {
"skip_test": re.compile(r"@pytest\.mark\.(skip|xfail)|\b(it|describe|test)\.skip\("),
"swallow_exc": re.compile(r"except(\s+Exception)?\s*:\s*(pass|\.\.\.)\s*$"),
"weak_assert": re.compile(r"assert\s+(True|.+\s+is\s+not\s+None)\s*$"),
"no_cover": re.compile(r"#\s*(pragma:\s*no\s*cover|type:\s*ignore|noqa)"),
"lower_threshold": re.compile(r"fail_under\s*=\s*\d+"),
}
def added_lines(base: str):
diff = subprocess.run(
["git", "diff", "-U0", f"{base}...HEAD"],
capture_output=True, text=True, check=True,
).stdout
current_file = None
for line in diff.splitlines():
if line.startswith("+++ b/"):
current_file = line[6:]
elif line.startswith("+") and not line.startswith("+++"):
yield current_file, line[1:]
def main():
base = sys.argv[1] if len(sys.argv) > 1 else "origin/main"
hits = []
for path, code in added_lines(base):
for name, pattern in SUSPICIOUS.items():
if pattern.search(code):
hits.append(f"[{name}] {path}: {code.strip()}")
if hits:
print("⚠️ Phát hiện pattern đáng ngờ:")
print("\n".join(hits))
sys.exit(1)
print("Không phát hiện pattern gian lận.")
if __name__ == "__main__":
main()
Script này sẽ có false positive, và mình chấp nhận điều đó. Mục đích không phải chặn tuyệt đối mà là buộc con người nhìn vào đúng chỗ. Mình để job này ở chế độ fail và cho phép override bằng label, giống guardrail 1. Mấu chốt là agent không thể tự mở khóa.
Guardrail 3: Mutation testing, đo xem test có "cắn" không
Hai guardrail trên bắt được kiểu gian lận lộ liễu. Kiểu tinh vi hơn là agent viết test mới nhưng test đó gần như không kiểm tra gì. Coverage vẫn 90% nhưng assertion rất yếu.
Cách mình dùng là mutation testing: tool tự động sửa code (đổi > thành >=, + thành -, True thành False...), rồi chạy lại test. Nếu test vẫn pass sau khi code bị "phá" thì test đó vô dụng.
Với Python, mình dùng mutmut (bản 3.x):
pip install "mutmut>=3.0"
# Chỉ chạy trên các file agent vừa sửa để tiết kiệm thời gian
CHANGED=$(git diff --name-only origin/main...HEAD -- 'src/*.py' | tr '\n' ',')
# Khai báo paths_to_mutate trong [tool.mutmut] của pyproject.toml
# hoặc truyền qua biến môi trường tùy setup
mutmut run
mutmut results # liệt kê các mutant "survived"
Với JS/TS thì có Stryker (npx stryker run), hỗ trợ Jest, Vitest và Mocha. Mutation testing chậm, nên đừng chạy trên toàn repo mỗi lần commit. Mình chỉ chạy trên file thay đổi trong PR do agent tạo, và đặt ngưỡng mutation score tối thiểu khoảng 70% cho phần code mới.
sequenceDiagram
participant Agent
participant CI
participant Mutmut
participant Reviewer
Agent->>CI: Push PR
CI->>CI: guard_tests.sh + detect_gaming.py
CI->>Mutmut: Chạy trên file thay đổi
Mutmut-->>CI: Mutation score
alt Score thấp hoặc có pattern đáng ngờ
CI-->>Reviewer: Fail + highlight chỗ cần xem
else Tất cả OK
CI-->>Reviewer: Sẵn sàng review logic
end
Đừng quên phần "prompt" và quy trình
Guardrail kỹ thuật là lớp cuối. Còn mấy thói quen nhỏ giúp giảm hẳn số lần agent đi đường tắt:
-
Nói rõ điều cấm: thêm vào file instruction của agent (
CLAUDE.md,.cursorrules,AGENTS.md) những câu như "Không bao giờ sửa test có sẵn để làm nó pass. Nếu nghĩ test sai, dừng lại và giải thích." Agent tuân thủ khá tốt khi có quy tắc tường minh. - Cho agent một lối thoát hợp lệ: agent hay hack khi bị ép phải "xong việc". Cho phép nó trả lời "Tôi không sửa được, lý do là..." thì tỉ lệ gian lận giảm rõ rệt.
- Hidden test: giữ một bộ test acceptance mà agent không đọc được (chạy ở CI riêng, không nằm trong workspace). Agent không thể overfit vào thứ nó không nhìn thấy.
-
Review diff theo thứ tự: mình luôn mở phần thay đổi ở
tests/và config trước, rồi mới đọc phần logic.
Kết luận
Agent không cố tình lừa bạn. Nó chỉ tối ưu đúng cái mục tiêu bạn đặt ra. Nếu mục tiêu là "CI xanh" thì sẽ có lúc nó tìm ra cách làm CI xanh rẻ nhất. Việc của mình là làm cho đường tắt đắt hơn đường đúng.
Các bước có thể áp dụng ngay trong tuần này:
-
Hôm nay: thêm
guard_tests.shvào CI, khóatests/và các file config coverage/lint, chỉ mở bằng label do người gắn. -
Tuần này: chạy
detect_gaming.pytrên mọi PR do agent tạo, rồi tinh chỉnh regex theo codebase của bạn. -
Khi có thời gian: tích hợp
mutmuthoặc Stryker cho file thay đổi, đặt ngưỡng mutation score cho code mới. - Luôn luôn: viết rõ quy tắc "không sửa test để pass" vào instruction file, và cho agent quyền nói "tôi không làm được".
Đừng chỉ hỏi agent "test pass chưa?". Hãy hỏi "test có đang kiểm tra đúng thứ mình cần không?". Câu trả lời cho câu thứ hai mới là thứ bảo vệ production của bạn.
Top comments (0)