Cách xây dựng vòng lặp AI đầu tiên của bạn vào năm 2026

Hai trong số những kỹ sư AI hàng đầu còn sống đã nói cùng một điều vào tháng trước.

Peter Steinberger, người tạo ra OpenClaw, hiện đang làm việc tại OpenAI:

"Bạn không nên prompt các coding agent nữa. Bạn nên thiết kế các vòng lặp để prompt các agent của bạn."

Boris Cherny, trưởng nhóm Claude Code tại Anthropic:

"Tôi không còn prompt Claude nữa. Tôi có các vòng lặp chạy để prompt Claude và tìm ra việc cần làm. Công việc của tôi là viết các vòng lặp."

Hầu hết mọi người đọc điều đó và nghĩ: điều đó thực sự có nghĩa là gì?

Và quan trọng hơn: làm thế nào để tôi xây dựng một cái?

Bài viết này sẽ cho bạn biết chính xác cách làm.

Không có lý thuyết mà không có code. Không có code mà không có ngữ cảnh. Các bước thực tế. Các lệnh thực tế. Sao chép và chạy.

Slate đang điều phối GPT-5.6, Claude và các subagent chuyên biệt trong một tác vụ di chuyển thực tế. Mô hình trở nên thông minh hơn. Thay đổi lớn hơn là các công cụ như Slate cuối cùng cũng có thể giữ cho các mô hình đó bận rộn liên tục thay vì chờ đợi các prompt từ con người.

Cách hầu hết mọi người sử dụng AI đã lỗi thời

Viết prompt. Chờ đợi. Đọc output. Sửa nó bằng tay. Viết một prompt khác.

Bạn chính là vòng lặp.

Mọi bước đều đi qua bạn. AI chờ đợi. Bạn quyết định. AI lại chờ đợi.

Khoảnh khắc bạn dừng lại, mọi thứ đều dừng.

Những người xây dựng đang di chuyển nhanh nhất vào năm 2026 không phải là những người viết prompt tốt hơn.

Họ đang xây dựng các hệ thống tự động thực hiện việc prompt cho họ.

Điểm đòn bẩy đã thay đổi.

Từ việc gõ prompt → đến việc thiết kế các vòng lặp.

Điều gì đã thay đổi với GPT-5.6?

GPT-5.6 không thay đổi nhu cầu về các vòng lặp.

Nó làm tăng giá trị của chúng.

Mô hình càng tốt, việc để nó nhàn rỗi giữa các prompt càng trở nên đắt đỏ.

Trong các quy trình làm việc trên terminal, GPT-5.6 tốt hơn đáng kể trong việc:

→ hiểu các codebase lớn

→ duy trì tính nhất quán trong triển khai

→ làm theo các kế hoạch nhiều bước

→ phục hồi sau các lần thử thất bại

→ hoạt động như một bộ xác minh nghiêm ngặt

Kết quả không phải là "prompt tốt hơn."

Mà là ít sự can thiệp của con người hơn cho mỗi tác vụ.

Vòng lặp thực sự là gì

Định nghĩa đơn giản:

Một prompt trả lời một lần và dừng lại.

Một vòng lặp tiếp tục làm việc cho đến khi công việc thực sự hoàn thành.

Không phải cho đến khi nó tạo ra một câu trả lời.

Mà là cho đến khi nó đạt được một kết quả đã được xác minh.

Mọi AI agent nghiêm túc đều chạy cùng một chu kỳ cơ bản:

→ Khám phá — cần làm gì?

→ Thực thi — làm công việc

→ Xác minh — nó có thực sự hoạt động không?

→ Lặp lại — chưa xong? sửa và lặp lại

→ Dừng — điều kiện đã đáp ứng, hoặc đạt giới hạn cứng

Claude Code. Cursor. Codex.

Bên dưới, tất cả đều chạy vòng lặp này.

Sự khác biệt giữa một prompt và một vòng lặp không phải là mô hình.

Mà là liệu có thứ gì đó kiểm tra công việc và tiếp tục cho đến khi nó vượt qua hay không.

Bài kiểm tra 4 điều kiện — chạy cái này trước khi xây dựng bất cứ thứ gì

Hầu hết các vòng lặp đều thất bại ở đây.

Một vòng lặp chỉ đáng giá chi phí thiết lập khi cả 4 điều kiện đều đúng.

Thiếu một điều kiện và vòng lặp sẽ tốn kém hơn nhiều so với lợi ích nó mang lại.

1. Tác vụ lặp lại. Ít nhất hàng tuần. Một tác vụ một lần vẫn tốt hơn nếu chỉ dùng một prompt tốt.

