Loop Engineering: ให้ AI ทำงานวนเองด้วย /loop และ /goal ใน Claude Code

ทุกวันนี้หลายคนใช้ AI เขียนโค้ดแบบตีปิงปอง พิมพ์สั่งหนึ่งครั้ง รอ อ่านผล แล้วพิมพ์สั่งต่อ วนแบบนี้ทั้งวัน งานเดินได้ก็จริง แต่คนที่เหนื่อยที่สุดคือเรา เพราะต้องนั่งเฝ้าและป้อนคำสั่งให้ทุกจังหวะ

Loop Engineering คือการเปลี่ยนบทบาทจาก "คนพิมพ์ prompt ทีละครั้ง" มาเป็น "คนออกแบบระบบที่ป้อน prompt ให้เอง" เราบอกครั้งเดียวว่างานคืออะไร ทำซ้ำเมื่อไร และเสร็จแปลว่าอะไร จากนั้น AI ทำงานวนเป็นรอบจนถึงจุดที่ตั้งไว้ ส่วนเรากลับไปทำหน้าที่วิศวกร คือออกแบบและตรวจผล

บทความนี้จะลองทำลูปแรกด้วยคำสั่ง /loop และ /goal ใน Claude Code กับโปรเจกต์ฝึกที่มีบั๊กจริงหนึ่งตัว จบบทความนี้คุณจะ:

• อธิบายได้ว่าลูปหนึ่งรอบมีกี่จังหวะ และต่างจากการสั่ง AI แบบเดิมยังไง
• ติดตั้ง Claude Code และสร้างโปรเจกต์ฝึกที่มีเทสต์ไม่ผ่าน
• ใช้ /loop ให้ AI เช็กงานซ้ำตามเวลา และใช้ /goal ให้ AI ทำงานจนผ่านเงื่อนไข
• ออกแบบลูปของตัวเองได้ พร้อมตั้งจุดหยุดและคุมค่าใช้จ่าย

ก่อนเริ่ม ต้องมีบัญชีแบบเสียเงิน Claude Code ใช้กับบัญชี Claude แบบ Pro, Max, Team หรือ Enterprise หรือบัญชี Claude Console ได้ (ณ ตอนเขียน ต.ค. 2026) และลูปจะใช้โควตาไปเรื่อยๆ ตราบที่มันยังวิ่ง ทุกแบบฝึกหัดในบทความนี้จึงมีวิธีหยุดลูปบอกไว้เสมอ

จากคนพิมพ์ prompt เป็นคนออกแบบลูป

ลองนึกถึงการซักผ้าครับ ถ้าซักมือ เราต้องทำเองทุกขั้น แช่ ขยี้ ล้าง บิด และต้องคอยดูว่าสะอาดหรือยัง แต่ถ้าใช้เครื่องซักผ้า เราแค่เลือกโปรแกรมครั้งเดียว เครื่องจะวนแช่ ซัก ล้าง ปั่นเป็นรอบ และหยุดเองเมื่อจบโปรแกรม เราไม่ได้หายไปไหน หน้าที่ของเราเปลี่ยนจากคนขยี้ผ้าเป็นคนเลือกโปรแกรม แล้วหยิบผ้าขึ้นมาดูตอนจบว่าสะอาดจริงไหม

Loop Engineering คือแนวคิดเดียวกันกับงานโค้ด แนวคิดนี้ถูกพูดถึงในบทความของ Addy Osmani (มิ.ย. 2026) ใจความคือ เลิกเป็นคนพิมพ์ prompt ทุกครั้ง แล้วไปออกแบบระบบที่พิมพ์ prompt แทนเรา ลูปหนึ่งตัวก็คือ เป้าหมายที่ทำซ้ำได้เอง ส่วนเรายังเป็นวิศวกรที่รับผิดชอบผลงานเหมือนเดิม

งานที่เหมาะกับลูปมีจุดร่วมอย่างหนึ่ง คือ เช็กได้ว่าเสร็จหรือยัง เช่น เทสต์ผ่านครบ CI เป็นสีเขียว หรือคิวงานว่าง ถ้างานไหนวัดไม่ได้ว่าเสร็จ เช่น "ทำหน้าเว็บให้สวยขึ้น" ลูปจะไม่รู้ว่าควรหยุดตรงไหน งานแบบนั้นยังเหมาะกับการคุยกับ AI ทีละขั้นมากกว่า

