วิธีสร้าง AI Loop แรกของคุณในปี 2026

วิศวกร AI ที่มีอาวุโสที่สุดสองคนในโลกพูดสิ่งเดียวกันเมื่อเดือนที่แล้ว

Peter Steinberger ผู้สร้าง OpenClaw ปัจจุบันอยู่ที่ OpenAI:

"คุณไม่ควรสั่งงาน coding agents อีกต่อไปแล้ว คุณควรออกแบบลูปที่คอยสั่งงาน agents ของคุณ"

Boris Cherny หัวหน้าทีม Claude Code ที่ Anthropic:

"ฉันไม่ได้สั่งงาน Claude อีกแล้ว ฉันมีลูปที่คอยสั่ง Claude และคิดว่าต้องทำอะไรต่อ หน้าที่ของฉันคือเขียนลูป"

คนส่วนใหญ่อ่านแล้วคิดว่า: มันหมายความว่ายังไงกันแน่?

และที่สำคัญกว่า: ฉันจะสร้างมันขึ้นมาได้ยังไง?

บทความนี้จะบอกคุณอย่างชัดเจน

ไม่มีทฤษฎีที่ไม่มีโค้ด ไม่มีโค้ดที่ไม่มีบริบท ขั้นตอนจริง คำสั่งจริง คัดลอกแล้วรันเลย

Slate กำลัง orchestrating GPT-5.6, Claude และ subagents เฉพาะทางในงาน migration จริง โมเดลฉลาดขึ้น การเปลี่ยนแปลงที่ใหญ่กว่าคือเครื่องมืออย่าง Slate สามารถทำให้โมเดลเหล่านั้นทำงานต่อเนื่องได้แทนที่จะรอคำสั่งจากมนุษย์

วิธีที่คนส่วนใหญ่ใช้ AI นั้นล้าสมัยแล้ว

เขียนพรอมต์ รอ อ่านผลลัพธ์ แก้ไขด้วยตัวเอง เขียนพรอมต์อีกครั้ง

คุณคือลูป

ทุกขั้นตอนต้องผ่านคุณ AI รอ คุณตัดสินใจ AI รออีกครั้ง

ทันทีที่คุณหยุด ทุกอย่างก็หยุด

ผู้ที่สร้างเร็วที่สุดในปี 2026 ไม่ได้เขียนพรอมต์ที่ดีกว่า

พวกเขากำลังสร้างระบบที่ทำหน้าที่เขียนพรอมต์ให้พวกเขา

จุดที่ได้เปรียบได้เปลี่ยนไปแล้ว

จากการพิมพ์พรอมต์ → สู่การออกแบบลูป

อะไรที่เปลี่ยนไปกับ GPT-5.6?

GPT-5.6 ไม่ได้เปลี่ยนความจำเป็นในการใช้ลูป

มันเพิ่มมูลค่าของลูปขึ้น

ยิ่งโมเดลดีเท่าไหร่ การปล่อยให้มันว่างงานระหว่างพรอมต์ก็ยิ่งแพงขึ้นเท่านั้น

ในเวิร์กโฟลว์บนเทอร์มินัล GPT-5.6 ทำได้ดีขึ้นอย่างเห็นได้ชัดใน:

→ การทำความเข้าใจโค้ดเบสขนาดใหญ่

→ การรักษาความสม่ำเสมอในการนำไปใช้งาน

→ การทำตามแผนหลายขั้นตอน

→ การกู้คืนจากความพยายามที่ล้มเหลว

→ การทำหน้าที่เป็นตัวตรวจสอบที่เข้มงวด

ผลลัพธ์ไม่ใช่ "พรอมต์ที่ดีกว่า"

แต่คือการแทรกแซงของมนุษย์น้อยลงต่องาน

ลูปที่ว่านั้นคืออะไร

คำจำกัดความง่ายๆ:

พรอมต์ตอบครั้งเดียวแล้วหยุด

ลูปทำงานต่อไปจนกว่างานจะเสร็จจริง

ไม่ใช่จนกว่าจะสร้างคำตอบ

จนกว่าจะถึงผลลัพธ์ที่ได้รับการตรวจสอบแล้ว

AI agent ที่จริงจังทุกตัวทำงานด้วยวงจรพื้นฐานเดียวกัน:

→ ค้นหา — ต้องทำอะไรบ้าง?

→ ดำเนินการ — ลงมือทำงาน

→ ตรวจสอบ — มันใช้งานได้จริงหรือ?

→ ทำซ้ำ — ยังไม่เสร็จ? แก้ไขแล้วทำซ้ำ

→ หยุด — ตรงตามเงื่อนไข หรือถึงขีดจำกัดสูงสุด

Claude Code, Cursor, Codex

เบื้องหลัง ทั้งหมดทำงานด้วยลูปนี้

ความแตกต่างระหว่างพรอมต์กับลูปไม่ใช่ตัวโมเดล

แต่คือมีอะไรบางอย่างตรวจสอบงานและทำงานต่อไปจนกว่าจะผ่าน

การทดสอบ 4 เงื่อนไข — ทำสิ่งนี้ก่อนสร้างอะไรก็ตาม

ลูปส่วนใหญ่ล้มเหลวตรงนี้