2. Việc xác minh được tự động hóa. Phải có thứ gì đó có thể đánh giá công việc thất bại mà không cần bạn có mặt. Các bài kiểm tra. Linters. Builds. Kiểm tra kiểu. Không có rào cản = agent đang tự chấm điểm bài tập của chính nó.

3. Ngân sách token của bạn có thể chịu được sự lãng phí. Các vòng lặp đọc lại toàn bộ ngữ cảnh trong mỗi lần lặp. Chúng thử lại, khám phá, đốt token cho dù lần chạy có tạo ra thứ gì hay không. Đây là chi phí mà không ai đề cập đến.

4. "Hoàn thành" là khách quan. Một bài kiểm tra đậu hoặc rớt. Một build biên dịch được hoặc không. Không phải "khi nó trông ổn." Nếu hoàn thành cần ý kiến của con người, hãy giữ nó thủ công.

Vượt qua cả 4 → xây dựng vòng lặp.

Thất bại bất kỳ 1 → sử dụng prompt để thay thế.

Phiên bản trung thực: hầu hết các nhà phát triển chưa cần các vòng lặp nặng. Thứ mà mọi người đều có thể sử dụng là một vòng lặp đơn giản. Chúng ta sẽ xây dựng một cái ngay sau đây.

Cài đặt Slate

Slate là một AI coding agent được xây dựng chính xác cho việc này — chạy các tác vụ dài, song song, nhiều bước trong terminal của bạn.

Được xây dựng bởi RandomLabs. Agent đầu tiên được xây dựng đặc biệt cho dàn nhạc bầy đàn (swarm orchestration).

Điều gì làm nó khác biệt so với Claude Code hoặc Cursor:

→ Tự động chọn mô hình phù hợp cho mỗi bước. Lên kế hoạch với Claude, tìm kiếm với mô hình khác, thực thi với Codex — Slate quyết định.

→ Chạy các subagent song song đồng thời trên toàn bộ codebase của bạn

→ Quản lý ngữ cảnh của chính nó trong các phiên dài nhiều giờ

→ Làm việc cùng với bạn — không chỉ cho bạn

Cài đặt nó trong một dòng:

1npm i -g @randomlabs/slate

Điều hướng đến dự án của bạn và khởi động nó:

1cd /path/to/your/project
2slate

Thao tác đó sẽ mở giao diện TUI của Slate — một giao diện terminal nơi bạn giao nhiệm vụ cho nó và xem nó làm việc.

Bước 1 — Thiết lập workspace của bạn

Trước khi Slate có thể chạy các vòng lặp trên dự án của bạn, nó cần hiểu codebase của bạn.

Tạo một tệp AGENTS.md trong thư mục gốc của dự án. Đây là ngữ cảnh mà Slate đọc khi bắt đầu mỗi phiên làm việc.

1# AGENTS.md
2
3## Codebase này làm gì
4[Mô tả một đoạn văn về dự án]
5
6## Kiến trúc
7- src/api/ — Các route API Express
8- src/services/ — Logic nghiệp vụ
9- src/db/ — Các mô hình cơ sở dữ liệu (PostgreSQL qua Prisma)
10- tests/ — Bộ kiểm thử Jest
11
12## Các lệnh chính
13- npm test — chạy toàn bộ bộ kiểm thử
14- npm run build — Biên dịch TypeScript
15- npm run lint — Kiểm tra ESLint
16- npm run typecheck — tsc --noEmit
17
18## Quy tắc
19- Không bao giờ sửa đổi src/billing/ hoặc src/auth/ nếu không có sự chấp thuận của con người
20- Luôn chạy kiểm thử trước khi đánh dấu bất kỳ tác vụ nào là hoàn thành
21- Sử dụng mẫu xử lý lỗi hiện có trong src/utils/errors.ts
22
23## Môi trường
24- .env.slate chứa tất cả các biến môi trường mà Slate cần

Slate tự động đọc tệp này khi khởi động — không cần phải dán nó vào mỗi phiên.

Thêm các thư mục workspace của bạn vào bên trong Slate:

1/workspace add ./src
2/workspace add ./tests
3/workspace list

Hoặc tham chiếu các tệp cụ thể trực tiếp bằng cách sử dụng đề cập @:

1Vui lòng xem xét @src/api/routes.ts và đề xuất các cải tiến

Bước 2 — Cấu hình Slate

Tạo slate.json trong thư mục gốc của dự án để kiểm soát cách Slate hoạt động.

1{
2  "$schema": "https://randomlabs.ai/config.json",
3  "permission": {
4    "*": "allow",
5    "bash": "ask"
6  },
7  "models": {
8    "main": { "default": "anthropic/claude-opus-4.6" },
9    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
10    "search": { "default": "anthropic/claude-haiku-4.5" },
11    "reasoning": { "default": "openai/gpt-5.6" }
12  }
13}

