Loop Engineering: ทำไมผู้สร้าง Claude Code ถึงบอกว่าเขาไม่จำเป็นต้องเขียน Prompt อีกต่อไป

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

- Boris Cherny ผู้สร้างและหัวหน้าของ Claude Code ที่ Anthropic

ประมาณสองปีที่ผ่านมา ทักษะที่ทุกคนไล่ตามคือวิศวกรรมพรอมต์ (prompt engineering) เขียนพรอมต์ดีๆ สักอัน แชร์บริบทให้เพียงพอ อ่านผลลัพธ์ แล้วเขียนพรอมต์ถัดไป คุณถือเอเจนต์เหมือนเครื่องมือ ทีละเทิร์น

ยุคสมัยนั้นกำลังจะจบลงอย่างเงียบๆ

ในช่วงกลางปี 2026 เสียงสามเสียงได้มาบรรจบกันที่แนวคิดเดียวกันภายในเวลาไม่กี่วัน Boris Cherny (Claude Code) บอกว่าหน้าที่ของเขาตอนนี้คือการเขียนลูป Peter Steinberger (ผู้สร้าง OpenClaw) บอกกับนักพัฒนาหลายล้านคนว่า "คุณไม่ควรพรอมต์โค้ดดิ้งเอเจนต์อีกต่อไปแล้ว คุณควรออกแบบลูปที่พรอมต์เอเจนต์ของคุณ" และ Addy Osmani (Google) ได้ตั้งชื่อให้กับรูปแบบนี้ในโพสต์ที่มีการแชร์อย่างกว้างขวาง: Loop Engineering บทความนี้จะอธิบายว่า loop engineering คืออะไรจริงๆ ปัญหาที่มันแก้ได้ วิธีที่มันแก้ปัญหาเหล่านั้น ตัวอย่างโค้ดที่ใช้งานได้จริงที่คุณสามารถรันได้วันนี้ และข้อแลกเปลี่ยนที่จริงใจที่ไม่มีใครพูดถึงในกระทู้ hype

Loop Engineering คืออะไร?

Loop engineering คือการแทนที่ตัวคุณเองในฐานะคนที่พรอมต์เอเจนต์ คุณออกแบบระบบที่ทำหน้าที่พรอมต์แทน

ลูปคือเป้าหมายแบบเรียกซ้ำ (recursive goal): คุณกำหนดจุดประสงค์และเงื่อนไขการหยุดที่ตรวจสอบได้ และ AI จะวนซ้ำ ค้นพบงาน ดำเนินการ ตรวจสอบ และบันทึกความคืบหน้า จนกว่าเงื่อนไขจะเป็นจริง คุณไม่ได้ อยู่ใน ลูปอีกต่อไป คุณ อยู่เหนือ มัน

ลองนึกถึงลำดับชั้นแบบนี้:

1. วิศวกรรมพรอมต์ (Prompt engineering) : คุณเขียนคำสั่งที่ดีหนึ่งอัน
2. วิศวกรรมบริบท (Context engineering) : คุณรวบรวมข้อมูลที่ถูกต้องรอบๆ คำสั่ง
3. วิศวกรรมสายรัดเอเจนต์ (Agent harness engineering) : คุณสร้างสภาพแวดล้อมที่เอเจนต์หนึ่งตัวทำงานอยู่ภายใน
4. วิศวกรรมลูป (Loop engineering) : คุณสร้างระบบที่รันสายรัดตามเวลาที่กำหนด สร้างผู้ช่วย และตรวจสอบงาน

เวิร์กโฟลว์แบบเก่า: เขียนพรอมต์ → อ่านผลลัพธ์ → เขียนพรอมต์ถัดไป (คุณคือลูป)

เวิร์กโฟลว์แบบใหม่: ออกแบบลูปครั้งเดียว → ลูปค้นพบงาน → ลูปมอบหมายเอเจนต์ → ลูปตรวจสอบ → ลูปบันทึกสถานะ → ทำซ้ำ (คุณตรวจสอบและปรับทิศทาง)

ปัญหาที่ Loop Engineering แก้ไข

ปัญหา 1: คุณคือคอขวด

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

ปัญหา 2: เอเจนต์ลืมทุกอย่างระหว่างเซสชัน

ทุกเซสชันเริ่มต้นจากศูนย์ โมเดลจะต้องเรียนรู้กฎเกณฑ์ของโปรเจกต์ ขั้นตอนการ build และบทเรียนที่ได้มาอย่างยากลำบากของคุณใหม่จากศูนย์ หรือแย่กว่านั้นคือ เติมช่องว่างด้วยการเดาที่มั่นใจ นี่คือสิ่งที่ Osmani เรียกว่า หนี้เจตนา (intent debt): เจตนาที่ไม่ได้ระบุไว้ ซึ่งต้องถูกชำระคืน (หรือเดาใหม่) ทุกครั้งที่รัน