หนึ่งรอบของลูปมี 4 จังหวะ

ไม่ว่าลูปจะใหญ่หรือเล็ก ข้างในหนึ่งรอบจะมี 4 จังหวะเหมือนกันเสมอ

1. หางาน ดูว่ามีอะไรต้องทำ เช่น เทสต์ที่ไม่ผ่าน CI ที่แดง หรือ issue ใหม่
2. ลงมือ แก้โค้ดหรือทำงานชิ้นนั้น
3. ตรวจ เช็กว่าที่ทำไปใช้ได้จริง ด้วยการรันเทสต์ หรือให้ตัวตรวจอีกตัวดู
4. จดไว้ บันทึกว่าทำอะไรไปแล้ว รอบหน้าจะได้ไม่ทำซ้ำ และเราจะได้ย้อนอ่านได้

จังหวะที่คนมักลืมคือการตรวจ ถ้าไม่มีการตรวจ ลูปจะกลายเป็นเครื่องผลิตโค้ดที่ไม่มีใครรู้ว่าถูกหรือผิด ในบทความของ Osmani ยังแบ่งชิ้นส่วนของระบบลูปเต็มรูปแบบไว้ 6 อย่าง

ไม่ต้องรีบใช้ครบทั้ง 6 อย่างครับ บทความนี้ลงมือเฉพาะส่วนแรก คือ /loop และ /goal ซึ่งเป็นหัวใจของลูป ส่วนอื่นค่อยเติมทีหลังเมื่อลูปเล็กๆ ทำงานได้ดีแล้ว ถ้าอยากรู้เรื่อง MCP ต่อ อ่านได้ที่ MCP คืออะไร และเรื่อง Skill อ่านได้ที่ SkillsMP

ศัพท์ที่ต้องรู้

เครื่องมือวนงานใน Claude Code

Claude Code มีวิธีทำให้งานวนต่อเองได้ 3 แบบ ต่างกันที่ว่า "อะไรเป็นตัวเริ่มรอบถัดไป" กับ "อะไรเป็นตัวหยุด"

จำง่ายๆ ว่า /loop คือ นาฬิกาปลุก ดังทุกกี่นาทีก็ว่าไป ส่วน /goal คือ เส้นชัย วิ่งต่อทันทีจนกว่าจะถึง ส่วน Stop hook เป็นตัวที่ปรับแต่งได้มากที่สุด แต่ต้องเขียนตั้งค่าเอง บทความนี้จึงยังไม่ลงลึก

ถ้าอยากให้งานรันตามเวลาแบบจริงจัง Claude Code ยังมีงานตั้งเวลาอีก 2 แบบนอกจาก /loop

เลือกแบบไหนดี เอกสารของ Claude Code แนะนำไว้ประมาณนี้ งานที่ต้องรันแม้ปิดเครื่องให้ใช้ Cloud งานที่ต้องใช้ไฟล์ในเครื่องให้ใช้ Desktop และงานเช็กเร็วๆ ระหว่างที่เรากำลังทำงานอยู่ให้ใช้ /loop (งาน Desktop ที่ตั้งผ่านฟอร์มในแอปจะถี่สุดได้ทุก 1 ชั่วโมง ถ้าให้ Claude ตั้งให้ถึงจะได้ทุก 1 นาที)

ติดตั้ง Claude Code

ถ้ามี Claude Code อยู่แล้ว ข้ามไปหัวข้อถัดไปได้เลยครับ ถ้ายังไม่มี เปิด Terminal (macOS) หรือ PowerShell (Windows) แล้วรันคำสั่งตามระบบที่ใช้

curl -fsSL https://claude.ai/install.sh | bash

irm https://claude.ai/install.ps1 | iex