Điều này làm gì:

→ "*": "allow" — Slate có thể đọc và ghi tệp mà không cần hỏi mỗi lần

→ "bash": "ask" — Slate hỏi trước khi chạy các lệnh shell (giữ cài đặt này cho đến khi bạn tin tưởng nó)

→ Cấu hình Models — mô hình nhanh rẻ cho tìm kiếm, mô hình đắt tiền cho lý luận chính

Đối với các lần chạy CI hoặc tự động hóa nơi bạn muốn không có lời nhắc nào:

1slate run "Chạy bộ kiểm thử và sửa bất kỳ lỗi nào" --dangerously-skip-permissions --output-format stream-json

Bước 3 — Tác vụ đầu tiên của bạn (chưa phải là một vòng lặp)

Trước khi xây dựng một vòng lặp, hãy đảm bảo một lần chạy thủ công duy nhất đáng tin cậy.

Đây là bước bị bỏ qua nhiều nhất. Và là lý do hầu hết các vòng lặp thất bại trong sản xuất.

Giao cho Slate một tác vụ thực tế:

1Vui lòng xem xét kiến trúc của toàn bộ codebase của tôi.
2Tạo một ARCH.md với:
3- cấu trúc hiện tại
4- các phụ thuộc giữa các module
5- 3 điều cần cải thiện
6Xem @src/ trước, sau đó @tests/

Xem Slate làm việc. Nó sẽ:

1. Tìm kiếm qua các tệp của bạn
2. Xây dựng sự hiểu biết về kiến trúc
3. Soạn thảo ARCH.md
4. Xem xét nó so với yêu cầu của bạn trước khi dừng lại

Đây đã là một vòng lặp nhỏ — nó kiểm tra output của chính nó trước khi hoàn thành.

Đối với một tác vụ dài hơn:

1Này Slate, hãy nghiên cứu codebase của tôi cho luồng xác thực,
2sau đó lập kế hoạch thêm hỗ trợ OAuth2.
3Hãy chắc chắn xem xét @src/auth/ và @src/api/routes.ts

Slate trả về một kế hoạch. Bạn lặp lại trên nó:

1Không, đừng thêm một lớp auth provider mới.
2Hãy làm theo cùng mẫu như ApiKeyAuth hiện có trong src/auth/api-key.ts

Phê duyệt kế hoạch. Slate thực thi tự động.

Bước 4 — Tạo một Skill (làm cho vòng lặp có thể tái sử dụng)

Skill là cách bạn ngừng giải thích lại dự án của mình mỗi phiên.

Viết nó một lần. Slate đọc nó trong mọi lần chạy có liên quan.

Tạo cấu trúc thư mục:

1mkdir -p .slate/skills/ci-triage
2touch .slate/skills/ci-triage/SKILL.md

Viết skill:

1---
2name: "ci-triage"
3description: "Phân loại các lỗi CI theo nguyên nhân gốc rễ và soạn thảo các bản sửa lỗi cho những lỗi dễ."
4---
5
6# Kỹ năng Phân loại CI
7
8## Tôi làm gì
9Khi một lần chạy CI thất bại, tôi:
101. Đọc output kiểm thử
112. Phân loại lỗi: vấn đề môi trường / kiểm thử không ổn định / lỗi thực tế / thay đổi phiên bản phụ thuộc / hạ tầng
123. Soạn thảo các bản sửa lỗi cho lỗi và vấn đề phụ thuộc
134. Chuyển các vấn đề môi trường và hạ tầng cho con người
14
15## Quy tắc phân loại
16- env: thiếu secret, sai biến môi trường → đánh dấu cho con người
17- flake: vượt qua khi chạy lại mà không thay đổi code → chạy lại một lần, sau đó ghi issue
18- bug: lỗi xác định liên quan đến commit gần đây → soạn thảo bản sửa
19- dependency: lỗi liên quan đến thay đổi phiên bản → soạn thảo PR rollback
20- infra: timeout, OOM, vấn đề runner → chuyển ngay lập tức
21
22## Mẫu sửa lỗi
23- Kiểm thử Auth thất bại → kiểm tra src/auth/middleware.ts trước
24- Kiểm thử Cơ sở dữ liệu thất bại → xác minh migration đã chạy trong môi trường CI
25- Kiểm thử E2E thất bại → kiểm tra các bộ chọn UI so với ảnh chụp nhanh mới nhất
26
27## Không bao giờ làm
28- Tắt các kiểm thử đang thất bại
29- Sửa đổi cấu hình CI mà không hỏi
30- Chạm vào src/billing/ hoặc src/payments/
31
32## Trạng thái
33Cập nhật STATE.md sau mỗi lần chạy:
34- Các tệp đã kiểm tra
35- Các phân loại đã thực hiện
36- Các PR đã mở
37- Các mục đã chuyển