ลูปจะคุ้มค่ากับต้นทุนการตั้งค่าก็ต่อเมื่อทั้ง 4 เงื่อนไขเป็นจริง

พลาดเงื่อนไขเดียว ลูปจะใช้ต้นทุนมากกว่าที่มันให้ผลตอบแทน

1. งานเกิดขึ้นซ้ำ อย่างน้อยทุกสัปดาห์ งานที่ทำครั้งเดียวยังคงเหมาะกับพรอมต์ที่ดีสักอันเดียว

2. การตรวจสอบเป็นแบบอัตโนมัติ ต้องมีอะไรบางอย่างที่ทำให้งานล้มเหลวโดยที่คุณไม่อยู่ในห้อง Tests, Linters, Builds, Type checks ไม่มี gate = agent กำลังตรวจการบ้านตัวเอง

3. งบประมาณ token ของคุณสามารถรองรับการสิ้นเปลืองได้ ลูปอ่านบริบททั้งหมดอีกครั้งในทุก iteration มันลองใหม่ สำรวจ เผา token ไม่ว่ารันนั้นจะส่งอะไรออกไปหรือไม่ นี่คือต้นทุนที่ไม่มีใครพูดถึง

4. "เสร็จ" ต้องเป็นสิ่งที่วัดได้ Test ที่ผ่านหรือไม่ผ่าน Build ที่ compile ได้หรือไม่ได้ ไม่ใช่ "เมื่อมันดูดี" ถ้าเสร็จต้องใช้ความคิดเห็นของมนุษย์ ให้ทำด้วยตนเอง

ผ่านทั้ง 4 ข้อ → สร้างลูป

ไม่ผ่านข้อใดข้อหนึ่ง → ใช้พรอมต์แทน

ในความเป็นจริง: นักพัฒนาส่วนใหญ่ยังไม่จำเป็นต้องใช้ลูปหนักๆ สิ่งที่ทุกคนใช้ได้คือลูปง่ายๆ เราจะสร้างขึ้นมาเร็วๆ นี้

ติดตั้ง Slate

Slate คือ AI coding agent ที่สร้างมาเพื่อสิ่งนี้โดยเฉพาะ — การทำงานหลายขั้นตอนระยะยาวแบบขนานในเทอร์มินัลของคุณ

สร้างโดย RandomLabs agent ตัวแรกที่ถูกสร้างขึ้นสำหรับการ orchestration แบบ swarm

สิ่งที่ทำให้แตกต่างจาก Claude Code หรือ Cursor:

→ เลือกโมเดลที่เหมาะสมสำหรับแต่ละขั้นตอนโดยอัตโนมัติ วางแผนด้วย Claude ค้นหาด้วยอีกตัว ดำเนินการด้วย Codex — Slate เป็นคนตัดสินใจ

→ รัน subagents แบบขนานพร้อมกันทั่วโค้ดเบสของคุณ

→ จัดการบริบทของตัวเองในเซสชันยาวหลายชั่วโมง

→ ทำงานเคียงข้างคุณ — ไม่ใช่แค่เพื่อคุณ

ติดตั้งด้วยคำสั่งบรรทัดเดียว:

1npm i -g @randomlabs/slate

นำทางไปยังโปรเจกต์ของคุณและเริ่มใช้งาน:

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

นั่นจะเปิด Slate TUI — อินเทอร์เฟซเทอร์มินัลที่คุณมอบหมายงานและดูมันทำงาน

ขั้นตอนที่ 1 — ตั้งค่าเวิร์กสเปซของคุณ

ก่อนที่ Slate จะสามารถรันลูปในโปรเจกต์ของคุณได้ มันต้องเข้าใจโค้ดเบสของคุณก่อน

สร้างไฟล์ AGENTS.md ในรากของโปรเจกต์ นี่คือบริบทที่ Slate จะอ่านทุกครั้งที่เริ่มเซสชัน

1# AGENTS.md
2
3## โค้ดเบสนี้ทำอะไร
4[คำอธิบายโปรเจกต์หนึ่งย่อหน้า]
5
6## สถาปัตยกรรม
7- src/api/ — Express API routes
8- src/services/ — Business logic
9- src/db/ — Database models (PostgreSQL via Prisma)
10- tests/ — Jest test suite
11
12## คำสั่งสำคัญ
13- npm test — รันชุดทดสอบทั้งหมด
14- npm run build — TypeScript compile
15- npm run lint — ESLint check
16- npm run typecheck — tsc --noEmit
17
18## กฎ
19- ห้ามแก้ไข src/billing/ หรือ src/auth/ โดยไม่ได้รับอนุมัติจากมนุษย์
20- รัน tests ทุกครั้งก่อนที่จะทำเครื่องหมายว่างานเสร็จ
21- ใช้รูปแบบการจัดการข้อผิดพลาดที่มีอยู่ใน src/utils/errors.ts
22
23## สภาพแวดล้อม
24- .env.slate มีตัวแปรสภาพแวดล้อมทั้งหมดที่ Slate ต้องการ

Slate อ่านไฟล์นี้โดยอัตโนมัติเมื่อเริ่มต้น — ไม่ต้องวางทุกเซสชัน

เพิ่มไดเรกทอรีเวิร์กสเปซของคุณภายใน Slate:

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

