สำหรับสองปีที่ผ่านมา การจะได้ผลลัพธ์มากขึ้นจาก AI Agent หมายถึงการเขียน Prompt ที่ดีขึ้น
ยุคสมัยนั้นกำลังจะจบลงอย่างเงียบๆ วิศวกรที่ดีที่สุดในโลกเลิกเขียน Prompt ไปได้สักพักแล้ว และหันมาเขียน "Loop" ซึ่งก็คือระบบที่ Prompt ให้ Agent ตรวจสอบผลลัพธ์ และทำงานต่อไปเรื่อยๆ จนกว่างานจะเสร็จ
สคริปต์ที่ Karpathy รันข้ามคืนพบการปรับแต่ง 20 จุดที่เขามองข้ามไปตลอดสองทศวรรษของการปรับแต่งด้วยมือ Boris Cherny ผู้สร้าง Claude Code ไม่ได้เขียนโค้ดแม้แต่บรรทัดเดียวในปีนี้ วิศวกรของ Anthropic ตอนนี้ Merge โค้ดเพิ่มขึ้นเกือบ 8 เท่าต่อวันเมื่อเทียบกับปี 2024
ไม่มีใครในพวกเขาพิมพ์อะไรที่ฉลาดขึ้น พวกเขาหยุดพิมพ์ไปเลย
นี่คือสิ่งที่ Loop จริงๆ เป็น เมื่อไหร่ที่คุณจำเป็นต้องใช้ เมื่อไหร่ที่ไม่จำเป็น และวิธีสร้าง Loop แรกของคุณ
700 การทดลองในขณะที่มนุษย์หลับ
มีนาคม 2026 Andrej Karpathy อัปโหลดสามไฟล์ไปยัง GitHub ประมาณ 630 บรรทัดของโค้ด
ไฟล์หนึ่งเก็บโมเดล ไฟล์หนึ่งให้คะแนนผลลัพธ์ และอีกไฟล์บอก Agent ว่าควรสำรวจอะไรและควรปล่อยอะไรไว้ตามเดิม Agent สามารถแตะได้เฉพาะไฟล์ฝึกสอนเท่านั้น ไม่มีอะไรอื่น
วงจรนี้ถูกออกแบบให้ซ้ำซากจำเจโดยเจตนา อ่านโค้ด เสนอการเปลี่ยนแปลง ฝึกสอนเป็นเวลาห้านาที ตรวจสอบว่าคะแนนดีขึ้นหรือไม่ เก็บการเปลี่ยนแปลงไว้ถ้ามันดีขึ้น ย้อนกลับถ้ามันไม่ดีขึ้น แล้วเริ่มใหม่
เขาชี้เป้าไปที่โมเดลที่เขาปรับแต่งด้วยมือมาเป็นเวลาสองทศวรรษ ปล่อยให้มันทำงานเป็นเวลาสองวัน
มันรันการทดลอง 700 ครั้ง มันพบการปรับปรุง 20 จุด หนึ่งในนั้นคือตัวคูณสเกลาร์ที่หายไปในกลไกการใส่ใจ (Attention Mechanism) ซึ่งเป็นอะไรที่ละเอียดอ่อน ไม่ใช่บั๊กที่ Linter ใดๆ จะจับได้ แต่เป็นสิ่งที่วิศวกรที่ระมัดระวังอาจพบได้แต่ไม่เคยพบ
CEO ของ Shopify ใช้เทคนิคเดียวกันนี้รันข้ามคืนกับโมเดลภายในบริษัท เขาตื่นขึ้นมาพบว่าคุณภาพเพิ่มขึ้น 19 เปอร์เซ็นต์บนโมเดลที่มีขนาดครึ่งหนึ่งของโมเดลก่อนหน้า
ข้อมูลเชิงลึกไม่ใช่ "AI ฉลาดขึ้น" มนุษย์เริ่มเหนื่อยหลังจากการทดลองครั้งที่สิบสอง Loop ไม่เคยเหนื่อยเลย
Loop ไม่ใช่ Prompt ที่ตั้งเวลาทำงาน
คนส่วนใหญ่ได้ยินคำว่า "Loop" แล้วนึกถึง Cron ซึ่งนั่นพลาดประเด็นสำคัญไป
Prompt คือคำสั่งเดียว Loop คือเป้าหมายที่ AI ทำงานไปเรื่อยๆ จนกว่าจะถึงเป้าหมาย โดยไม่มีใครนั่งควบคุม มันวางแผน ดำเนินการ ตรวจสอบผลลัพธ์ของตัวเอง ป้อนผลลัพธ์กลับเข้าไป และทำซ้ำ
ห้าขั้นตอน: ค้นหา, วางแผน, ดำเนินการ, ตรวจสอบ, ทำซ้ำ สามขั้นตอนในนั้นทำงานจริง
ตัวตรวจสอบ (Verifier) คือหัวใจของ Loop หากไม่มี Gate ที่แท้จริงบนผลลัพธ์ คุณจะไม่มี Loop แต่คุณมี Agent ที่ตรวจการบ้านตัวเองไปเรื่อยๆ Gate คือการทดสอบที่ผ่านหรือไม่ผ่าน, Build ที่ Compile หรือ Crash, Linter ที่คืนค่าเป็นศูนย์หรือไม่เป็นศูนย์ ไม่ใช่ Agent ตัวที่สองที่มีความเห็น
State คือสิ่งที่ทำให้ Loop เรียนรู้ ไฟล์ที่เก็บไว้ข้างๆ, บอร์ด Linear, บันทึกโครงการ, ที่ไหนสักแห่งภายนอกการสนทนาที่บันทึกว่าลองอะไรไปแล้วและอะไรล้มเหลว การทำงานในวันพรุ่งนี้จะดำเนินการต่อแทนที่จะเริ่มจากศูนย์
เงื่อนไขการหยุด (Stop Condition) คือสิ่งที่ทำให้มันมีสติ ทุก Loop ที่แท้จริงมีสองทางออก: เป้าหมายสำเร็จ หรือขีดจำกัดสูงสุดถูกเรียกใช้ ข้ามสิ่งนี้ไป คุณจะสร้างเครื่องจักรที่ทำงานทั้งคืนโดยไม่มีอะไรเกิดขึ้น
พลาดสามสิ่งนี้ไป คุณจะไม่ได้สร้าง Loop คุณสร้างสคริปต์ราคาแพง
เงื่อนไขสี่ประการก่อนที่คุณจะสร้าง Loop ขึ้นมา
Loop จะคุ้มค่ากับต้นทุนก็ต่อเมื่อเงื่อนไขสี่ประการเป็นจริงพร้อมกันเท่านั้น พลาดข้อใดข้อหนึ่ง การตั้งค่าจะใช้ต้นทุนมากกว่าผลตอบแทนที่ได้รับ
- งานเกิดขึ้นซ้ำๆ อย่างน้อยสัปดาห์ละครั้ง น้อยกว่านั้น ต้นทุนการตั้งค่าจะไม่มีวันคุ้มทุน
- มีบางอย่างที่สามารถทำให้งานล้มเหลวได้โดยอัตโนมัติ เช่น การทดสอบ, การตรวจสอบชนิดข้อมูล, Linter, Build
- งบประมาณ Token ของคุณสามารถรองรับความสิ้นเปลืองได้ Loops อ่านบริบทซ้ำ ลองใหม่ และสำรวจ
- Agent มีเครื่องมือระดับวิศวกรอาวุโส เช่น Logs, สภาพแวดล้อมที่สามารถจำลองปัญหา, ความสามารถในการรันโค้ดที่มันเขียนและดูว่าอะไรพัง
ส่วนที่ซื่อสัตย์ ซึ่งเป็นส่วนที่ไม่มีใครขาย Loop จะบอกคุณ: คนส่วนใหญ่ยังไม่จำเป็นต้องใช้เวอร์ชันหนักหน่วงนี้ หากคุณใช้แผนผู้บริโภคและพยายามรัน Loop ตรวจสอบข้ามคืนกับงานที่จริงจัง ค่าใช้จ่าย Token จะมาถึงก่อนที่ผลผลิตจะเพิ่มขึ้น
Loop แรกที่ดีคือ Loop ที่น่าเบื่อ การจัดลำดับความสำคัญของ CI, การอัปเดต Dependency, การตรวจสอบและแก้ไข Lint, การจำลองการทดสอบที่ไม่เสถียร, การร่าง Issue-to-PR บนฐานโค้ดที่มีการทดสอบที่แข็งแกร่งอยู่แล้ว
Loop แรกที่ไม่ดีคือ Loop ที่น่าสนใจ การเขียนสถาปัตยกรรมใหม่, โค้ด Authentication, การชำระเงิน, อะไรก็ตามที่ "เสร็จ" เป็นการตัดสินใจและมนุษย์ยังคงต้องมีส่วนร่วม
ห้าส่วนประกอบที่ทำให้ Loop กลายเป็นจริง
ทุก Loop ที่แท้จริงประกอบขึ้นจากห้าส่วนประกอบเดียวกัน ตอนนี้ Claude Code และ Codex มีทั้งหมดนี้แล้ว
ส่วนแรกคือ Automation (ระบบอัตโนมัติ) หัวใจที่เต้น เป็นสิ่งที่เรียกใช้ Loop ตามกำหนดเวลาหรือเหตุการณ์ /loop รันในจังหวะที่กำหนด /goal ทำงานต่อไปจนกว่าเงื่อนไขที่คุณกำหนดไว้จะเป็นจริง หากไม่มีหัวใจที่เต้น Loop ก็คือสคริปต์ที่คุณรันครั้งเดียวแล้วลืม
ส่วนที่สองคือ Skill (ทักษะ) ความรู้ของโครงการที่บันทึกเป็นไฟล์ claude-md ที่ Agent อ่านทุกครั้งที่รัน หากไม่มี Loop จะต้องอนุมานบริบทของคุณใหม่จากศูนย์ทุกครั้งที่มีรอบการทำงาน เมื่อมี บริบทจะสั่งสมขึ้นเรื่อยๆ Loop รู้จักข้อตกลงของคุณ, ขั้นตอนการ Build ของคุณ, สิ่งที่คุณไม่เคยทำเพราะเหตุการณ์ที่เกิดขึ้นเมื่อสามเดือนก่อน
ส่วนที่สามคือ Sub-Agents (ตัวแทนย่อย) ผู้สร้างและผู้ตรวจสอบต้องไม่เป็นโมเดลเดียวกัน โมเดลที่เขียนโค้ดจะใจดีเกินไปในการตรวจสอบงานของตัวเอง โมเดลที่เขียนบทความจะมองไม่เห็นจุดอ่อนของตัวเอง ให้ผู้เขียนเร็วและราคาถูก ผู้ตรวจสอบช้าและเข้มงวด การแยกนี้คือคุณภาพส่วนใหญ่
ส่วนที่สี่คือ Connectors (ตัวเชื่อมต่อ) Loop เปิด Pull Request, ปิด Ticket, ส่งข้อความในช่องเมื่อ CI เปลี่ยนเป็นสีเขียว นี่คือความแตกต่างระหว่าง Agent ที่พูดว่า "นี่คือวิธีแก้ไขที่แนะนำ" กับรายงานที่รอคุณอยู่ในตอนเช้าที่บอกว่า PR ถูก Merge ไปแล้ว
ส่วนที่ห้าคือ Verifier (ตัวตรวจสอบ) การทดสอบ การตรวจสอบชนิดข้อมูล หรือ Build ที่ทำให้งานที่ผิดพลาดล้มเหลวโดยอัตโนมัติ ทุกอย่างอื่นเป็นแค่ระบบประปา นี่คือส่วนประกอบที่ตัดสินว่า Loop ช่วยคุณหรือแค่ใช้เงินของคุณ
รวมสิ่งเหล่านี้เข้าด้วยกัน แล้วคุณจะได้สิ่งที่ทีมจริงจังตอนนี้รันในระดับใหญ่ Loops นับสิบ แต่ละตัวรับผิดชอบงานแคบๆ หนึ่งงาน ทำงานเคียงข้างกันในขณะที่ทุกคนหลับ วิศวกรคนหนึ่งใช้ Fleet Loop แบบนี้เพื่อเขียนฐานโค้ดทั้งหมดจากภาษาหนึ่งไปยังอีกภาษาหนึ่งในเวลาประมาณหกวัน ซึ่งเป็นงานที่如果用มือทำจะใช้เวลาเกือบหนึ่งปี
จุดที่ Loop ล้มเหลวอย่างเงียบๆ
Loop ไม่พัง มันเรียกเก็บเงินคุณอย่างเงียบๆ มีรูปแบบความล้มเหลวสองแบบที่ควรกล่าวถึง ซึ่งทั้งคู่จะแย่ลงเมื่อ Loop ดีขึ้น ไม่ใช่แย่ลง
รูปแบบแรกคือ Ralph Wiggum Loop วิศวกร Geoffrey Huntley บันทึกไว้ Agent ตัดสินใจว่ามันเสร็จเร็วเกินไป ส่งสัญญาณเสร็จสมบูรณ์ในงานที่ทำไปครึ่งเดียว และ Loop ก็ออกไปอย่างพอใจ หากไม่มี Gate เชิงวัตถุประสงค์ที่แข็งกร้าว Loop จะทำงานต่อไปในคืนถัดไป ใช้เงินต่อไป และผลิตงานที่ไม่มีใครยอมรับ
วิธีแก้ไขไม่ใช่ Agent ที่ฉลาดขึ้น แต่เป็น Gate ที่โง่ลง การทดสอบที่ผ่านหรือไม่ผ่าน Build ที่ Compile หรือไม่ สิ่งที่ไม่มีความคิดเห็น
รูปแบบที่สองละเอียดอ่อนกว่า หนี้ความเข้าใจ (Comprehension debt) ยิ่ง Loop ส่งโค้ดที่คุณไม่ได้เขียนได้เร็วเท่าไหร่ ช่องว่างระหว่างสิ่งที่ Repository ของคุณมีและสิ่งที่คุณเข้าใจจริงๆ ก็ยิ่งมากขึ้นเท่านั้น Loop ที่ทำงานราบรื่นจะคิดดอกเบี้ยทบต้นจากช่องว่างนั้น วันที่คุณต้องดีบักระบบที่ไม่มีใครในทีมเคยอ่าน มีค่าใช้จ่ายมากกว่า Token ที่เคยใช้
การยอมจำนนทางความคิด (Cognitive surrender) มาพร้อมกับมัน เมื่อ Loop ทำงานด้วยตัวเอง มันเป็นสิ่งล่อใจที่จะหยุดสร้างความคิดเห็นและยอมรับทุกสิ่งที่ส่งกลับมา การออกแบบ Loop คือการรักษาเมื่อคุณทำด้วยวิจารณญาณ มันคือตัวเร่งเมื่อคุณทำเพื่อหลีกเลี่ยงการคิด การกระทำเดียวกัน ผลลัพธ์ตรงกันข้าม
คนสองคนสามารถสร้าง Loop ที่เหมือนกันทุกประการและจบลงที่จุดที่ตรงกันข้าม คนหนึ่งใช้มันเพื่อทำงานเร็วขึ้นในสิ่งที่เขาเข้าใจอย่างลึกซึ้ง อีกคนใช้มันเพื่อหลีกเลี่ยงการเข้าใจงานเลย Loop ไม่รู้ว่าต่างกันอย่างไร แต่คุณรู้
เริ่มต้นด้วย Loop เดียว ไม่ใช่สิบ
ความผิดพลาดที่ทุกคนทำคือพยายามสร้างทั้งระบบในวันแรก Loops สิบตัว, Dashboard, Fleet มันพังภายในวันหยุดสุดสัปดาห์เพราะคุณไม่สามารถบอกได้ว่า Loop ไหนทำอะไร
เริ่มต้นด้วยอันเดียว เลือกงานที่เกิดขึ้นซ้ำๆ ที่น่ารำคาญที่สุดที่คุณมี สิ่งที่คุณตรวจสอบทุกเช้าด้วยนิสัย และเปลี่ยนงานเดียวนั้นให้เป็น Loop ปล่อยให้มันทำงานสักสองสามวัน ดูว่ามันใจดีเกินไปตรงไหน ดูว่ามันพลาดตรงไหน ปรับให้แน่นขึ้น แล้วค่อยเพิ่มอันที่สอง
ลำดับสำคัญกว่าเครื่องมือ ทำให้การทำงานด้วยมือครั้งเดียวเชื่อถือได้ก่อน ไม่ใช่เร็ว แต่เชื่อถือได้ เปลี่ยนการทำงานนั้นเป็น Skill ใน claude-md ห่อ Skill นั้นด้วย Loop ที่มี Gate เชิงวัตถุประสงค์และเงื่อนไขการหยุดที่เข้มงวด จากนั้น เมื่อนั้นเท่านั้น ถึงนำไปใส่ในตารางเวลา การข้ามขั้นตอน การกำหนดเวลาสิ่งที่คุณยังไม่ได้ทำให้เชื่อถือได้ด้วยมือ คือวิธีที่ Loop ระเบิดในขณะที่คุณหลับ
เมตริกที่ตัดสินว่า Loop ทำงานได้ดีหรือไม่ ไม่ใช่ Token ที่ใช้ไป หรืองานที่พยายามทำ หรือ PR ที่เปิดขึ้น มันคือต้นทุนต่อการเปลี่ยนแปลงที่ยอมรับ (Cost per accepted change) หากอัตราการยอมรับการเปลี่ยนแปลงของคุณต่ำกว่า 50 เปอร์เซ็นต์ แสดงว่าคุณกำลังทำงานตรวจสอบที่ Loop ควรจะกำจัดออกไป และ Loop กำลังขาดทุน
Karpathy หยุดเขียนโค้ดฝึกสอน Cherny หยุด Prompt ทั้งคู่ไม่ได้หยุดคิด หากคุณได้รับสิ่งหนึ่งจากบทความนี้ จงรับสิ่งนี้ไป Loop คือระบบที่ทำ 95 เปอร์เซ็นต์ที่น่าเบื่อ ในขณะที่คุณจดจ่อกับ 5 เปอร์เซ็นต์ที่แบกความเสี่ยงจริงๆ
คุณกำลังจ่ายเงินเพื่อ Fleet ของ Agent และใช้หน้าต่างแชทเพียงหน้าต่างเดียว
ติดตามผมและ Subscribe ช่อง Telegram ของผม: https://t.me/+75nMf005jRpjMDU1