ทั้งสองคำสั่งทำสิ่งเดียวกัน คือดาวน์โหลดสคริปต์ติดตั้งจากเว็บของ Claude แล้วรันทันที ติดตั้งเสร็จให้ ปิดหน้าต่างแล้วเปิดใหม่ เพื่อให้เครื่องรู้จักคำสั่ง claude แล้วเช็กเวอร์ชัน

claude --version

2.x.x (Claude Code)

ถ้าขึ้นว่าไม่รู้จักคำสั่ง claude แปลว่าโฟลเดอร์ที่ติดตั้งยังไม่อยู่ใน PATH (รายชื่อโฟลเดอร์ที่เครื่องใช้หาคำสั่ง) ให้ดูหัวข้อ "Fix your PATH" ในหน้าแก้ปัญหาการติดตั้งของ Claude Code ส่วนบน Windows ต้องติดตั้ง Git for Windows ไว้ด้วย

ระวังพิมพ์ผิดหน้าต่าง ถ้าเห็นข้อความ The token '&&' is not a valid statement separator แปลว่ากำลังอยู่ใน PowerShell แต่ไปใช้คำสั่งของ macOS ส่วนถ้าเห็น 'irm' is not recognized แปลว่ากำลังอยู่ใน Command Prompt (CMD) ให้เปิด PowerShell แล้วรันใหม่

ลองเปิดใช้งานครั้งแรก

cd ~/Desktop
claude

ครั้งแรกจะมีหน้าเว็บเด้งขึ้นมาให้ล็อกอินด้วยบัญชี Claude ล็อกอินเสร็จกลับมาที่หน้าต่างเดิม จะเห็นช่องให้พิมพ์ ลองพิมพ์ /help เพื่อดูคำสั่งทั้งหมด และ /exit เพื่อออก

เช็กว่าได้แล้ว: claude --version ขึ้นเลขเวอร์ชัน และเปิด claude แล้วเห็นช่องพิมพ์

เตรียมโปรเจกต์ฝึกที่มีบั๊กจริง

ลูปจะมีความหมายก็ต่อเมื่อมีงานให้ทำและมีวิธีตรวจ เราจึงสร้างโปรเจกต์เล็กๆ ที่มีฟังก์ชันบวกเลขเขียนผิดหนึ่งตัว พร้อมเทสต์ที่จับความผิดนั้นได้ ต้องมี Node.js ในเครื่อง (เช็กด้วย node --version) เพราะเราจะใช้ตัวรันเทสต์ที่ติดมากับ Node

cd ~/Desktop
mkdir loop-lab
cd loop-lab
git init

git init ทำให้โฟลเดอร์นี้เป็นโปรเจกต์ Git เพื่อให้เราย้อนกลับได้ทุกเมื่อถ้าลูปแก้อะไรพัง จากนั้นสร้างไฟล์ 2 ไฟล์ในโฟลเดอร์ loop-lab ด้วยโปรแกรมแก้โค้ดที่ถนัด เช่น VS Code

module.exports = (a, b) => a - b;

บั๊กอยู่ตรงนี้ครับ ฟังก์ชันชื่อ sum แต่ดันเอาเลขมาลบกัน ต่อมาคือไฟล์เทสต์

const test = require('node:test');
const assert = require('node:assert');
const sum = require('./sum');
 
test('1 + 2 = 3', () => {
  assert.strictEqual(sum(1, 2), 3);
});

node:test คือตัวรันเทสต์ที่ติดมากับ Node ส่วน assert.strictEqual(ค่าที่ได้, ค่าที่ควรได้) คือการเทียบคำตอบ ถ้าไม่เท่ากันเทสต์จะไม่ผ่าน รันเทสต์ดู ต้องไม่ผ่านก่อน ถึงจะถูก

node --test

✖ 1 + 2 = 3 (0.56ms)
ℹ tests 1
ℹ pass 0
ℹ fail 1
 
✖ failing tests:
  AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
 
  -1 !== 3

อ่านทีละบรรทัด ✖ คือเทสต์ข้อนั้นไม่ผ่าน fail 1 คือไม่ผ่าน 1 ข้อ และ -1 !== 3 บอกเหตุผลตรงตัว ฟังก์ชันคืน -1 (เพราะ 1 − 2) แต่เราอยากได้ 3 สุดท้ายบันทึกจุดเริ่มต้นไว้ใน Git