หรืออ้างอิงไฟล์เฉพาะโดยใช้ @ mentions:

1กรุณาตรวจสอบ @src/api/routes.ts และแนะนำการปรับปรุง

ขั้นตอนที่ 2 — กำหนดค่า Slate

สร้าง slate.json ในรากของโปรเจกต์เพื่อควบคุมการทำงานของ Slate

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}

สิ่งที่มันทำ:

→ "*": "allow" — Slate สามารถอ่านและเขียนไฟล์ได้โดยไม่ต้องถามทุกครั้ง

→ "bash": "ask" — Slate จะถามก่อนรันคำสั่ง shell (เปิดไว้จนกว่าคุณจะเชื่อใจ)

→ การกำหนดค่า Models — โมเดลราคาถูกเร็วสำหรับค้นหา โมเดลราคาแพงสำหรับการใช้เหตุผลหลัก

สำหรับการรันใน CI หรือระบบอัตโนมัติที่ไม่ต้องการพรอมต์เลย:

1slate run "Run the test suite and fix any failures" --dangerously-skip-permissions --output-format stream-json

ขั้นตอนที่ 3 — งานแรกของคุณ (ยังไม่ใช่ลูป)

ก่อนที่จะสร้างลูป ให้ทำให้การรันด้วยตนเองครั้งเดียวเชื่อถือได้ก่อน

นี่คือขั้นตอนที่ข้ามมากที่สุด และเป็นสาเหตุที่ลูปส่วนใหญ่ล้มเหลวในการใช้งานจริง

มอบหมายงานจริงให้ Slate:

1กรุณาตรวจสอบสถาปัตยกรรมของโค้ดเบสทั้งหมดของฉัน
2สร้าง ARCH.md ด้วย:
3- โครงสร้างปัจจุบัน
4- การพึ่งพากันระหว่างโมดูล
5- 3 สิ่งที่ควรปรับปรุง
6ดู @src/ ก่อน แล้วค่อย @tests/

ดู Slate ทำงาน มันจะ:

1. ค้นหาไฟล์ของคุณ
2. สร้างความเข้าใจในสถาปัตยกรรม
3. ร่าง ARCH.md
4. ตรวจสอบกับคำขอของคุณก่อนที่จะหยุด

นี่คือมินิ-ลูปอยู่แล้ว — มันตรวจสอบผลลัพธ์ของตัวเองก่อนที่จะเสร็จ

สำหรับงานที่ยาวขึ้น:

1สวัสดี Slate, ค้นคว้าโค้ดเบสของฉันเกี่ยวกับ authentication flow
2แล้ววางแผนสำหรับการเพิ่ม OAuth2 support
3ตรวจสอบให้แน่ใจว่าคุณดูที่ @src/auth/ และ @src/api/routes.ts

Slate จะคืนแผน คุณปรับแก้มัน:

1ไม่ อย่าเพิ่มคลาส auth provider ใหม่
2ทำให้มันเป็นไปตามรูปแบบเดียวกับ ApiKeyAuth ที่มีอยู่ใน src/auth/api-key.ts

อนุมัติแผน Slate จะดำเนินการด้วยตนเอง

ขั้นตอนที่ 4 — สร้าง Skill (ทำให้ลูปใช้ซ้ำได้)

Skill คือวิธีที่คุณหยุดอธิบายโปรเจกต์ของคุณซ้ำแล้วซ้ำอีกทุกเซสชัน

เขียนครั้งเดียว Slate อ่านทุกครั้งที่รันที่เกี่ยวข้อง

สร้างโครงสร้างโฟลเดอร์:

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

เขียน skill:

1---
2name: "ci-triage"
3description: "จำแนกสาเหตุของ CI failures และร่างแก้ไขสำหรับกรณีง่ายๆ"
4---
5
6# CI Triage Skill
7
8## สิ่งที่ฉันทำ
9เมื่อ CI run ล้มเหลว ฉัน:
101. อ่าน test output
112. จำแนกประเภทความล้มเหลว: env issue / flaky test / real bug / dependency bump / infra
123. ร่างแก้ไขสำหรับ bugs และ dependency issues
134. ส่งต่อ env และ infra issues ไปให้มนุษย์
14
15## กฎการจำแนก
16- env: secret หาย, env var ผิด → ทำ flag ให้มนุษย์
17- flake: ผ่านเมื่อรันใหม่โดยไม่เปลี่ยนโค้ด → รันซ้ำหนึ่งครั้ง แล้วสร้าง issue
18- bug: ความล้มเหลวที่แน่นอนเกี่ยวข้องกับ commit ล่าสุด → ร่างแก้ไข
19- dependency: ความล้มเหลวเกี่ยวข้องกับการ bump version → ร่าง PR rollback
20- infra: timeout, OOM, runner issue → ส่งต่อทันที
21
22## รูปแบบการแก้ไข
23- Auth test failures → ตรวจสอบ src/auth/middleware.ts ก่อน
24- Database test failures → ยืนยัน migration รันใน CI env
25- E2E failures → ตรวจสอบ UI selectors เทียบกับ snapshot ล่าสุด
26
27## ห้ามทำเด็ดขาด
28- ปิดการทดสอบที่ล้มเหลว
29- แก้ไข CI config โดยไม่ถาม
30- แตะ src/billing/ หรือ src/payments/
31
32## สถานะ
33อัปเดต STATE.md ทุกครั้งหลังรัน:
34- ไฟล์ที่ตรวจสอบ
35- การจำแนกที่ทำ
36- PRs ที่เปิด
37- รายการที่ส่งต่อ