Liệt kê các skill có sẵn bên trong Slate:

1/skills

Kích hoạt một skill theo cách thủ công:

1@ci-triage vui lòng phân loại các kiểm thử thất bại hôm nay

Hoặc Slate tự động kích hoạt các skill khi nó quyết định chúng có liên quan đến tác vụ hiện tại.

Bước 5 — Thêm trạng thái (bộ nhớ của vòng lặp)

Agent quên.

Tệp thì không.

Tạo STATE.md trong thư mục gốc của dự án:

1# Trạng thái Vòng lặp — Phân loại CI
2
3## Lần chạy cuối
42026-06-28 03:30 UTC — 7 lỗi được phân loại, 3 bản sửa lỗi được soạn thảo, 4 được chuyển
5
6## Đang tiến hành
7- claude/fix-auth-token-refresh — kiểm thử đang vượt qua cục bộ, đang chờ CI
8- claude/fix-flaky-payment-webhook — mẫu thử lại đã được áp dụng, đang theo dõi
9
10## Đã hoàn thành
11- claude/bump-axios-1.7.4 → đã merged (CI xanh)
12- claude/lint-fix-pass-june-28 → đã merged
13
14## Đã chuyển cho con người
15- src/billing/refund.ts — kiểm thử thất bại theo 3 cách, nguyên nhân gốc rễ không rõ ràng
16- ci/staging-runner — thời gian chờ hạ tầng, không phải vấn đề code
17
18## Bài học kinh nghiệm
19- 2026-06-27: PowerShell gặp sự cố TLS 1.2 trên runner Windows này. Sử dụng bash.
20- 2026-06-26: tests/e2e/checkout yêu cầu Stripe webhook secret trong env. Bỏ qua nếu thiếu.

Yêu cầu Slate sử dụng nó khi bắt đầu mỗi phiên bằng cách thêm vào AGENTS.md:

1## Bắt đầu phiên
2Luôn đọc STATE.md trước. Tiếp tục từ nơi lần chạy cuối cùng dừng lại.
3Cập nhật STATE.md vào cuối mỗi lần chạy với những gì đã làm và những gì tiếp theo.

Không có trạng thái: mọi lần chạy đều bắt đầu từ con số không.

Có trạng thái: mọi lần chạy đều tiếp tục và tích lũy dựa trên lần trước.

Bước 6 — Xây dựng vòng lặp thực tế

Bây giờ bạn có:

→ Workspace đã thiết lập (AGENTS.md)

→ Cấu hình (slate.json)

→ Một lần chạy thủ công đáng tin cậy đã được chứng minh

→ Một skill đã viết (ci-triage)

→ Tệp trạng thái đã tạo (STATE.md)

Đã đến lúc gói nó thành một vòng lặp thực sự.

Tùy chọn A: Vòng lặp tệp hàng đợi (đơn giản nhất)

Tạo loop.md:

1Đọc STATE.md để hiểu những gì đã được thử.
2
3Chạy skill phân loại CI trên tất cả các kiểm thử thất bại trong bản build cuối cùng.
4
5Đối với mỗi lỗi:
6- Phân loại nó bằng cách sử dụng các quy tắc skill ci-triage
7- Soạn thảo bản sửa cho lỗi và vấn đề phụ thuộc
8- Chuyển các vấn đề môi trường và hạ tầng
9
10Chạy các bản sửa. Kiểm tra xem các kiểm thử có vượt qua không.
11Nếu kiểm thử vượt qua → mở PR.
12Nếu kiểm thử vẫn thất bại → ghi lại trong STATE.md và dừng lại.
13
14Cập nhật STATE.md với mọi thứ đã làm trong lần chạy này.
15
16Dừng cứng: tối đa 8 lần thử. Khi đạt giới hạn, báo cáo trạng thái hiện tại.

Chạy nó:

1slate --queue loop.md

Slate đọc tệp hàng đợi và chạy từng khối như một tin nhắn đã xếp hàng đợi.

Tùy chọn B: Vòng lặp Headless/CI (tự động hóa)

Chạy không tương tác trong một GitHub Action hoặc cron job:

1slate run "$(cat loop.md)" --output-format stream-json --dangerously-skip-permissions

Trong một quy trình làm việc GitHub Actions:

1name: Vòng lặp Phân loại CI
2on:
3  workflow_run:
4    workflows: ["CI"]
5    types: [completed]
6
7jobs:
8  triage:
9    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
10    runs-on: ubuntu-latest
11    steps:
12      - uses: actions/checkout@v4
13
14      - name: Cài đặt Slate
15        run: npm i -g @randomlabs/slate
16
17      - name: Chạy vòng lặp phân loại
18        env:
19          SLATE_API_KEY: ${{ secrets.SLATE_API_KEY }}
20        run: |
21          slate run "$(cat loop.md)" \
22            --output-format stream-json \
23            --dangerously-skip-permissions \
24            --workspace ./src \
25            --workspace ./tests

Bây giờ mọi lỗi CI đều tự động kích hoạt vòng lặp phân loại.

Không cần con người cho đến khi chuyển giao.

Bước 7 — Thêm sub-agent (sự phân chia người tạo - người kiểm tra)

Cải tiến cấu trúc quan trọng nhất đối với bất kỳ vòng lặp nào.

Không bao giờ để cùng một agent chấm điểm bài tập của chính nó.

Mô hình đã viết bản sửa lỗi là một người chấm điểm quá rộng lượng.

Trong Slate, bạn có thể đặt các mô hình khác nhau cho các vai trò khác nhau:

1{
2  "models": {
3    "main": { "default": "anthropic/claude-opus-4.6" },
4    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
5    "search": { "default": "anthropic/claude-haiku-4.5" }
6  }
7}

Sau đó viết tác vụ của bạn để Slate sử dụng sự phân chia này một cách tự nhiên:

1Vui lòng sửa các kiểm thử auth đang thất bại.
2
3Bước 1: Yêu cầu một search agent khám phá src/auth/ để hiểu triển khai hiện tại.
4Bước 2: Yêu cầu một agent riêng biệt triển khai bản sửa dựa trên những gì đã tìm thấy.
5Bước 3: Yêu cầu một agent thứ ba xác minh bản sửa so với các yêu cầu kiểm thử ban đầu —
6        agent này KHÔNG được thấy quá trình triển khai.
7Bước 4: Chỉ mở PR nếu người xác minh chấp thuận.

Slate điều phối các subagent một cách tự động.

Search agent sử dụng một mô hình nhanh rẻ. Agent triển khai sử dụng một mô hình mạnh hơn. Người xác minh sử dụng một mô hình nghiêm ngặt không có quyền truy cập vào lý luận của người tạo.

Sự phân chia này là lý do tại sao Slate có thể chạy 5 subagent song song trên một tác vụ duy nhất — mỗi cái chuyên biệt, mỗi cái biệt lập.

Bước 8 — Mẫu vòng lặp trạng thái (cho các tác vụ chạy dài)

Đối với các tác vụ chạy trong nhiều giờ hoặc nhiều ngày, hãy sử dụng mẫu này trong prompt tác vụ của bạn:

1Bạn đang chạy một vòng lặp nhiều phiên.
2
3MỤC TIÊU: Di chuyển tất cả các route Express sang mẫu ApiError mới.
4Theo dõi tiến độ trong STATE.md.
5
6BẮT ĐẦU MỖI PHIÊN:
71. Đọc STATE.md
82. Tìm mục chưa hoàn thành đầu tiên trong "Các route còn lại"
93. Chỉ làm mục đó thôi
10
11KẾT THÚC MỖI PHIÊN:
121. Di chuyển các mục đã hoàn thành sang "Các route đã xong" trong STATE.md
132. Ghi lại bất kỳ trình chặn nào trong "Trình chặn"
143. Cập nhật dấu thời gian "Lần chạy cuối"
154. Dừng sạch sẽ
16
17ĐỊNH DẠNG STATE.md:
18---
19## Các route đã xong
20- [x] /api/users (2026-06-27)
21- [x] /api/auth/login (2026-06-28)
22
23## Các route còn lại
24- [ ] /api/payments/checkout
25- [ ] /api/payments/refund
26- [ ] /api/admin/users
27
28## Trình chặn
29- /api/payments/refund — yêu cầu xem xét của con người (chạm vào logic thanh toán)
30
31## Lần chạy cuối
322026-06-28 14:30 UTC
33---
34
35QUY TẮC CỨNG:
36- Không bao giờ chạm vào src/billing/ nếu không có sự chấp thuận của con người
37- Luôn chạy kiểm thử sau mỗi lần di chuyển route
38- Dừng lại sau khi hoàn thành MỘT route mỗi phiên

Chạy cái này mỗi sáng:

1slate --continue "$(cat loop.md)"

--continue tiếp tục phiên gần đây nhất thay vì bắt đầu lại.

Mỗi ngày, thêm một route. STATE.md theo dõi mọi thứ.

Vòng lặp tiếp tục chính xác từ nơi nó dừng lại.

Bước 9 — Các lệnh tùy chỉnh cho các vòng lặp được sử dụng nhiều nhất của bạn

