Skip to content
TungDaDev's Blog

All Code Is Slop: cách team Grok Bot ship 11.000 PR/tháng

Shallow focus photography of potted plants
Published on
14 mins read

Bạn mở một pull request do agent viết. Code chạy, test xanh, nhưng đọc tới đâu thấy gợn tới đó: một cái setTimeout(0) để "chờ state cập nhật", một đoạn comment dài giải thích vì sao chỗ này phải làm tắt, và một import kéo nguyên module ở tầng khác sang. Bạn sửa, nhắc agent "đừng làm thế nữa", rồi tuần sau gặp lại đúng kiểu đó ở PR khác.

Nếu mỗi ngày chỉ có vài PR thì chịu khó review là xong. Nhưng team Grok Bot ở SpaceX ship 11.000 PR lên production trong một tháng. Không ai đọc nổi chừng đó code. Vậy họ giữ chất lượng bằng cách nào?

Đó là chủ đề bài nói "All Code Is Slop (Except Mine)" của Lauren Tan tại AI Engineer Code 2026 (giữa tháng 11/2026, dài khoảng 17 phút). Bài này tóm tắt những gì chị ấy nói, đối chiếu từng con số với lời thoại gốc, rồi thêm góc nhìn của mình: chỗ nào áp dụng được ngay cho một team Java/Spring, chỗ nào cần đọc với chút hoài nghi.

# Lauren Tan là ai

Lauren Tan, biệt danh "poteto", là principal engineer trong team Grok Bot ở SpaceX SI (xAI đã sáp nhập vào SpaceX hồi tháng 2/2026). Trước đó chị ở Netflix, rồi Meta, nơi chị nằm trong core team của React Compiler, sau đó làm ở Cursor. Chị cũng là tác giả pstack, bộ skill cho coding agent nằm trong kho plugin chính thức của Cursor.

Nói vậy để thấy đây không phải một người hô hào "AI thay lập trình viên". Người nói là kỹ sư từng viết compiler cho React, và luận điểm chính của chị lại rất "kỹ sư": muốn tin agent thì phải đầu tư vào môi trường của agent, không phải tin mù quáng.

# luận điểm: chuyện không nằm ở khối lượng, mà ở niềm tin

Lauren mở bài bằng một con số: tháng trước, riêng chị ship 3.000 PR lên production. Trước thời agent, khối lượng không phải thước đo; chỉ vài người ngoại lệ mới được gọi là "coding machine", kiểu Bret Taylor viết lại Google Maps trong một cuối tuần. Giờ ai có agent cũng thành coding machine được.

Nên theo chị, cái khó của nghề bây giờ là giữ (thậm chí nâng) chất lượng code trong khi năng suất tăng vọt. Người ta hay gọi mô hình này là "software factory". Lauren gọi đơn giản hơn: chuyện niềm tin. Không phải tin bừa, mà đầu tư vào môi trường của agent tới mức tin được là agent sẽ làm đúng. Chị nói thẳng là mất sáu tháng mới tới được lúc ship hàng nghìn PR, nhiều cái trong lúc chị đang ngủ.

# kim tự tháp ngược: tiền đầu tư nên đổ vào đâu

Phần xương sống của bài nói là một kim tự tháp ngược, xếp các lớp theo mức độ nên ưu tiên:

Hai lớp trên cùng là tất định: chính codebase và những công cụ kiểm tra máy móc (lint, type system, compiler, test). Dùng chúng để ép agent làm đúng ngay từ đầu. Lớp thứ ba là verification, để tìm bug và kiểm tra agent có hiểu đúng ý mình không. Văn xuôi như rules, skills, AGENTS.md, những thứ cần phán đoán, xếp cuối cùng.

Thứ tự này đi ngược một thói quen khá phổ biến: agent làm sai thì thêm một dòng vào file rules. Lauren cho rằng mỗi lần sửa agent nên được hỏi lại: có biến được lần sửa này thành một check tất định không? Một dòng trong AGENTS.md thì agent có thể đọc hoặc không, hiểu đúng hoặc không. Một lint rule thì lần nào cũng chạy, kết quả như nhau.

# codebase là khu vườn

Lý do lớp "code" nằm trên cùng khá giản dị: agent sinh output dựa trên input, và codebase là input lớn nhất.