แสดงรายการ skills ที่มีภายใน Slate:

1/skills

เปิดใช้งานหนึ่งอย่างด้วยตนเอง:

1@ci-triage กรุณาจำแนกการทดสอบที่ล้มเหลวของวันนี้

หรือ Slate จะเปิดใช้งาน skills โดยอัตโนมัติเมื่อมันตัดสินใจว่าเกี่ยวข้องกับงานปัจจุบัน

ขั้นตอนที่ 5 — เพิ่ม state (ความจำของลูป)

agent ลืม

แต่ไฟล์ไม่ลืม

สร้าง STATE.md ในรากของโปรเจกต์:

1# สถานะลูป — CI Triage
2
3## การรันล่าสุด
42026-06-28 03:30 UTC — จำแนก 7 failures, ร่างแก้ไข 3 รายการ, ส่งต่อ 4 รายการ
5
6## กำลังดำเนินการ
7- claude/fix-auth-token-refresh — tests ผ่านในเครื่อง, รอ CI
8- claude/fix-flaky-payment-webhook — ใช้รูปแบบ retry แล้ว, กำลังตรวจสอบ
9
10## เสร็จสิ้น
11- claude/bump-axios-1.7.4 → merge แล้ว (CI เขียว)
12- claude/lint-fix-pass-june-28 → merge แล้ว
13
14## ส่งต่อให้มนุษย์
15- src/billing/refund.ts — tests ล้มเหลว 3 รูปแบบ, ไม่ทราบสาเหตุที่แน่ชัด
16- ci/staging-runner — infra timeouts, ไม่ใช่ปัญหาโค้ด
17
18## บทเรียนที่ได้
19- 2026-06-27: PowerShell มีปัญหา TLS 1.2 บน Windows runner นี้ ใช้ bash แทน
20- 2026-06-26: tests/e2e/checkout ต้องการ Stripe webhook secret ใน env ข้ามถ้าไม่มี

บอก Slate ให้ใช้มันตอนเริ่มทุกเซสชันโดยเพิ่มใน AGENTS.md:

1## การเริ่มเซสชัน
2อ่าน STATE.md ก่อนเสมอ เริ่มงานต่อจากที่การรันล่าสุดหยุดไว้
3อัปเดต STATE.md เมื่อสิ้นสุดทุกการรันด้วยสิ่งที่ทำและสิ่งที่จะทำต่อไป

ไม่มี state: ทุกการรันเริ่มต้นจากศูนย์

มี state: ทุกการรันดำเนินต่อและสะสมจากครั้งก่อน

ขั้นตอนที่ 6 — สร้างลูปจริง

ตอนนี้คุณมี:

→ เวิร์กสเปซที่ตั้งไว้ (AGENTS.md)

→ การกำหนดค่า (slate.json)

→ การรันด้วยตนเองที่เชื่อถือได้หนึ่งครั้ง

→ skill ที่เขียนแล้ว (ci-triage)

→ ไฟล์ state ที่สร้างแล้ว (STATE.md)

ถึงเวลาห่อหุ้มมันเป็นลูปจริง

ตัวเลือก A: Queue file loop (ง่ายที่สุด)

สร้าง loop.md:

1อ่าน STATE.md เพื่อทำความเข้าใจสิ่งที่ลองไปแล้ว
2
3รัน CI triage skill กับการทดสอบที่ล้มเหลวทั้งหมดใน build ล่าสุด
4
5สำหรับแต่ละ failure:
6- จำแนกมันโดยใช้กฎ ci-triage skill
7- ร่างแก้ไขสำหรับ bugs และ dependency issues
8- ส่งต่อ env และ infra issues
9
10รันการแก้ไข ตรวจสอบว่า tests ผ่านหรือไม่
11ถ้า tests ผ่าน → เปิด PR
12ถ้า tests ยังคงล้มเหลว → บันทึกใน STATE.md และหยุด
13
14อัปเดต STATE.md ด้วยทุกสิ่งที่ทำในการรันนี้
15
16หยุดโดยเด็ดขาด: สูงสุด 8 ครั้ง เมื่อถึงขีดจำกัด ให้รายงานสถานะปัจจุบัน

รันมัน:

1slate --queue loop.md

Slate อ่านไฟล์คิวและรันแต่ละบล็อกเป็นข้อความที่เข้าคิว

ตัวเลือก B: หัวขาด/CI loop (อัตโนมัติ)

รันแบบไม่โต้ตอบใน GitHub Action หรือ cron job:

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

ใน GitHub Actions workflow:

1name: CI Triage Loop
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: ติดตั้ง Slate
15        run: npm i -g @randomlabs/slate
16
17      - name: รัน triage loop
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

ตอนนี้ทุก CI failure จะเรียก triage loop โดยอัตโนมัติ

ไม่ต้องใช้มนุษย์จนกว่าจะถึงขั้นส่งต่อ

ขั้นตอนที่ 7 — เพิ่ม sub-agents (การแยก maker-checker)