git add .
git commit -m "start"

ถ้า Git ถามชื่อและอีเมล ให้ตั้งครั้งเดียวด้วย git config --global user.name "ชื่อเรา" และ git config --global user.email "อีเมลเรา" แล้ว commit ใหม่

เช็กว่าได้แล้ว: node --test ขึ้น fail 1 และ git log เห็น commit ชื่อ start

ทำไมต้องให้เทสต์ไม่ผ่านก่อน เทสต์ที่ไม่ผ่านคือ "งาน" ที่ลูปต้องหาเจอ และคือหลักฐานว่าเทสต์ตัวนี้จับความผิดได้จริง ถ้าอยากเข้าใจแนวคิดเขียนเทสต์ก่อนโค้ดให้ลึกขึ้น อ่านต่อได้ที่ Superpowers ส่วน commit ที่ทำไว้ คือปุ่มย้อนเวลา ถ้าลูปแก้อะไรเละ พิมพ์ git checkout . ไฟล์จะกลับเป็นแบบตอน commit

ลูปแรกด้วย /loop

/loop คือคำสั่งให้ Claude รัน prompt เดิมซ้ำเรื่อยๆ ตราบที่ session ยังเปิดอยู่ เหมาะกับงาน "คอยเช็ก" เช่น ดูว่า deploy เสร็จหรือยัง หรือคอยดูว่าเทสต์ยังผ่านอยู่ไหม พิมพ์ได้ 3 แบบ

หน่วยเวลาใช้ได้ 4 แบบ s วินาที m นาที h ชั่วโมง และ d วัน วางไว้หน้า prompt (/loop 30m ...) หรือเขียนต่อท้ายแบบ every 2 hours ก็ได้ ตารางเวลาข้างในละเอียดสุดแค่ระดับนาที วินาทีจึงถูกปัดขึ้นเป็นนาที และค่าที่แบ่งรอบไม่ลงตัว เช่น 7m หรือ 90m จะถูกปัดเป็นค่าใกล้เคียง โดย Claude จะบอกว่าปัดเป็นเท่าไร นอกจากนี้ยังใส่ Skill แทน prompt ได้ด้วย เช่น /loop 20m /review-pr 1234

ลองเลย ให้ลูปคอยดูเทสต์

เปิด Claude Code ในโฟลเดอร์ฝึก

cd ~/Desktop/loop-lab
claude

แล้วพิมพ์ในช่องแชตของ Claude

/loop 1m รัน node --test แล้วบอกในบรรทัดเดียวว่าผ่านกี่ข้อ ไม่ผ่านกี่ข้อ ห้ามแก้ไฟล์ใดๆ

ประโยค "ห้ามแก้ไฟล์ใดๆ" สำคัญครับ ลูปนี้เราตั้งใจให้ทำแค่จังหวะ "ตรวจ" เพื่อดูว่าลูปทำงานยังไง ยังไม่ให้ลงมือแก้เอง Claude จะตั้งงานให้ บอกรอบเวลาและรหัสงาน 8 ตัวอักษร แล้วรันรอบแรกทันที ถ้าเป็นการรันคำสั่งครั้งแรก Claude อาจถามขออนุญาตรัน node --test ก่อน ให้อ่านแล้วกดอนุญาต

ตั้งงานรันทุก 1 นาทีแล้ว (รหัสงาน 3f9a2c1d)
ผ่าน 0 ข้อ ไม่ผ่าน 1 ข้อ

ทีนี้ลองเป็นคนแก้บั๊กเอง เปิด sum.js เปลี่ยน a - b เป็น a + b แล้วเซฟ จากนั้นรอสักครู่ รอบถัดไปจะรายงานผลใหม่เอง

ผ่าน 1 ข้อ ไม่ผ่าน 0 ข้อ

เช็กว่าได้แล้ว: ไม่ต้องพิมพ์อะไรเพิ่ม แต่ผลเปลี่ยนจาก "ไม่ผ่าน 1" เป็น "ผ่าน 1" เอง นี่คือลูปตัวแรกของเราครับ