Thêm các lệnh gạch chéo tùy chỉnh vào slate.json để các vòng lặp của bạn luôn cách một lần gõ phím:

1{
2  "command": {
3    "triage": {
4      "description": "Chạy vòng lặp phân loại CI",
5      "template": "Đọc STATE.md. Chạy skill ci-triage trên tất cả các kiểm thử thất bại. Cập nhật STATE.md khi hoàn thành.",
6      "agent": "build"
7    },
8    "review": {
9      "description": "Xem xét một tệp để kiểm tra tính đúng đắn",
10      "template": "Xem xét @$ARGUMENTS về tính đúng đắn, các trường hợp cạnh và tính nhất quán với code xung quanh."
11    },
12    "migrate": {
13      "description": "Di chuyển một route sang mẫu ApiError",
14      "template": "Đọc STATE.md. Di chuyển route chưa hoàn thành tiếp theo sang mẫu ApiError. Chạy kiểm thử. Cập nhật STATE.md."
15    }
16  }
17}

Bây giờ bên trong Slate:

1/triage
2/review src/api/payments.ts
3/migrate

Mỗi lệnh chạy ngay lập tức prompt vòng lặp đã viết sẵn của bạn.

3 vòng lặp hoàn chỉnh bạn có thể chạy ngay hôm nay

Vòng lặp 1: Phân loại lỗi CI (cái chúng ta đã xây dựng)

Khi nào: mỗi lỗi CI Cái gì: phân loại → sửa lỗi dễ → chuyển lỗi khó → mở PR Trạng thái: STATE.md Cổng: kiểm thử vượt qua Thời gian thiết lập: 30 phút

1# kích hoạt
2slate run "$(cat loop.md)" --dangerously-skip-permissions --output-format stream-json
3
4# hoặc trong GitHub Actions — xem Bước 6 ở trên

Vòng lặp 2: Báo cáo buổi sáng

Khi nào: 7 giờ sáng mỗi ngày trong tuần (cron job) Cái gì: quét 24h qua của commits, PRs và các issue đang mở → viết báo cáo 5 điểm → đăng lên Slack

1# loop.md cho báo cáo buổi sáng
2cat > morning-brief-loop.md << 'EOF'
3Đọc 24 giờ qua của:
4- git log --since="24 hours ago" --oneline
5- Các PR đang mở ở trạng thái draft hoặc review
6- GitHub Issues được mở hoặc cập nhật trong 24 giờ qua
7
8Viết một báo cáo buổi sáng:
9- 3 điều quan trọng nhất đã xảy ra
10- 2 điều cần sự chú ý hôm nay
11- 1 điều có nguy cơ chặn ai đó
12
13Giữ dưới 120 từ. Đăng lên kênh Slack #engineering.
14EOF
15
16# chạy theo lịch trình với cron
170 7 * * 1-5 slate run "$(cat morning-brief-loop.md)" --dangerously-skip-permissions

Vòng lặp 3: Vòng lặp cập nhật phụ thuộc

Khi nào: mỗi thứ Hai Cái gì: quét các gói đã lỗi thời → kiểm tra tương thích → mở PR cho các bản cập nhật an toàn

1cat > deps-loop.md << 'EOF'
2Đọc STATE.md.
3
4Chạy: npm outdated
5
6Đối với mỗi gói đã lỗi thời:
71. Kiểm tra xem thay đổi phiên bản là major (phá vỡ) hay minor/patch (an toàn)
82. Đối với minor/patch: cập nhật gói, chạy npm test
93. Nếu kiểm thử vượt qua: mở PR
104. Nếu kiểm thử thất bại: ghi lại trong STATE.md là "cần xem xét của con người"
115. Đối với các bản bump major: luôn chuyển cho con người
12
13Quy tắc cứng:
14- Không bao giờ bump quá 5 gói trong một vòng lặp duy nhất
15- Không bao giờ bump các gói trong phần "peer dependencies"
16- Luôn chạy toàn bộ bộ kiểm thử sau mỗi lần bump, không chỉ các kiểm thử liên quan
17
18Cập nhật STATE.md với những gì đã được bump và những gì đã được chuyển.
19EOF
20
21# chạy mỗi thứ Hai
220 9 * * 1 slate run "$(cat deps-loop.md)" --dangerously-skip-permissions

Các chế độ thất bại gây tốn kém

Biết những điều này trước khi bạn lên lịch bất cứ thứ gì.

Vòng lặp Ralph Wiggum

Agent tuyên bố hoàn thành trên một công việc mới làm được một nửa.

Thoát sớm. Vòng lặp tiếp tục tiêu tốn. Một cách âm thầm.

Sửa: điều kiện dừng cứng được kiểm tra bởi một mô hình mới.