การปรับปรุงโครงสร้างที่สำคัญที่สุดสำหรับลูปใดๆ

อย่าปล่อยให้ agent คนเดียวกันตรวจการบ้านตัวเอง

โมเดลที่เขียนแก้ไขนั้นเป็นผู้ตรวจที่ใจดีเกินไป

ใน Slate คุณสามารถกำหนดโมเดลที่แตกต่างกันสำหรับบทบาทที่แตกต่างกัน:

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}

จากนั้นเขียนงานของคุณเพื่อให้ Slate ใช้การแยกนี้โดยธรรมชาติ:

1กรุณาแก้ไข auth tests ที่ล้มเหลว
2
3ขั้นตอนที่ 1: ให้ search agent สำรวจ src/auth/ เพื่อทำความเข้าใจการใช้งานปัจจุบัน
4ขั้นตอนที่ 2: ให้ agent อีกตัวนำการแก้ไขไปใช้ตามสิ่งที่พบ
5ขั้นตอนที่ 3: ให้ agent ที่สามตรวจสอบการแก้ไขเทียบกับข้อกำหนด test เดิม —
6        agent นี้ไม่ควรเห็นการนำไปใช้
7ขั้นตอนที่ 4: เปิด PR ก็ต่อเมื่อ verifier อนุมัติ

Slate orchestrates subagents โดยอัตโนมัติ

search agent ใช้โมเดลที่เร็วราคาถูก implementation agent ใช้โมเดลที่แข็งแกร่งกว่า verifier ใช้โมเดลที่เข้มงวดซึ่งไม่สามารถเข้าถึงเหตุผลของ maker

การแยกนี้คือสาเหตุที่ Slate สามารถรัน subagents 5 ตัวแบบขนานในงานเดียว — แต่ละตัวเชี่ยวชาญ แต่ละตัวแยกออกจากกัน

ขั้นตอนที่ 8 — รูปแบบ state loop (สำหรับงานระยะยาว)

สำหรับงานที่รันเป็นชั่วโมงหรือวัน ให้ใช้รูปแบบนี้ใน task prompt ของคุณ:

1คุณกำลังรันลูปหลายเซสชัน
2
3เป้าหมาย: ย้าย Express routes ทั้งหมดไปใช้รูปแบบ ApiError ใหม่
4ติดตามความคืบหน้าใน STATE.md
5
6ทุกครั้งเริ่มเซสชัน:
71. อ่าน STATE.md
82. หารายการแรกที่ยังไม่เสร็จใน "Route ที่เหลือ"
93. ทำรายการนั้นเท่านั้น
10
11ทุกครั้งสิ้นสุดเซสชัน:
121. ย้ายรายการที่เสร็จแล้วไป "Route ที่ทำเสร็จ" ใน STATE.md
132. บันทึกอุปสรรคใดๆ ใน "อุปสรรค"
143. อัปเดตการประทับเวลา "การรันล่าสุด"
154. หยุดอย่างเรียบร้อย
16
17รูปแบบ STATE.md:
18---
19## Route ที่ทำเสร็จ
20- [x] /api/users (2026-06-27)
21- [x] /api/auth/login (2026-06-28)
22
23## Route ที่เหลือ
24- [ ] /api/payments/checkout
25- [ ] /api/payments/refund
26- [ ] /api/admin/users
27
28## อุปสรรค
29- /api/payments/refund — ต้องได้รับการตรวจสอบจากมนุษย์ (เกี่ยวข้องกับ billing logic)
30
31## การรันล่าสุด
322026-06-28 14:30 UTC
33---
34
35กฎเด็ดขาด:
36- ห้ามแตะ src/billing/ โดยไม่ได้รับการอนุมัติจากมนุษย์
37- รัน tests ทุกครั้งหลัง migration แต่ละ route
38- หยุดหลังจากทำ ONE route ต่อเซสชัน

รันทุกเช้า:

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

--continue จะดึงเซสชันล่าสุดมาแทนที่จะเริ่มใหม่

แต่ละวัน อีกหนึ่ง route STATE.md ติดตามทุกอย่าง

ลูปดำเนินต่อตรงจุดที่หยุดไว้

ขั้นตอนที่ 9 — คำสั่งแบบกำหนดเองสำหรับลูปที่ใช้บ่อย

เพิ่มคำสั่ง slash แบบกำหนดเองใน slate.json เพื่อให้ลูปของคุณอยู่ใกล้แค่แป้นพิมพ์เดียว:

1{
2  "command": {
3    "triage": {
4      "description": "รัน CI triage loop",
5      "template": "อ่าน STATE.md รัน ci-triage skill กับการทดสอบที่ล้มเหลวทั้งหมด อัปเดต STATE.md เมื่อเสร็จ",
6      "agent": "build"
7    },
8    "review": {
9      "description": "ตรวจสอบไฟล์ว่าถูกต้อง",
10      "template": "ตรวจสอบ @$ARGUMENTS ในเรื่องความถูกต้อง กรณีขอบ และความสอดคล้องกับโค้ดรอบข้าง"
11    },
12    "migrate": {
13      "description": "ย้ายหนึ่ง route ไปใช้รูปแบบ ApiError",
14      "template": "อ่าน STATE.md ย้าย route ถัดไปที่ยังไม่เสร็จไปใช้รูปแบบ ApiError รัน tests อัปเดต STATE.md"
15    }
16  }
17}