Lauren kể năm 2024 mỗi sáng chị review khoảng ba PR của đồng nghiệp; giờ con số đó là khoảng 300. Mỗi kỹ sư giờ giống một team hàng trăm, hàng nghìn agent, code đổ vào gần như liên tục, như một thứ đang sống. Chị gọi đó là "organic architecture": ràng buộc và guardrail của bạn là bộ khung bê tông, còn code agent viết mọc quanh nó như cây quanh nhà.

Hệ quả khá đáng sợ: mọi workaround, anti-pattern, code deprecated hay nợ kỹ thuật trong repo đều trông như pattern đã được chấp nhận, và agent kế tiếp sẽ chép lại. Cỏ dại mọc một chỗ, vài hôm sau lan khắp vườn. Nên việc của kỹ sư giờ giống làm vườn hơn: giữ codebase sạch để agent luôn chép thứ tốt.

# ba ví dụ từ Dune

Để làm được điều trên, team dựng Dune, một framework client cho Grok Bot. Lauren tả nó "chẳng có gì hay về mặt kỹ thuật", đại khái như Next.js cho app Electron. Cái đáng học là Dune gói rất nhiều bài học làm app desktop thành ràng buộc và lint rule.

Cấm useEffect trong code sản phẩm. Thứ gì cần nhiều tinh tế mới dùng đúng thì thường sinh ra rác, và useEffect của React là ví dụ kinh điển (chị đùa là cần bằng tiến sĩ mới dùng nổi). Agent dùng nó rất tệ. Giải pháp của team là cấm luôn trong product code, chỉ cho phép bên trong vài API của Dune. Từ đó cả một nhóm lỗi biến mất, review không phải soi nữa.

Truyền ngữ cảnh qua cấu trúc thư mục. Ở Cursor (cũng là app Electron), agent hay import code của main process sang renderer, gây long task và giật lag. Trong Grok Bot, có hẳn hai thư mục gốc tên electron-main và electron-renderer, và import qua lại giữa chúng bị chặn bằng dependency graph analyzer cùng vài lint rule. Cách đặt tên tự nó đã nói cho agent biết code này chạy ở đâu.

Cấm gần như toàn bộ comment. Đây là phần gây tranh cãi nhất. Lauren kể ở Cursor, agent rất thích dùng timer kiểu setTimeout, requestAnimationFrame, requestIdleCallback để chữa cháy. Gốc rễ là xung đột giữa phong cách imperative của VS Code và declarative của React, nghĩa là chính lựa chọn kiến trúc đã làm cả app lẫn agent tệ đi. Timer tạo rồi huỷ liên tục khiến GC chạy dày, app giật. Tệ nhất là agent viết rất nhiều comment giải thích vì sao cách chữa cháy này hợp lý, và agent sau đọc comment đó rồi chép tiếp. Timer lan khắp nơi.

Bài học của chị: agent dùng Markdown (comment, docs, rules) làm chỗ biện minh cho việc không làm đúng, hoặc bám một lần sửa nhỏ thành luật cứng mãi mãi. Comment lại không ép buộc được gì. Nên Grok Bot cấm khoảng 99% comment, thay vào đó là lint rule có thông báo lỗi chỉ thẳng cách sửa gốc rễ.

Nguyên tắc chung: mỗi lần sửa agent thì hoặc thành một check tất định, hoặc tìm cách xoá hẳn nhóm lỗi đó bằng API hay kiến trúc tốt hơn. Làm đủ lâu, danh sách thứ cần soi khi review cứ ngắn dần, tới lúc chẳng còn gì để review, và agent tự merge phần lớn PR của nó.

# thử làm cho codebase của bạn

Hai ràng buộc của Dune dựng được bằng công cụ có sẵn trong vài phút. Ví dụ dưới mình đã chạy thử với ESLint 9 và dependency-cruiser 16. Điểm quan trọng nằm ở thông báo lỗi: nó là chỉ dẫn cho agent đọc, nên phải nói cách làm đúng, không chỉ nói "sai rồi".

// eslint.config.mjs: chỉ thư mục src/dune được dùng useEffect
const banUseEffect = {
  'no-restricted-imports': [
    'error',
    {
      paths: [
        {
          name: 'react',
          importNames: ['useEffect', 'useLayoutEffect'],
          message:
            'useEffect is banned in product code. Derive state during render, or use a Dune API (useSubscription, useMutation).',
        },
      ],
    },
  ],
  'no-restricted-syntax': [
    'error',
    {
      selector: "MemberExpression[object.name='React'][property.name=/^use(Layout)?Effect$/]",
      message: 'React.useEffect is banned in product code. Use a Dune API instead.',
    },
  ],
}
 