มีสองเรื่องที่ควรรู้ระหว่างรอ ข้อแรก งานจะรันเฉพาะตอนที่ Claude ว่าง ถ้ากำลังตอบอะไรเราอยู่ รอบนั้นจะรอให้ตอบเสร็จก่อน ข้อสอง เวลาจะคลาดเคลื่อนเล็กน้อยโดยตั้งใจ (เรียกว่า jitter) เพื่อไม่ให้ทุกคนยิงงานพร้อมกันเป๊ะ งานรายชั่วโมงอาจช้าได้ถึง 30 นาที

ดูและหยุดลูป

ลูปที่ไม่หยุดคือลูปที่กินโควตาไปเรื่อยๆ จึงต้องรู้วิธีหยุดตั้งแต่ลูปแรก ทั้งหมดนี้พิมพ์เป็นภาษาธรรมดาในแชตได้เลย

มีงานที่ตั้งเวลาไว้อะไรบ้าง

ยกเลิกงานเช็กเทสต์ที่ตั้งไว้

ถ้ามีหลายงาน บอกรหัสงาน 8 ตัวอักษรไปด้วยจะชัดที่สุด ส่วนลูปแบบที่ Claude เลือกเวลาเอง (ไม่ได้ใส่เวลา) กด Esc ระหว่างที่มันรอรอบถัดไปเพื่อหยุดได้ แต่ ลูปแบบใส่เวลาจะไม่หยุดด้วย Esc ต้องสั่งยกเลิกในแชตเท่านั้น

ยกเลิกเสร็จแล้ว คืนบั๊กกลับมาเพื่อใช้ในแบบฝึกหัดถัดไป (พิมพ์ /exit ออกจาก Claude ก่อน หรือเปิดอีกหน้าต่างก็ได้)

git checkout .
node --test

เช็กว่าได้แล้ว: node --test กลับมาขึ้น fail 1 เหมือนเดิม

ตั้ง prompt ประจำด้วย loop.md

ถ้าพิมพ์ /loop เฉยๆ โดยไม่มี prompt Claude จะใช้ prompt ดูแลงานที่ติดมาให้ ซึ่งทำตามลำดับ คือทำงานที่ค้างในบทสนทนาให้จบ ดูแล pull request ของ branch ปัจจุบัน (คอมเมนต์รีวิว CI ที่ไม่ผ่าน และ conflict) แล้วค่อยเก็บกวาดโค้ดเมื่อไม่มีอะไรค้าง ถ้าอยากให้ /loop เฉยๆ ทำอย่างอื่นแทน ให้สร้างไฟล์ loop.md

รัน node --test
ถ้ามีเทสต์ไม่ผ่าน อธิบายสาเหตุในบรรทัดเดียว แล้วรอฉัน
ถ้าผ่านหมด ตอบว่า "all green" ในบรรทัดเดียว

ไฟล์นี้วางได้ 2 ที่ .claude/loop.md ในโปรเจกต์ (ใช้กับโปรเจกต์นี้ และชนะถ้ามีทั้งสองที่) หรือ ~/.claude/loop.md (ใช้กับทุกโปรเจกต์ที่ไม่มีไฟล์ของตัวเอง) แก้ไฟล์ระหว่างที่ลูปวิ่งอยู่ได้ รอบถัดไปจะใช้ข้อความใหม่ทันที แต่เขียนให้กระชับ เพราะส่วนที่เกิน 25,000 ไบต์จะถูกตัดทิ้ง และถ้าพิมพ์ prompt ต่อท้าย /loop เมื่อไร ไฟล์นี้จะถูกข้าม

ข้อจำกัดของ /loop

• session ต้องเปิดอยู่และว่าง ปิดหน้าต่างเมื่อไร งานหยุดทันที
• งานที่วนซ้ำหมดอายุใน 7 วัน รันรอบสุดท้ายแล้วลบตัวเอง กันลูปที่ถูกลืมวิ่งไปตลอดกาล
• ไม่มีรันชดเชย ถ้าพลาดไปหลายรอบระหว่างที่ Claude ยุ่ง จะรันแค่ครั้งเดียวตอนว่าง
• เปิดแชตเดิมต่อด้วย claude --resume งานที่ใส่เวลาจะกลับมา แต่ลูปแบบให้ Claude เลือกเวลาเองต้องสั่ง /loop ใหม่
• หนึ่ง session มีงานได้สูงสุด 50 งาน
• ปิดระบบตั้งเวลาทั้งหมด ได้ด้วยตัวแปร CLAUDE_CODE_DISABLE_CRON=1