ตอนนี้ภายใน Slate:

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

แต่ละคำสั่งรันลูปพรอมต์ที่เขียนไว้ล่วงหน้าของคุณทันที

3 ลูปสมบูรณ์ที่คุณสามารถรันได้วันนี้

ลูป 1: CI failure triage (ลูปที่เราสร้าง)

เมื่อ: ทุก CI failure อะไร: จำแนก → แก้ง่าย → ส่งต่อยาก → เปิด PRs สถานะ: STATE.md เกต: tests ผ่าน เวลาตั้งค่า: 30 นาที

1# trigger
2slate run "$(cat loop.md)" --dangerously-skip-permissions --output-format stream-json
3
4# หรือใน GitHub Actions — ดูขั้นตอนที่ 6 ด้านบน

ลูป 2: Morning brief

เมื่อ: 7 ทุกวันจันทร์-ศุกร์ (cron job) อะไร: สแกน 24 ชม.ล่าสุดของ commits, PRs และ open issues → เขียนสรุป 5 ข้อ → โพสต์ไปยัง Slack

1# loop.md สำหรับ morning brief
2cat > morning-brief-loop.md << 'EOF'
3อ่านข้อมูล 24 ชั่วโมงที่ผ่านมา:
4- git log --since="24 hours ago" --oneline
5- PRs ที่เปิดอยู่ใน draft หรือ review
6- GitHub Issues ที่เปิดหรืออัปเดตใน 24 ชม.ที่ผ่านมา
7
8เขียน morning brief:
9- 3 สิ่งสำคัญที่สุดที่เกิดขึ้น
10- 2 สิ่งที่ต้องการความสนใจในวันนี้
11- 1 สิ่งที่เสี่ยงต่อการบล็อกใครบางคน
12
13ให้สั้นกว่า 120 คำ โพสต์ไปยัง #engineering Slack channel
14EOF
15
16# รันตามตารางด้วย cron
170 7 * * 1-5 slate run "$(cat morning-brief-loop.md)" --dangerously-skip-permissions

ลูป 3: Dependency bump loop

เมื่อ: ทุกวันจันทร์ อะไร: สแกนหาแพ็คเกจที่ล้าสมัย → ทดสอบความเข้ากันได้ → เปิด PRs สำหรับการ bump ที่ปลอดภัย

1cat > deps-loop.md << 'EOF'
2อ่าน STATE.md
3
4รัน: npm outdated
5
6สำหรับแต่ละแพ็คเกจที่ล้าสมัย:
71. ตรวจสอบว่า version bump เป็น major (เปลี่ยนแปลงครั้งใหญ่) หรือ minor/patch (ปลอดภัย)
82. สำหรับ minor/patch: อัปเดตแพ็คเกจ, รัน npm test
93. ถ้า tests ผ่าน: เปิด PR
104. ถ้า tests ล้มเหลว: บันทึกใน STATE.md ว่า "ต้องการการตรวจสอบจากมนุษย์"
115. สำหรับ major bumps: ส่งต่อไปยังมนุษย์เสมอ
12
13กฎเด็ดขาด:
14- ห้าม bump มากกว่า 5 แพ็คเกจในลูปเดียว
15- ห้าม bump แพ็คเกจในส่วน "peer dependencies"
16- รันชุดทดสอบทั้งหมดเสมอหลังแต่ละ bump ไม่ใช่แค่ tests ที่เกี่ยวข้อง
17
18อัปเดต STATE.md ด้วยสิ่งที่ถูก bump และสิ่งที่ถูกส่งต่อ
19EOF
20
21# รันทุกวันจันทร์
220 9 * * 1 slate run "$(cat deps-loop.md)" --dangerously-skip-permissions

โหมดความล้มเหลวที่เสียเงิน

รู้จักสิ่งเหล่านี้ก่อนที่คุณจะกำหนดเวลาอะไรก็ตาม

The Ralph Wiggum Loop

agent ประกาศว่าเสร็จในงานที่ทำไปครึ่งเดียว

ออกก่อนเวลาอันควร ลูปยังคงใช้ทรัพยากรต่อไป อย่างเงียบๆ

การแก้ไข: เงื่อนไขการหยุดที่เข้มงวดซึ่งตรวจสอบโดยโมเดลใหม่

1เงื่อนไขหยุด: tests ทั้งหมดใน tests/auth/ ผ่าน และ lint คืนค่า 0
2ตรวจสอบโดยใช้การรันตรวจสอบแยกต่างหาก ไม่ใช่การตัดสินของ agent เอง
3ขีดจำกัด: 8 ครั้ง เมื่อถึงขีดจำกัด: รายงานสถานะและหยุด

Goal drift

ในเซสชันยาว ข้อจำกัดในช่วงแรกจะหายไป

"ห้ามแตะ src/billing/" จากข้อความที่ 3 หายไปเมื่อถึงข้อความที่ 47

การแก้ไข: เพิ่ม VISION.md ที่ Slate อ่านซ้ำตอนเริ่มทุกเซสชัน