export default [
  { files: ['src/**/*.js'], languageOptions: { sourceType: 'module' }, rules: banUseEffect },
  {
    files: ['src/dune/**/*.js'],
    rules: { 'no-restricted-imports': 'off', 'no-restricted-syntax': 'off' },
  },
]
// .dependency-cruiser.cjs: renderer và main không được import lẫn nhau
module.exports = {
  forbidden: [
    {
      name: 'renderer-must-not-import-main',
      severity: 'error',
      comment: 'Main-process code in the renderer blocks the UI thread. Talk to main over IPC.',
      from: { path: '^src/electron-renderer/' },
      to: { path: '^src/electron-main/' },
    },
    {
      name: 'main-must-not-import-renderer',
      severity: 'error',
      from: { path: '^src/electron-main/' },
      to: { path: '^src/electron-renderer/' },
    },
  ],
  options: { doNotFollow: { path: 'node_modules' } },
}

Phía backend Java, ý tưởng y hệt, công cụ là ArchUnit. Giả sử agent "tiện tay" cho module order gọi thẳng repository nội bộ của billing thay vì đi qua BillingApi:

import com.tngtech.archunit.core.domain.JavaClasses;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import com.tngtech.archunit.lang.ArchRule;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
 
public class ModuleBoundaryCheck {
  // Modules talk through their api package; internal packages stay private to their module.
  static final ArchRule ORDER_MUST_NOT_REACH_INTO_BILLING = noClasses()
      .that().resideInAPackage("com.shop.order..")
      .should().dependOnClassesThat().resideInAPackage("com.shop.billing.internal..")
      .because("billing.internal is private to billing: call BillingApi (billing.api) instead");
 
  public static void main(String[] args) {
    JavaClasses classes = new ClassFileImporter().importPackages("com.shop");
    ORDER_MUST_NOT_REACH_INTO_BILLING.check(classes);
  }
}

Chạy với ArchUnit 1.3.0, rule bắt đủ ba chỗ (constructor, field, method call) kèm số dòng, và câu because(...) hiện ngay trong thông báo lỗi, đúng thứ agent cần đọc để tự sửa. Trong dự án thật bạn sẽ để nó trong một test JUnit, hoặc dùng luôn ApplicationModules.verify() của Spring Modulith nếu đã chia module theo kiểu đó.

# verification: đọc bằng chứng thay vì đọc code

Lớp thứ ba là thứ giúp agent tự chủ hơn và giúp người tin kết quả hơn. Code review của team giờ co lại thành xem "verification artifact": video, ảnh chụp màn hình, sơ đồ, kết quả formal verification.

Cơ bản nhất là runtime verification: cho agent tự chạy app và dùng đúng công cụ debug người dùng, như Chrome DevTools Protocol. Team có hai mẹo đáng chép:

  • Feature map: một kiểu sitemap liệt kê mọi tính năng nhìn từ phía người dùng. Bạn nói "cái nút ở sidebar trái" thì agent không phải đoán, hai bên có chung từ vựng.
  • CLI và driver tự viết đặt trong skill: agent gọi lại cùng một công cụ mỗi lần, đỡ tốn token, và chính công cụ đó test được.

Team còn thử formal verification: dùng TLA+ để model check các luồng lớn như thông báo xuyên nhiều thiết bị và nền tảng, dùng Lean để chứng minh thư viện virtualization tự viết không bị nháy hay giật. Ngoài ra có Bombadil, thư viện property-based testing cho UI, đã bắt được vài bug. Lauren nói rõ đây chưa phải viên đạn bạc, chỉ là thêm một lớp, dù cách này đã tìm ra khá nhiều bug.

Chị trích tweet của một người tên Cindy: sáu tháng trước Cindy không tin nổi agent vì bug ngầm cứ lọt vào; giờ 70% token mỗi ngày của Cindy dành cho verification. Lauren nói con số đó khớp với chị, phần lớn token của chị cũng đổ vào verification. Ý quan trọng nhất ở đây: mấy kỹ thuật này không mới, chỉ là trước kia quá đắt để viết và bảo trì. Agent kéo chi phí đó xuống, nên theo chị ta đang bước vào "thời hoàng kim của testing và verification". Để review dễ hơn, chị còn làm skill statechart trong pstack, vẽ state machine theo góc nhìn người dùng để xem cạnh video và ảnh chụp.