1ĐIỀU KIỆN DỪNG: Tất cả các kiểm thử trong tests/auth/ đều vượt qua VÀ lint trả về 0.
2Xác minh bằng cách sử dụng một lần chạy kiểm tra riêng biệt, không phải phán đoán của chính agent.
3Giới hạn cứng: 8 lần lặp. Khi đạt giới hạn: báo cáo trạng thái và dừng lại.

Trôi mục tiêu

Trong các phiên dài, các ràng buộc ban đầu biến mất.

"Không bao giờ chạm vào src/billing/" từ tin nhắn 3 đã biến mất vào tin nhắn 47.

Sửa: thêm một VISION.md mà Slate đọc lại khi bắt đầu mỗi phiên.

1# VISION.md — Đọc khi bắt đầu mỗi phiên
2
3## Mục tiêu cốt lõi
4Di chuyển tất cả các route Express sang mẫu ApiError.
5
6## Các ràng buộc cứng (không bao giờ vi phạm)
7- Không bao giờ chạm vào src/billing/ nếu không có sự chấp thuận của con người
8- Không bao giờ tắt các kiểm thử đang thất bại
9- Luôn chạy toàn bộ bộ kiểm thử trước khi mở bất kỳ PR nào
10
11## Ưu tiên hiện tại
12Các route trong src/api/payments/ — xử lý cẩn thận hơn

Thiên vị tự tham khảo

Người tạo chấm điểm bài tập của chính nó. Luôn cho mình đậu.

Sửa: subagent xác minh không có quyền truy cập vào lý luận của người tạo.

Yêu cầu Slate một cách rõ ràng:

1Agent xác minh KHÔNG được thấy công việc của agent triển khai.
2Nó chỉ được thấy: các yêu cầu kiểm thử ban đầu và output kiểm thử.
3Nếu kiểm thử vượt qua → chấp thuận. Nếu kiểm thử thất bại → từ chối. Không có ý kiến nào khác.

Sự lười biếng của agent

Vòng lặp gọi một tác vụ là "đủ tốt" khi hoàn thành một phần.

Đặc biệt là khi tiêu chí thành công mơ hồ.

Sửa: chỉ có điều kiện dừng khách quan.

1HOÀN THÀNH KHI: npm test trả về mã thoát 0 VÀ npm run lint trả về mã thoát 0.
2Không phải khi "kiểm thử trông ổn." Không phải khi "hầu hết kiểm thử vượt qua."
3Mã thoát 0 trên cả hai lệnh. Đó là điều kiện hoàn thành duy nhất.

Các thủ thuật cụ thể của Slate có giá trị

Một vài điều làm cho Slate khác biệt so với các agent khác trong thực tế.

Xếp hàng đợi tin nhắn trong khi nó đang làm việc

Slate đang chạy một tác vụ dài. Bạn nghĩ ra một điều quan trọng.

Nhấn Tab để xếp hàng đợi tin nhắn — nó chạy sau khi tác vụ hiện tại hoàn thành, không làm gián đoạn nó.

1[Slate đang làm việc trên tác vụ di chuyển...]
2
3Bạn: Thực ra, hãy đảm bảo mẫu mới cũng xử lý trường hợp userId là null
4[Tab — đã xếp hàng đợi]
5
6[Slate hoàn thành bước hiện tại, sau đó đọc tin nhắn đã xếp hàng đợi của bạn]

Điều hướng giữa lúc chạy

Nếu Slate đang đi sai hướng, bạn không cần phải dừng nó:

1[Slate đang đi được nửa đường triển khai bản sửa...]
2
3Bạn: Chờ đã — đừng thêm một lớp mới cho việc này. Sử dụng BaseError hiện có trong src/utils/errors.ts
4[Enter — điều hướng ngay lập tức]
5
6Slate: Đã hiểu, chuyển hướng tiếp cận để sử dụng BaseError...

Sử dụng /enter-mode-next để chuyển đổi giữa các chế độ steer / queue / interrupt.Các lệnh Shell trực tiếp

Chạy các lệnh bên trong phiên Slate mà không cần chuyển sang terminal khác:

1!npm test          # chạy kiểm thử và gửi output cho Slate
2!git diff HEAD     # kiểm tra những gì đã thay đổi
3!git status        # xem trạng thái hiện tại

Slate đọc output và sử dụng nó trong hành động tiếp theo của nó.

Chế độ máy chủ cho thiết lập nhóm

Chạy Slate như một máy chủ và kết nối với nó từ nhiều terminal:

1# Terminal 1 — khởi động máy chủ
2slate serve --port 7777
3
4# Terminal 2 — kết nối TUI
5slate attach http://localhost:7777 --dir /path/to/project