ทำงานจนเสร็จด้วย /goal

/loop เหมาะกับงานคอยเช็กตามเวลา แต่ถ้าเราอยากให้ AI ลงมือแก้จนเสร็จ โดยไม่ต้องรอนาฬิกา ให้ใช้ /goal เราบอกเงื่อนไขว่าเสร็จแปลว่าอะไร พอ Claude ทำงานจบหนึ่งรอบ จะมีโมเดลตัวเล็กและเร็วอีกตัวมาเป็นกรรมการ (evaluator) ดูว่าถึงเงื่อนไขหรือยัง

• ยังไม่ผ่าน Claude ทำรอบต่อทันที โดยใช้เหตุผลของตัวตรวจเป็นแนวทาง
• ผ่านแล้ว goal ถูกล้าง และบันทึกว่าสำเร็จ
• เป็นไปไม่ได้ goal ถูกล้าง พร้อมบอกเหตุผลว่าทำไมทำไม่ได้

ประเด็นที่ต้องเข้าใจให้ขาดคือ ตัวตรวจอ่านได้แค่สิ่งที่ Claude แสดงในแชต มันไม่ได้รันคำสั่งหรือเปิดไฟล์ดูเอง เหมือนกรรมการที่ดูแค่กระดาษคำตอบที่ส่งมา ถ้าเงื่อนไขพิสูจน์ในแชตไม่ได้ เช่น "โค้ดสวยขึ้น" ตัวตรวจจะตัดสินไม่ถูก

เงื่อนไขที่ดีมี 4 ส่วน

1. ผลลัพธ์เดียวที่วัดได้ เช่น เทสต์ผ่านครบ build สำเร็จ จำนวนไฟล์ หรือคิวว่าง
2. วิธีพิสูจน์ บอกเลยว่าดูจากอะไร เช่น "node --test จบด้วย exit code 0"
3. ข้อห้ามระหว่างทาง สิ่งที่ห้ามเปลี่ยน เช่น "แก้ได้เฉพาะ sum.js"
4. เพดาน จุดหยุดถ้าไม่สำเร็จ เช่น "หรือหยุดเมื่อครบ 10 turn"

เงื่อนไขยาวได้สูงสุด 4,000 ตัวอักษร ข้อ 3 สำคัญกว่าที่คิดครับ ถ้าไม่เขียนไว้ AI อาจทำให้เทสต์ผ่านด้วยการแก้เทสต์แทนการแก้โค้ด ซึ่งเงื่อนไขผ่านก็จริง แต่ไม่ใช่สิ่งที่เราต้องการ

ลองเลย ให้ AI แก้บั๊กเอง

เช็กก่อนว่า sum.js ยังเป็น a - b อยู่ (ถ้ายัง ให้ git checkout . ตามหัวข้อก่อน) แล้วเปิด Claude ในโฟลเดอร์ loop-lab พิมพ์

/goal node --test ผ่านทุกข้อและจบด้วย exit code 0 แก้ได้เฉพาะไฟล์ sum.js เท่านั้น หรือหยุดเมื่อครบ 10 turn

ครบทั้ง 4 ส่วน ผลลัพธ์คือเทสต์ผ่าน วิธีพิสูจน์คือ exit code 0 ข้อห้ามคือแก้ได้แค่ sum.js และเพดานคือ 10 turn (เขียนเป็นภาษาอังกฤษก็ได้ เช่น /goal node --test exits 0 with all tests passing, only sum.js is changed, or stop after 10 turns)

พอกด Enter งานเริ่มทันทีโดยไม่ต้องพิมพ์สั่งเพิ่ม จะเห็นป้าย ◎ /goal active บอกว่า goal กำลังทำงานและทำมานานเท่าไร Claude จะรันเทสต์ เห็น -1 !== 3 แก้ sum.js แล้วรันเทสต์อีกรอบ พอผ่าน ตัวตรวจจะตัดสินว่าถึงเงื่อนไขแล้วและจบงาน