# kết quả, và đọc nó thế nào cho tỉnh

Theo Lauren, sau khoản đầu tư này:

Chỉ số (team tự báo cáo)Giá trị
PR lên production tháng gần nhấtkhoảng 11.000
Bản stable của clientkhoảng một bản mỗi ngày
Người đóng góp ít nhất 1 PR trong tháng 10khoảng 227, gồm nhiều người "ghé qua"
Tỉ lệ PR bị revertổn định quanh 0,5%, giảm theo tỉ lệ tương đối
Hiệu năng appkhởi động, gõ phím, mở và chuyển chat đều nhanh hơn lúc ra mắt

Vòng ngoài cũng tự động: mỗi lần cắt release, Grok Bot tự dựng một project Cursor để fuzz toàn bộ app như người dùng thật, mỗi bug tìm được thành một PR sửa, và PR đó tự merge. Chị nói làm được vậy vì codebase đủ tốt để PR "mặc định là tốt".

Mình thấy cách làm rất thuyết phục, nhưng vẫn nên đọc con số cho tỉnh:

  • Đây là số team tự báo cáo trong một keynote, chưa có bài kỹ thuật hay số liệu độc lập đi kèm.
  • Revert rate 0,5% không phải tỉ lệ bug. Nó chỉ đếm những PR tệ tới mức phải lùi lại. Bug nhỏ được sửa bằng PR tiếp theo không hiện trong con số này, và với 11.000 PR, 0,5% vẫn là khoảng 55 lần revert một tháng.
  • PR của agent thường nhỏ. 11.000 PR không cùng đơn vị với 11.000 PR của người, nên đừng so thẳng năng suất.
  • Grok Bot là sản phẩm của chính SpaceX, và phần cuối bài nói có quảng bá nó như công cụ dựng "vòng ngoài". Không làm sai đi điều gì, chỉ là nên biết bối cảnh.

Chuyện cấm 99% comment thì mình không áp dụng nguyên xi. Lauren nhắm vào loại comment agent dùng để biện minh cho cách làm tắt, và điểm đó đúng. Nhưng comment giải thích "vì sao" ở tầng nghiệp vụ, kiểu một ràng buộc pháp lý hay một quyết định với đối tác, vẫn có giá trị với người đọc. Cách dung hoà mình thấy hợp lý: chuyển các "luật" hiện đang nằm trong comment thành lint rule hoặc test, còn quyết định kiến trúc thì ghi vào ADR, nơi có người review.

# nên làm gì từ tuần sau

Lời khuyên chốt của Lauren khá ngắn: trước khi dựng "software factory" và tự động hoá mọi thứ, mỗi lần sửa agent hãy sửa bằng codebase trước. Viết lint rule để chặn anti-pattern mới, rồi dọn các chỗ cũ. Làm verification cho chắc. Vì nếu vòng lặp code bên trong đang sinh rác, tự động hoá nó chỉ sinh ra nhiều rác hơn, và bạn sẽ phải đổ ngày càng nhiều token vào để chữa.

Nếu chỉ chọn ba việc để bắt đầu, mình sẽ làm thế này:

  1. Mở lại file AGENTS.md (hay CLAUDE.md, .cursor/rules), tìm những dòng kiểu "không được làm X", và thử biến từng dòng thành lint rule hoặc ArchUnit test có thông báo lỗi tử tế.
  2. Chọn một anti-pattern agent hay chép nhất trong repo, chặn chỗ mới bằng rule, rồi dọn hết chỗ cũ để agent không còn mẫu xấu mà chép.
  3. Cho agent một cách tự chạy và tự kiểm tra app: một script khởi động, vài lệnh CLI để gọi tính năng, và yêu cầu kèm ảnh chụp hoặc log làm bằng chứng trong mỗi PR.

Video gốc chỉ khoảng 17 phút, đáng xem nguyên bài. Ai muốn đọc thêm về cách dựng môi trường cho agent thì có hai bài trước trên blog: kiến trúc agentic AI và ADLC: vòng đời phát triển agent.

Tham khảo:


Chỉ là những ghi chép cá nhân với hy vọng mang lại chút giá trị. Nếu thấy hữu ích, đừng ngại chia sẻ cho bạn bè & đồng nghiệp nhé!

Happy coding 😎 👍🏻 🚀 🔥.