1# VISION.md — อ่านตอนเริ่มทุกเซสชัน
2
3## เป้าหมายหลัก
4ย้าย Express routes ทั้งหมดไปใช้รูปแบบ ApiError
5
6## ข้อจำกัดที่ห้ามละเมิดเด็ดขาด
7- ห้ามแตะ src/billing/ โดยไม่ได้รับการอนุมัติจากมนุษย์
8- ห้ามปิดการทดสอบที่ล้มเหลว
9- รันชุดทดสอบทั้งหมดก่อนเปิด PR เสมอ
10
11## ลำดับความสำคัญปัจจุบัน
12Routes ใน src/api/payments/ — จัดการด้วยความระมัดระวังเป็นพิเศษ

Self-preferential bias

ผู้สร้างตรวจการบ้านตัวเอง มักจะให้ผ่านเสมอ

การแก้ไข: verifier subagent ที่ไม่สามารถเข้าถึงเหตุผลของผู้สร้าง

บอก Slate อย่างชัดเจน:

1verifier agent ไม่ควรเห็นงานของ implementation agent
2มันควรเห็นเพียง: ข้อกำหนด test เดิมและ test output
3ถ้า tests ผ่าน → อนุมัติ ถ้า tests ล้มเหลว → ปฏิเสธ ไม่มีความคิดเห็นอื่น

Agentic laziness

ลูปเรียกงานว่า "เสร็จพอ" เมื่อทำเสร็จบางส่วน

โดยเฉพาะเมื่อเกณฑ์ความสำเร็จไม่ชัดเจน

การแก้ไข: เงื่อนไขการหยุดที่เป็นรูปธรรมเท่านั้น

1เสร็จเมื่อ: npm test คืนค่า exit code 0 และ npm run lint คืนค่า exit code 0
2ไม่ใช่เมื่อ "tests ดูดี" ไม่ใช่เมื่อ "tests ส่วนใหญ่ผ่าน"
3Exit code 0 สำหรับทั้งสองคำสั่ง นั่นคือการเสร็จที่แท้จริงเท่านั้น

เคล็ดลับเฉพาะของ Slate ที่สำคัญ

สองสามสิ่งที่ทำให้ Slate แตกต่างจาก agents อื่นในทางปฏิบัติ

การจัดคิวข้อความในขณะที่มันทำงาน

Slate กำลังรันงานระยะยาว คุณนึกถึงบางสิ่งที่สำคัญ

กด Tab เพื่อจัดคิวข้อความ — มันจะรันหลังจากงานปัจจุบันเสร็จ โดยไม่ขัดจังหวะ

1[Slate กำลังทำงาน migration task...]
2
3คุณ: จริงๆ แล้ว ตรวจสอบให้แน่ใจว่ารูปแบบใหม่จัดการกรณีที่ userId เป็น null ด้วย
4[Tab — เข้าคิว]
5
6[Slate เสร็จขั้นตอนปัจจุบัน แล้วอ่านข้อความที่คุณจัดคิวไว้]

การควบคุมระหว่างรัน

ถ้า Slate กำลังไปในทิศทางที่ผิด คุณไม่จำเป็นต้องหยุดมัน:

1[Slate กำลังดำเนินการแก้ไขครึ่งทาง...]
2
3คุณ: เดี๋ยวก่อน — อย่าเพิ่มคลาสใหม่สำหรับเรื่องนี้ ใช้ BaseError ที่มีอยู่ใน src/utils/errors.ts
4[Enter — ควบคุมทันที]
5
6Slate: เข้าใจแล้ว เปลี่ยนแนวทางไปใช้ BaseError...

ใช้ /enter-mode-next เพื่อสลับระหว่างโหมด steer / queue / interrupt**คำสั่ง Shell โดยตรง

รันคำสั่งภายในเซสชัน Slate โดยไม่ต้องสลับไปยังเทอร์มินัลอื่น:

1!npm test          # รัน tests และส่ง output ไปยัง Slate
2!git diff HEAD     # ดูสิ่งที่เปลี่ยน
3!git status        # ดูสถานะปัจจุบัน

Slate อ่าน output และใช้มันในการดำเนินการต่อไป

โหมด Server สำหรับการตั้งค่าทีม

รัน Slate เป็นเซิร์ฟเวอร์และเชื่อมต่อจากหลายเทอร์มินัล:

1# Terminal 1 — เริ่มเซิร์ฟเวอร์
2slate serve --port 7777
3
4# Terminal 2 — เชื่อมต่อ TUI
5slate attach http://localhost:7777 --dir /path/to/project

มีประโยชน์สำหรับการ pair-programming กับ Slate หรือรันบนเครื่องระยะไกล

รายการตรวจสอบการตั้งค่าทั้งหมด

ก่อนรันลูปจริงครั้งแรก:

1□ ติดตั้ง npm i -g @randomlabs/slate แล้ว
2□ สร้าง AGENTS.md พร้อมภาพรวมโปรเจกต์ คำสั่ง กฎ
3□ สร้าง slate.json พร้อมสิทธิ์และการกำหนดค่าโมเดล
4□ รันด้วยตนเองหนึ่งครั้งและยืนยันว่าเชื่อถือได้
5□ เขียน SKILL.md สำหรับงานที่ทำซ้ำเป็นงานแรก
6□ สร้าง STATE.md และอ้างอิงใน AGENTS.md
7□ เขียน loop.md พร้อมเงื่อนไขหยุดที่ชัดเจน
8□ ขีดจำกัด iteration (เริ่มต้นสูงสุด 8)
9□ Verifier ไม่ใช่ agent เดียวกับ maker
10□ เกตการตรวจสอบโดยมนุษย์สำหรับการกระทำที่ไม่สามารถย้อนกลับได้ (PRs, deploys)