/goal ไม่ได้เปลี่ยนโหมดสิทธิ์ ถ้ายังอยู่โหมดปกติ Claude จะถามก่อนรันคำสั่งหรือแก้ไฟล์เหมือนเดิม สำหรับการฝึกครั้งแรกแนะนำให้กดอนุญาตเองทีละครั้ง จะได้เห็นทุกอย่างที่มันทำ ถ้าอยากให้วิ่งเองโดยไม่ถาม กด Shift+Tab เพื่อสลับไปโหมด auto (อ่านหัวข้อความปลอดภัยก่อนนะครับ)

อย่าเชื่อคำว่าเสร็จทันที

goal จบแล้วไม่ได้แปลว่างานถูกแน่นอน ตัวตรวจตัดสินจากสิ่งที่อยู่ในแชต ซึ่งอาจตกหล่นได้ Osmani ย้ำไว้ในบทความว่า "เสร็จแล้ว" ที่ลูปบอกเป็นแค่คำกล่าวอ้าง ยังไม่ใช่หลักฐาน เราจึงตรวจเองอีกรอบ

node --test
git diff

diff --git a/sum.js b/sum.js
--- a/sum.js
+++ b/sum.js
@@ -1 +1 @@
-module.exports = (a, b) => a - b;
+module.exports = (a, b) => a + b;

บรรทัดที่ขึ้นต้นด้วย - คือของเดิม บรรทัด + คือของใหม่ ถ้าเห็นแค่ sum.js เปลี่ยนบรรทัดเดียว แปลว่า Claude ทำตามข้อห้าม ไม่ได้ไปแตะไฟล์เทสต์

เช็กว่าได้แล้ว: node --test ขึ้น pass 1 และ git diff มีแค่ sum.js เปลี่ยน 1 บรรทัด

ออกแบบลูปของตัวเอง

พอเข้าใจทั้งสองคำสั่งแล้ว ลองออกแบบลูปของงานจริงด้วยคำถาม 4 ข้อ

1. อะไรที่ต้องทำซ้ำ งานที่เราทำแบบเดิมทุกวัน หรือคอยเช็กบ่อยๆ
2. รอบใหม่เริ่มเมื่อไร ถ้าตามเวลา ใช้ /loop ถ้าเริ่มต่อทันทีที่รอบก่อนจบ ใช้ /goal
3. รู้ได้ยังไงว่าเสร็จ ต้องเป็นสิ่งที่เห็นได้ในแชต เช่น ผลเทสต์ หรือผลของคำสั่ง
4. ถ้าไม่เสร็จ หยุดเมื่อไร จำนวน turn เวลา หรือเรายกเลิกเอง

ในบทความของ Osmani มีตัวอย่างลูปทั้งวันของทีมที่ใช้ครบทุกชิ้นส่วน ตอนเช้ามีงานตั้งเวลาไล่ดู CI กับ issue ใหม่แล้วจดลงไฟล์สถานะ งานแต่ละชิ้นแยกทำใน worktree ของตัวเอง มีเอเจนต์ตัวที่สองคอยรีวิว ใช้ connector เปิด PR และอัปเดตตั๋วงาน ส่วนเรื่องที่ต้องให้คนตัดสินถูกส่งเข้ากล่องของคน ฟังดูใหญ่ แต่ทุกระบบแบบนี้เริ่มจากลูปเล็กๆ ตัวเดียวที่ทำงานได้จริง แล้วค่อยต่อเติมทีละชิ้นครับ

ความปลอดภัยและค่าใช้จ่าย

ลูปทำงานแทนเราได้ก็จริง แต่ผลลัพธ์ยังเป็นความรับผิดชอบของเรา จำ 7 ข้อนี้ไว้