ปัญหา 3: เอเจนต์ตรวจการบ้านตัวเอง

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

ปัญหา 4: เอเจนต์ที่ทำงานพร้อมกันชนกัน

ทันทีที่คุณรันเอเจนต์มากกว่าหนึ่งตัวบน repo เดียวกัน พวกมันจะเริ่มเขียนทับไฟล์ของกันและกัน ซึ่งเป็นหายนะแบบเดียวกับที่วิศวกรสองคน commit ไปที่บรรทัดเดียวกันโดยไม่คุยกัน

ปัญหา 5: งานที่เกิดซ้ำไม่เคยถูกทำให้เป็นอัตโนมัติ

การจัดการ CI ที่ล้มเหลว การอัปเดต dependency การตามล่าเทสที่ไม่แน่นอน การติดป้าย issue การกวาดล้างบั๊กประจำวัน งานเหล่านี้มันน่าเบื่อ ไม่รู้จบ และเหมาะกับเอเจนต์อย่างยิ่ง แต่ไม่มีใครพรอมต์เอเจนต์ให้ทำทุกเช้า เพราะ คุณ ต้องมาปรากฏตัวทุกเช้าเพื่อทำการพรอมต์

Loop Engineering แก้ปัญหาเหล่านี้ได้อย่างไร: องค์ประกอบสำคัญหกประการ

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

1. ระบบอัตโนมัติ (Automations) : หัวใจที่เต้น

การรันตามกำหนดเวลาที่ทำการค้นพบและคัดแยกด้วยตัวเอง สิ่งนี้แก้ ปัญหา 5

• Claude Code: /loop รันพรอมต์ซ้ำตามจังหวะ (ตั้งแต่ช่วงเวลาหนึ่งนาทีไปจนถึงหลายวัน) งานที่กำหนดเวลาด้วย cron, Routines สำหรับระบบอัตโนมัติที่กำหนดเวลาบนคลาวด์, ฮุควงจรชีวิต หรือ GitHub Actions สำหรับการรันที่อยู่รอดแม้คุณปิดแล็ปท็อป
• Codex: แท็บ Automations เลือกโปรเจกต์ พรอมต์ และจังหวะ ผลลัพธ์จะไปอยู่ในกล่องจดหมาย Triage การรันที่ว่างเปล่าจะเก็บถาวรตัวเอง

สิ่งสำคัญในเซสชันคือ /goal: ทำงานต่อไปในทุกเทิร์นจนกว่าเงื่อนไข ที่คุณเขียน จะเป็นจริงอย่างตรวจสอบได้ เช่น "เทสทั้งหมดใน test/auth ผ่านและ lint สะอาด" แล้วเดินออกไป

1. Worktrees : การแยกสำหรับการทำงานแบบขนาน

Git worktrees ให้เอเจนต์แต่ละตัวมีไดเรกทอรีการทำงานของตัวเองบน branch ของตัวเอง โดยแชร์ประวัติของ repo การแก้ไขจะไม่ชนกันอย่างแท้จริง สิ่งนี้แก้ ปัญหา 4

• Claude Code: git worktree, แฟล็ก --worktree หรือ isolation: worktree บน subagent เพื่อให้ผู้ช่วยแต่ละตัวได้ checkout ที่สดใหม่และทำความสะอาดตัวเองได้
• Codex: worktree ในตัวต่อเธรด

ผู้ใช้ระดับสูงรายงานว่าสามารถรันเอเจนต์แบบขนานได้ 10–15 ตัวด้วยวิธีนี้

1. ทักษะ (Skills) : ความรู้ของโปรเจกต์ที่ถูกบันทึกเป็นรหัส

ทักษะคือโฟลเดอร์ที่มี SKILL.md ซึ่งประกอบด้วยกฎเกณฑ์ของโปรเจกต์ ขั้นตอนการ build และ "เราไม่ทำแบบนี้เพราะเหตุการณ์นั้น" ที่เขียน ครั้งเดียว และเอเจนต์อ่าน ทุกครั้งที่รัน สิ่งนี้แก้ ปัญหา 2 หากไม่มีทักษะ ลูปจะต้องเรียนรู้โปรเจกต์ของคุณจากศูนย์ทุกครั้งในรอบการทำงาน เมื่อมีทักษะ มันจะทวีคูณความรู้

1. ปลั๊กอินและตัวเชื่อมต่อ (MCP) : มือที่จับเครื่องมือจริง