ตรวจสอบทุกช่องก่อนกำหนดเวลาอะไรก็ตาม

ข้ามช่องเดียว ลูปจะล้มเหลวอย่างเงียบๆ หรือคิดเงินคุณโดยไม่ได้อะไร

สำหรับแรงบันดาลใจเกี่ยวกับลูปเพิ่มเติม

เมื่อคุณเข้าใจรูปแบบแล้ว อุปสรรคจะเปลี่ยนจาก "ฉันจะสร้าง loop ได้อย่างไร" ไปเป็น "loop ไหนที่ฉันควรสร้างต่อไป"

Forward Future Loop Library ที่ signals.forwardfuture.com/loop-library เป็นแหล่งที่ดีในการดู loop ที่ใช้งานได้จริงในหลากหลายหมวดหมู่ — เนื้อหา, วิศวกรรม, การดำเนินงาน, งานวิจัย

เมื่อคุณเห็น loop ที่ใช้งานได้ 20 ตัวในที่เดียว คุณจะเลิกคิดแบบ prompt แบบครั้งเดียวจบ

ความจริงที่ไม่สบายใจ

ผู้สร้างสองคนสามารถใช้ loop เดียวกันแล้วได้ผลลัพธ์ตรงกันข้าม

คนหนึ่งใช้มันเพื่อทำงานที่เข้าใจอย่างลึกซึ้งอยู่แล้วให้เร็วขึ้น

อีกคนใช้มันเพื่อหลีกเลี่ยงการทำความเข้าใจงานเลย

loop ไม่รู้ว่าความแตกต่างคืออะไร

แต่คุณรู้

การออกแบบ loop นั้นยากกว่าการเขียน prompt engineering — ไม่ใช่ง่ายกว่า

ประเด็นไม่ใช่ว่างานนั้นง่ายขึ้น

จุด leverage ได้ย้ายไปแล้ว

สร้าง loop ขึ้นมา

แต่สร้างมันเหมือนคนที่ตั้งใจจะเป็นวิศวกร

ไม่ใช่แค่คนที่กดปุ่มเริ่ม

และ GPT-5.6 ตัวใหม่ไม่ได้แทนที่หลักการนี้ ถ้าจะพูดให้ถูก มันยิ่งตอกย้ำหลักการนี้

แนวหน้าไม่ได้อยู่ที่ว่าใครเขียน prompt ได้ฉลาดที่สุดอีกต่อไป

แต่อยู่ที่ว่าใครออกแบบระบบที่ดีที่สุดรอบโมเดลที่มีความสามารถมากขึ้นเรื่อยๆ

สรุป 60 วินาที

loop คืออะไร:

→ Prompt = คำถาม Loop = งาน

→ ค้นพบ → ดำเนินการ → ตรวจสอบ → ทำซ้ำ → หยุด

เงื่อนไข 4 ข้อ:

→ งานเกิดขึ้นซ้ำ / การตรวจสอบเป็นอัตโนมัติ / งบประมาณรับมือกับของเสีย / เสร็จสิ้นเป็นเรื่องที่วัดผลได้

ขั้นตอนตั้งค่า 5 ขั้นตอน:

→ AGENTS.md → slate.json → 1 รอบที่ทำด้วยตัวเอง → SKILL.md → STATE.md

จากนั้นห่อมัน:

→ ไฟล์คิว loop.md หรือการรัน slate แบบ headless ใน CI

รูปแบบความล้มเหลว:

→ Ralph Wiggum (ออกก่อนกำหนด) / Goal drift (ลืมข้อจำกัด) / อคติชอบตนเอง (ผู้สร้าง = ผู้ตรวจสอบ) / ความขี้เกียจของ agent (พอแล้ว)

ข้อดีของ Slate:

→ การเลือกโมเดลอัตโนมัติในแต่ละขั้นตอน → Subagents แบบขนานที่มีการแยกส่วน → การจัดการ session ระยะยาว → loop ของคุณ การออกแบบของคุณ

ถ้าสิ่งนี้มีประโยชน์:

→ แชร์ต่อเพื่อส่งต่อให้ builder ทุกคนที่คุณรู้จัก

→ ติดตาม @sairahul1 สำหรับระบบแบบนี้เพิ่มเติม

→ บุ๊กมาร์กไว้ — รายการตรวจสอบการตั้งค่าอย่างเดียวก็คุ้มค่าที่จะเก็บไว้

สมัครสมาชิก theaibuilders.co เพื่อรับบทความที่น่าสนใจแบบนี้เพิ่มเติม

ผมเขียนเกี่ยวกับ AI การสร้างผลิตภัณฑ์ และระบบที่ทำงานในขณะที่คุณหลับ

เครื่องมือที่กล่าวถึง:

→ เอกสาร Slate: docs.randomlabs.ai

→ Forward Future Loop Library: signals.forwardfuture.com/loop-library