1. ตั้งจุดหยุดเสมอ ทุก /goal ควรมีเพดาน และทุก /loop ต้องรู้วิธียกเลิก
2. token โตตามจำนวนรอบ ทุกรอบใช้โควตา และถ้ามีเอเจนต์ย่อย แต่ละตัวก็ใช้ token ของตัวเองแยกกัน
3. commit ก่อนเริ่มลูป จะได้มีจุดย้อนกลับถ้าลูปแก้อะไรพัง
4. ระวังโหมด auto ใช้กับโปรเจกต์ที่ commit ไว้แล้ว และงานที่ขอบเขตชัดเท่านั้น
5. อ่านโค้ดที่ลูปเขียน โค้ดที่เราไม่เคยอ่านคือหนี้ความเข้าใจ (comprehension debt) วันที่มันพังเราจะแก้ไม่เป็น
6. อย่ารับผลโดยไม่คิด การยอมรับทุกอย่างที่ AI บอกเพราะขี้เกียจคิด (cognitive surrender) ทำให้ฝีมือเราถดถอย
7. เพดานจริงคือเวลารีวิวของเรา ลูปผลิตงานได้เร็วแค่ไหนก็ตาม ถ้าเราตรวจไม่ทัน งานที่ได้ก็ใช้ไม่ได้

เริ่มจากลูปที่ดูอย่างเดียว ลูปแรกของงานจริงควรเป็นแบบ "เช็กแล้วรายงาน" ห้ามแก้ไฟล์ เหมือนแบบฝึกหัด /loop ด้านบน พอเห็นว่ามันรายงานถูกต้องสม่ำเสมอ ค่อยขยับเป็นลูปที่ลงมือแก้เอง

เจอปัญหา ลองเช็กตามนี้

เก็บกวาดหลังฝึก

ลูปที่ถูกลืมคือลูปที่กินโควตาเงียบๆ ฝึกเสร็จแล้วเก็บให้เรียบร้อย

1. ถาม Claude ว่า "มีงานที่ตั้งเวลาไว้อะไรบ้าง" แล้วยกเลิกทุกงานที่เหลือ
2. พิมพ์ /goal clear ถ้ายังมี goal ค้าง
3. ออกจาก Claude ด้วย /exit แล้วลบโฟลเดอร์ฝึกทิ้งได้

rm -rf ~/Desktop/loop-lab

Remove-Item -Recurse -Force "$HOME\Desktop\loop-lab"

คำสั่งลบทั้งสองแบบลบทั้งโฟลเดอร์โดยไม่ถามซ้ำ เช็กชื่อโฟลเดอร์ให้ดีก่อนกด Enter ครับ

ไปต่อ

• บทความต้นทางของแนวคิด Loop Engineering โดย Addy Osmani
• เอกสาร /loop และงานตั้งเวลา และ /goal ของ Claude Code
• เริ่มต้นใช้ Claude Code แบบละเอียด Quickstart
• ต่อลูปเข้ากับเครื่องมือภายนอกด้วย MCP และสอนนิสัยดีๆ ให้ AI ด้วย Superpowers

สรุป

• Loop Engineering คือเลิกพิมพ์ prompt ทุกครั้ง แล้วออกแบบระบบที่ป้อนงานให้ AI เอง ส่วนเรายังเป็นคนออกแบบและตรวจผล
• ลูปหนึ่งรอบมี 4 จังหวะ หางาน ลงมือ ตรวจ และจดไว้ จังหวะตรวจขาดไม่ได้
• /loop วนตามเวลา เหมาะกับงานคอยเช็ก ลูปแบบใส่เวลาต้องสั่งยกเลิกในแชต และหมดอายุเองใน 7 วัน
• /goal วนต่อทันทีจนผ่านเงื่อนไข ตัวตรวจอ่านได้แค่สิ่งที่อยู่ในแชต เงื่อนไขที่ดีต้องวัดได้ บอกวิธีพิสูจน์ มีข้อห้าม และมีเพดาน
• "เสร็จแล้ว" จากลูปเป็นแค่คำกล่าวอ้าง ตรวจเองด้วย node --test และ git diff เสมอ และ commit ก่อนเริ่มลูปทุกครั้ง

พร้อมแล้วก็ไปทำ Quiz ท้ายบทด้านล่างเพื่อรับ XP ได้เลยครับ