ลูปที่เห็นเฉพาะระบบไฟล์คือลูปที่เล็กมาก ตัวเชื่อมต่อ MCP ช่วยให้มันอ่าน issue tracker ของคุณ สืบค้นฐานข้อมูล เปิด PR อัปเดต Linear ticket และแจ้ง Slack เมื่อ CI ผ่าน นี่คือความแตกต่างระหว่างเอเจนต์ที่ พูดว่า "นี่คือวิธีแก้ไข" กับลูปที่ ส่งมอบ วิธีแก้ไข

1. เอเจนต์ย่อย (Sub-agents) : แยกผู้สร้างออกจากผู้ตรวจสอบ

แนวคิดเชิงโครงสร้างที่สำคัญที่สุดในรูปแบบทั้งหมด เอเจนต์หนึ่งตัว (หรือโมเดล) เขียน; เอเจนต์ อีกตัว ที่มีคำสั่งต่างกันตรวจสอบ สิ่งนี้แก้ ปัญหา 3 /goal ของ Claude Code มีสิ่งนี้ในตัว: โมเดลแยกต่างหากเป็นผู้ให้คะแนนว่าเงื่อนไขการหยุดเป็นจริงหรือไม่ ดังนั้นผู้ทำงานจึงไม่ตรวจการบ้านตัวเอง

• Claude Code: subagents ใน .claude/agents/, ทีมเอเจนต์
• Codex: subagents เป็น TOML ใน .codex/agents/ เช่น โมเดลที่แข็งแกร่งพร้อมความพยายามในการใช้เหตุผลสูงเป็นผู้ตรวจสอบความปลอดภัยของคุณ โมเดลที่อ่านอย่างเดียวที่รวดเร็วเป็นนักสำรวจของคุณ

1. สถานะ (State) : กระดูกสันหลังของหน่วยความจำ

ไฟล์ markdown, บันทึกความคืบหน้า หรือบอร์ด Linear อะไรก็ได้ที่อยู่ ภายนอก การสนทนาและบันทึกสิ่งที่ทำไปแล้วและสิ่งที่ต้องทำต่อไป ฟังดูง่ายเกินไปจนไม่สำคัญ แต่มันเป็นเคล็ดลับเดียวที่เอเจนต์ที่ทำงานระยะยาวทุกตัวพึ่งพา: โมเดลลืมระหว่างการรัน; repo ไม่ลืม สิ่งนี้ยังแก้ ปัญหา 2 ในระดับงาน และเป็นสิ่งที่ทำให้การรันในวันพรุ่งนี้สามารถเริ่มต่อจากจุดที่วันนี้หยุดไว้ได้อย่างแม่นยำ เมื่อรวมกับระบบอัตโนมัติ มันจะสลาย ปัญหา 1 ลูปทำงานในขณะที่คุณหลับ

ลูปจริงๆ หนึ่งอันมีหน้าตาเป็นอย่างไร

นี่คือรูปร่างอ้างอิง (ดัดแปลงจากลูปประจำวันของ Osmani เอง):

1. ระบบอัตโนมัติทำงานบน repo พรอมต์ของมันเรียก ทักษะการคัดแยก ที่อ่านความล้มเหลวของ CI เมื่อวาน issue ที่เปิดอยู่ และ commit ล่าสุด แล้วเขียนผลลัพธ์ลงใน STATE.md
2. สำหรับแต่ละผลลัพธ์ที่คุ้มค่าจะทำ ลูปจะเปิด worktree ที่แยกออกมา และส่ง เอเจนต์ย่อยผู้สร้าง ไปร่างวิธีแก้ไข
3. เอเจนต์ย่อยผู้ตรวจสอบ ตรวจสอบร่างกับทักษะของโปรเจกต์และเทสที่มีอยู่
4. ตัวเชื่อมต่อ เปิด PR เชื่อมโยง ticket และโพสต์ไปยัง Slack
5. สิ่งใดก็ตามที่ลูปจัดการไม่ได้จะตกไปอยู่ในกล่องจดหมาย triage สำหรับ คุณ
6. STATE.md บันทึกสิ่งที่ลองแล้ว สิ่งที่ผ่าน และสิ่งที่ยังเปิดอยู่ การรันในวันพรุ่งนี้จะเริ่มต่อจากจุดนั้น

แหล่งที่มาและอ่านเพิ่มเติม: Addy Osmani, "Loop Engineering" (addyosmani.com); บทความของ The New Stack เกี่ยวกับ loop engineering; การสนทนาข้างกองไฟของ Boris Cherny ที่งาน Scale ของ Meta และบทสัมภาษณ์ CNBC; เอกสาร Claude Code เกี่ยวกับ Routines (code.claude.com/docs/en/routines); เอกสาร OpenAI Codex Automations

ถ้าคุณสร้างลูปจากบทความนี้ ฉันอยากเห็นมาก !! ตอบกลับมาว่าคุณทำให้อะไรเป็นอัตโนมัติก่อน