Hữu ích cho việc lập trình cặp với Slate hoặc chạy nó trên một máy từ xa.

Danh sách kiểm tra thiết lập đầy đủ

Trước khi chạy vòng lặp thực tế đầu tiên của bạn:

1□ npm i -g @randomlabs/slate đã được cài đặt
2□ AGENTS.md đã được tạo với tổng quan dự án, lệnh, quy tắc
3□ slate.json đã được tạo với quyền và cấu hình mô hình
4□ Một lần chạy thủ công đã hoàn thành và được xác minh đáng tin cậy
5□ SKILL.md đã được viết cho tác vụ lặp lại đầu tiên của bạn
6□ STATE.md đã được tạo và được tham chiếu trong AGENTS.md
7□ loop.md đã được viết với điều kiện dừng rõ ràng
8□ Giới hạn cứng về số lần lặp (tối đa 8 để bắt đầu)
9□ Người xác minh KHÔNG phải là cùng agent với người tạo
10□ Cổng xem xét của con người cho bất kỳ hành động không thể đảo ngược nào (PRs, triển khai)

Kiểm tra mọi ô trước khi lên lịch bất cứ thứ gì.

Bỏ qua một ô và vòng lặp sẽ thất bại một cách âm thầm hoặc tính phí bạn mà không tạo ra gì.

Để có thêm cảm hứng về vòng lặp

Khi bạn đã hiểu được mô hình, nút thắt chuyển từ "làm thế nào để xây một vòng lặp" sang "vòng lặp nào tôi nên xây tiếp theo".

Thư viện Vòng Lặp Forward Future tại signals.forwardfuture.com/loop-library là nơi tốt để duyệt các vòng lặp đang chạy thực tế trên nhiều lĩnh vực — nội dung, kỹ thuật, vận hành, nghiên cứu.

Khi bạn thấy 20 vòng lặp đang hoạt động ở một nơi, bạn sẽ ngừng suy nghĩ theo kiểu prompt rời rạc.

Sự thật khó chịu

Hai người xây dựng có thể chạy cùng một vòng lặp và nhận được kết quả trái ngược.

Một người dùng nó để làm việc nhanh hơn trên những công việc họ đã hiểu sâu.

Người kia dùng nó để tránh hiểu công việc đó hoàn toàn.

Vòng lặp không biết sự khác biệt.

Bạn thì biết.

Thiết kế vòng lặp khó hơn kỹ thuật prompt — không dễ hơn.

Vấn đề không phải là công việc trở nên dễ dàng hơn.

Điểm đòn bẩy đã di chuyển.

Hãy xây vòng lặp.

Nhưng hãy xây nó như một người có ý định tiếp tục làm kỹ sư.

Không chỉ là người nhấn nút chạy.

Và GPT-5.6 mới không thay thế nguyên tắc này. Nếu có gì, nó còn củng cố nó.

Biên giới không còn là ai viết prompt thông minh nhất.

Mà là ai thiết kế hệ thống tốt nhất xung quanh các mô hình ngày càng mạnh mẽ.

Tóm tắt 60 giây

Vòng lặp là gì:

→ Prompt = câu hỏi. Loop = công việc.

→ Khám phá → Thực thi → Xác minh → Lặp lại → Dừng

Bài kiểm tra 4 điều kiện:

→ Công việc lặp lại / Xác minh tự động / Ngân sách hấp thụ lãng phí / Hoàn thành là khách quan

5 bước thiết lập:

→ AGENTS.md → slate.json → một lần chạy thủ công → SKILL.md → STATE.md

Sau đó, đóng gói:

→ file queue loop.md HOẶC chạy headless slate trong CI

Các chế độ thất bại:

→ Ralph Wiggum (thoát sớm) / Trôi mục tiêu (quên ràng buộc) / Thiên vị tự thân (người tạo = người kiểm tra) / Lười tác nhân (làm đủ rồi)

Lợi thế của Slate:

→ Tự động chọn mô hình theo bước → Các tác nhân phụ song song có cô lập → Quản lý phiên dài → Vòng lặp của bạn, thiết kế của bạn

Nếu bài viết này hữu ích:

→ Đăng lại để chia sẻ với mọi người xây dựng bạn biết

→ Theo dõi @sairahul1 để biết thêm các hệ thống như thế này

→ Đánh dấu trang này — riêng checklist thiết lập đã đáng để lưu

Đăng ký theaibuilders.co để nhận thêm nhiều bài viết thú vị như thế này

Tôi viết về AI, xây dựng sản phẩm và các hệ thống chạy trong khi bạn ngủ.

Công cụ được đề cập:

→ Tài liệu Slate: docs.randomlabs.ai

→ Thư viện Vòng Lặp Forward Future: signals.forwardfuture.com/loop-library