Learn Harness Engineering เป็นคอร์สฟรีจากทีม walkinglabs สำหรับคนที่ใช้ AI coding agent อย่าง Claude Code หรือ Codex เขียนโค้ดและรันคำสั่งบนโปรเจกต์จริง โดยเนื้อหาเริ่มต้นจากปัญหาที่คุณอาจเคยเจอกับตัว

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

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

ทางคอร์สชี้ให้เห็นว่า ปัญหานี้ไม่ได้เกิดจากโมเดล AI ไม่ฉลาด แต่เป็นปัญหาเรื่อง "harness" ซึ่งหมายถึงสภาพแวดล้อมและระบบควบคุมรอบตัว agent ทั้งหมด ตั้งแต่โครงสร้างไฟล์คำสั่ง บันทึกความคืบหน้า ไปจนถึงชุดตรวจสอบผลงาน

harness เป็นสิ่งที่เราสร้างขึ้นเองเพื่อควบคุม agent ในโปรเจกต์ของตัวเองได้ คอร์สนี้สอนตั้งแต่ศูนย์ผ่าน 14 บทเรียน พร้อม 8 โปรเจกต์ที่ให้ agent ลงมือทำงานจริง ส่วนใครที่ยังไม่พร้อมเรียนทั้งคอร์ส ก็มีไฟล์เทมเพลต 4 ไฟล์ให้หยิบไปวางในโปรเจกต์แล้วเริ่มใช้ได้ทันที

โมเดลตัวเดียวกัน ต่างกันแค่ harness

หลักฐานสำคัญที่คอร์สนี้ยกมาอ้างอิง คือผลการทดลองของ Anthropic บริษัทผู้พัฒนา Claude โดยทีมงานใช้โมเดล Opus 4.5 ตัวเดียวกัน สั่งด้วยพรอมต์เดียวกันเป๊ะว่า "สร้างเครื่องมือทำเกม 2D สไตล์ย้อนยุค" แล้วทดสอบเปรียบเทียบกัน 2 รูปแบบ:

• แบบไม่มี harness: เสียค่าใช้จ่าย 9 ดอลลาร์ ใช้เวลาไป 20 นาที แต่ได้ผลงานที่เปิดใช้งานจริงไม่ได้เลย
• แบบมี harness เต็มรูปแบบ: วางระบบแยกหน้าที่ชัดเจน ทั้งตัววางแผน ตัวลงมือเขียนโค้ด และตัวตรวจงาน วิธีนี้เสียค่าใช้จ่าย 200 ดอลลาร์ ใช้เวลา 6 ชั่วโมง แต่ได้ตัวเกมที่เล่นได้จริง

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

ทางฝั่ง OpenAI ก็รายงานผลลัพธ์ไปในทิศทางเดียวกันจากการทดสอบ Codex กล่าวคือ เมื่อโปรเจกต์วางระบบ harness ไว้อย่างดี โมเดลตัวเดิมจะเปลี่ยนจากเครื่องมือที่ไว้ใจไม่ได้ มาเป็นเครื่องมือที่พึ่งพาได้จริง และยกระดับคุณภาพขึ้นมาคนละชั้น ไม่ใช่แค่ดีขึ้นเพียงเล็กน้อย

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

harness ไม่ใช่แค่พรอมต์ที่ยาวขึ้น

คำว่า harness อาจฟังดูเป็นนามธรรม แต่ในทางปฏิบัติไม่ได้อยู่ในช่องพิมพ์พรอมต์ แต่อยู่ในตัวโปรเจกต์ของเรา ในรูปของไฟล์และขั้นตอนการทำงานที่เป็นรูปธรรม โดยคอร์สนี้แบ่ง harness ออกเป็น 5 ส่วนสำคัญ ซึ่งแต่ละส่วนมีหน้าที่รับผิดชอบชัดเจน:

ส่วนที่พลาดง่ายคือ Instructions เพราะการรวมกฎทุกอย่างไว้ในไฟล์เดียวดูครบถ้วนและเป็นระเบียบดี แต่คอร์สนี้สอนแนวทางตรงกันข้าม คือให้แตกคำสั่งออกเป็นไฟล์ย่อยๆ แล้วให้ agent ดึงมาอ่านเฉพาะส่วนที่ต้องใช้ตอนนั้น ถึงขั้นมีบทเรียนเต็มๆ หนึ่งบทที่อธิบายว่าทำไมไฟล์คำสั่งขนาดยักษ์เพียงไฟล์เดียวถึงไม่เวิร์กในทางปฏิบัติ

หลักการนี้ตรงกับแนวทางของ agent ระดับโปรดักชันในปัจจุบัน โดยคอร์สได้เพิ่มเนื้อหาใหม่ที่แกะสถาปัตยกรรม harness ของทั้ง Pi, Claude Code, Codex และ DeepSeek มาให้ดูทีละตัว ตัวอย่างที่เห็นภาพชัดที่สุดคือ Codex ซึ่งใช้ไฟล์ AGENTS.md เป็นเพียงหน้าสารบัญ แล้วให้ agent อ่านรายละเอียดจากไฟล์ในโปรเจกต์เป็นแหล่งข้อมูลหลักเพียงแหล่งเดียว

1 session ที่ agent ต้องพิสูจน์ผลงานก่อนบอกว่าเสร็จ

องค์ประกอบทั้ง 5 ส่วนนี้รวมกันเป็นขั้นตอนประจำที่ agent ต้องทำตามทุกครั้งที่เปิด session ใหม่ โดยคอร์สแบ่งออกเป็น 4 ช่วง:

1. เตรียมความพร้อม: อ่าน AGENTS.md หรือ CLAUDE.md แล้วรันสคริปต์ init.sh เพื่อติดตั้ง dependency ที่จำเป็นและตรวจความพร้อมของระบบ จากนั้นอ่าน claude-progress.md เพื่อดูว่ารอบก่อนหน้าทำค้างไว้ตรงไหน เช็ก feature_list.json เพื่อดูว่าอะไรเสร็จแล้วและอะไรเป็นคิวถัดไป แล้วดูประวัติการแก้โค้ดล่าสุดใน git log ว่ามีส่วนไหนเปลี่ยนไปบ้าง
2. เลือกงาน: หยิบฟีเจอร์ที่ยังทำไม่เสร็จขึ้นมาเพียงชิ้นเดียว แล้วโฟกัสกับงานนั้นอย่างเดียว
3. ลงมือทำและตรวจทาน: เขียนโค้ดฟีเจอร์แล้วรันชุดทดสอบทันที ถ้าไม่ผ่านก็แก้แล้วรันใหม่จนกว่าจะผ่าน เมื่อผ่านแล้วจึงเก็บผลการทดสอบไว้เป็นหลักฐาน
4. สรุปและส่งต่องาน: อัปเดตบันทึกความคืบหน้าและรายการฟีเจอร์ จดสิ่งที่ยังติดขัดหรือยังไม่ได้ตรวจสอบ แล้วค่อย git commit เฉพาะตอนที่มั่นใจว่าระบบอยู่ในสภาพที่ปลอดภัยพอให้รอบถัดไปมาทำต่อได้

จุดสำคัญที่สุดที่คอร์สชี้ให้เห็นคือขั้นตอนการตรวจงานในช่วงลงมือทำ ถ้าไม่มี harness ตัว agent มักจะคิดและสรุปเอาเองว่า "โค้ดดูเรียบร้อยดี" แต่ถ้ามี harness ตัวชี้วัดจะเปลี่ยนเป็นผลลัพธ์จริง คือชุดทดสอบต้องรันผ่านทั้งหมด ส่วนเครื่องมือตรวจโค้ดอย่าง lint และ type-check ต้องไม่แจ้งเตือนข้อผิดพลาดใดๆ คำว่า "งานเสร็จ" จึงไม่ได้ขึ้นอยู่กับความรู้สึกของ agent แต่เปลี่ยนเป็นผลลัพธ์จริงที่สามารถรันซ้ำเพื่อพิสูจน์ได้ทุกเมื่อ

ผลของการสรุปส่งต่องานจะเห็นชัดตอนเริ่ม session ถัดไป ตัว agent จะอ่านบันทึกความคืบหน้าแล้วทำงานที่ค้างต่อจากจุดเดิมได้ทันที หน้าที่ของเราจึงเปลี่ยนจากคนคอยตามแก้ปัญหา มาเป็นคนตรวจรับงานที่มีคุณภาพ

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

4 ไฟล์ที่หยิบไปวางในโปรเจกต์ได้ตั้งแต่วันนี้

เราไม่จำเป็นต้องรอเรียนจนครบทั้ง 14 บทถึงจะได้ประโยชน์ ถ้าคุณใช้ coding agent กับโปรเจกต์จริงอยู่แล้ว ทางคอร์สมีทางลัดให้ โดยสามารถคัดลอกไฟล์เทมเพลต 4 ไฟล์จากคลังเทมเพลตของคอร์ส มาวางไว้ที่โฟลเดอร์ชั้นนอกสุดหรือ root ของโปรเจกต์ได้ทันที:

โปรเจกต์ของคุณ/
├── AGENTS.md            # คู่มือการทำงานของ agent (หากใช้ Claude Code สามารถใช้ชื่อ CLAUDE.md แทนได้)
├── init.sh              # สคริปต์ติดตั้ง ตรวจสอบสภาพแวดล้อม และเตรียมระบบให้พร้อม
├── feature_list.json    # รายการฟีเจอร์ทั้งหมด พร้อมระบุสถานะว่าตัวไหนเสร็จแล้วบ้าง
├── claude-progress.md   # บันทึกความคืบหน้าในแต่ละ session
└── src/                 # ซอร์สโค้ดของโปรเจกต์

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

จุดที่พลาดง่ายคือชื่อไฟล์ claude-progress.md ที่อาจฟังดูเหมือนออกแบบมาเพื่อ Claude Code เท่านั้น แต่จริงๆ แล้วเป็นไฟล์บันทึกกลางที่คงชื่อเดิมไว้ให้ตรงกับตัวอย่างในคอร์ส สามารถนำไปใช้กับ Codex หรือ agent ตัวอื่นได้ตามปกติ

ข้อควรระวังอีกเรื่องคือ ไม่มี agent ตัวไหนอัปเดต claude-progress.md ให้เองโดยอัตโนมัติ เราต้องเขียนกำกับไว้ในไฟล์คู่มืออย่างชัดเจนว่าให้เปิดอ่านไฟล์นี้ตอนเริ่มรอบ และอัปเดตก่อนส่งต่องานทุกครั้ง ถ้าไม่เขียนไว้ agent ก็จะไม่หยิบไฟล์นี้มาใช้ อย่างน้อย AGENTS.md ควรมีข้อความประมาณนี้

## เริ่ม session
- รัน init.sh
- อ่าน claude-progress.md และ feature_list.json ก่อนเริ่มแตะโค้ด
- เลือกทำฟีเจอร์ที่ยังไม่เสร็จเพียงตัวเดียวเท่านั้น

## ก่อนจบ session
- ถือว่างานเสร็จสมบูรณ์เมื่อรัน test ผ่านทั้งหมดเท่านั้น
- อัปเดตความคืบหน้าลงใน claude-progress.md และ feature_list.json
- จดบันทึกสิ่งที่ยังติดขัดหรือยังไม่ได้ตรวจสอบ

audit-harness.sh กับ harness-creator ใช้ได้ทันทีโดยไม่ต้องเรียนก่อน

ถ้าต้องการประเมินก่อนว่าโปรเจกต์เดิมที่มีอยู่ขาดตกบกพร่องตรงไหนบ้าง ทางคอร์สได้เตรียมสคริปต์ audit-harness.sh มาช่วยสแกนโปรเจกต์เทียบกับองค์ประกอบทั้ง 5 ส่วนของ harness ให้โดยอัตโนมัติ สคริปต์นี้ไม่จำเป็นต้องติดตั้ง Node.js เพียงแค่เปลี่ยน /path/to/your/repo เป็นที่อยู่โฟลเดอร์โปรเจกต์ของคุณ แล้วรันคำสั่งนี้ได้ทันที:

curl -fsSL https://raw.githubusercontent.com/walkinglabs/learn-harness-engineering/main/tools/audit-harness.sh | bash -s -- /path/to/your/repo

สคริปต์จะถือว่าโปรเจกต์ผ่านเกณฑ์ ก็ต่อเมื่อรายการตรวจสอบระดับสำคัญสูงสุดอย่าง CRITICAL ผ่านครบทุกข้อเท่านั้น

แต่วิธีรันข้างต้นเป็นการดึงสคริปต์จากอินเทอร์เน็ตมารันโดยตรง แม้จะสะดวกรวดเร็วที่สุด แต่เราไม่ได้ตรวจดูโค้ดข้างในก่อน ถ้าคำนึงถึงความปลอดภัย อีกทางเลือกหนึ่งคือ clone โปรเจกต์มาไว้ในเครื่อง เพื่อตรวจดูเนื้อหาของสคริปต์ก่อน แล้วค่อยสั่งรันจากโฟลเดอร์ของคอร์ส:

git clone https://github.com/walkinglabs/learn-harness-engineering
cd learn-harness-engineering
bash tools/audit-harness.sh /path/to/your/repo

สำหรับใครที่ต้องการวางโครงสร้าง harness ทั้งชุดโดยไม่อยากเริ่มร่างไฟล์เปล่าขึ้นมาเอง ทางคอร์สก็มี harness-creator เป็น skill เสริมสำหรับ agent ที่ช่วยสร้างไฟล์ AGENTS.md รายการฟีเจอร์ สคริปต์ init.sh ตลอดจนขั้นตอนตรวจสอบงานให้โปรเจกต์ของคุณได้โดยอัตโนมัติภายในเวลาไม่กี่นาที

8 โปรเจกต์กับ 1 แอป ที่โตไปพร้อมทักษะของคุณ

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

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

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

โค้ดเฉลยของแต่ละโปรเจกต์จะกลายมาเป็นจุดเริ่มต้นของโปรเจกต์ถัดไป ตัวแอปพลิเคชันจึงค่อยๆ สมบูรณ์ขึ้นทีละขั้น ควบคู่ไปกับทักษะการสร้าง harness ของเราที่พัฒนาขึ้นตามลำดับ

เนื้อหาคอร์สแบ่งออกเป็น 8 ช่วงหลัก ถ้าจัดเวลาเรียนสัปดาห์ละช่วงก็จะใช้เวลาราว 8 สัปดาห์ แต่ถ้าต้องการเร่งให้เร็วขึ้น ก็สามารถจัดเวลาเก็บ 3 ช่วงแรกให้จบได้ภายในช่วงวันหยุดยาว:

• ช่วงที่ 1-3 มองเห็นปัญหาและวางรากฐาน: เริ่มต้นด้วยการเปรียบเทียบระหว่างการสั่งด้วยพรอมต์ล้วนๆ กับการวางกฎเกณฑ์ก่อนเริ่มงาน จากนั้นจัดโครงสร้างโปรเจกต์ให้ agent เข้าใจได้ง่าย และวางระบบให้ส่งต่องานข้าม session ได้อย่างต่อเนื่อง
• ช่วงที่ 4-6 ควบคุมขอบเขตและตรวจสอบงาน: กำหนดขอบเขตงานให้ชัดเจน ใช้ผลลัพธ์ระหว่างรันมาปรับพฤติกรรมของ agent ฝึกให้ agent ตรวจสอบงานของตัวเองก่อนส่งมอบงาน และปิดท้ายด้วยโปรเจกต์ที่ 6 ซึ่งเป็นการประกอบส่วนต่างๆ ของ harness เข้าด้วยกันอย่างครบวงจร
• ช่วงที่ 7-8 พัฒนาสู่ระบบอัตโนมัติ: เปลี่ยนจากการนั่งพิมพ์สั่ง agent ทีละครั้ง มาเป็นการออกแบบระบบให้มันวนลูปทำงานได้เอง แล้วแปลงขั้นตอนการทำงานทั้งหมดให้เป็นกราฟแสดงลำดับงาน

เลิกนั่งพิมพ์สั่ง แล้วเปลี่ยนมาออกแบบลูปแทน

บทที่ 13 เจาะลึกเรื่อง loop engineering หรือการออกแบบระบบให้ agent วนทำงานได้เองอย่างต่อเนื่องโดยที่เราไม่ต้องคอยพิมพ์สั่งทุกรอบ บทนี้ไล่เรียงตั้งแต่องค์ประกอบพื้นฐาน 6 ประการของลูป การแยกบทบาทระหว่าง agent ตัวลงมือทำและตัวตรวจสอบงาน ไปจนถึงต้นทุนแฝง 4 ด้านที่ต้องคำนึงถึงเมื่อปล่อยให้ระบบทำงานแบบอัตโนมัติ

ในโปรเจกต์ที่ 7 เราจะได้สร้างลูป 3 รูปแบบ โดยไล่ระดับจากง่ายไปยาก ได้แก่ ลูปที่ทำงานตามเป้าหมาย ลูปที่ทำงานตามรอบเวลา และลูปที่แยกตัวทำงานกับตัวตรวจงานออกจากกัน ซึ่งรูปแบบสุดท้ายนี้แบ่งหน้าที่คล้ายกับ harness ในการทดลองของ Anthropic จากนั้นจึงนำมาเปรียบเทียบกับการสั่งงานด้วยตัวเอง เพื่อดูว่าเราลดภาระที่ต้องเข้าไปคอยคุมงานลงได้มากแค่ไหน

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

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

ต้องมี agent ที่ใช้งานได้จริงก่อนลงมือ

คอร์สนี้ออกแบบมาเพื่อให้ลงมือปฏิบัติจริง ไม่ใช่แค่อ่านทฤษฎีผ่านตา สิ่งที่ต้องมีคือ AI coding agent อย่างน้อย 1 ตัวที่แก้ไขไฟล์ รันคำสั่งในเทอร์มินัล และทำงานต่อเนื่องหลายขั้นตอนได้ เช่น Claude Code หรือ Codex

นอกจากนี้ คุณควรคุ้นเคยกับการใช้ terminal และ git มาก่อน สามารถอ่านและเขียนโค้ดได้อย่างน้อยหนึ่งภาษาที่ใช้พัฒนาแอปพลิเคชันทั่วไป รวมถึงเคยไล่หาบั๊กจากไฟล์ log และผลการรันชุดทดสอบมาบ้าง สำหรับคนที่ไม่มี agent ก็ยังอ่านเนื้อหาเพื่อทำความเข้าใจหลักการได้ แต่จะไม่สามารถทำโปรเจกต์จริงให้สำเร็จตามที่คอร์สวางไว้

ทางคอร์สระบุไว้อย่างตรงไปตรงมาว่า หลักสูตรนี้ไม่เหมาะกับผู้ที่มองหาบทเรียน AI แบบไม่ต้องเขียนโค้ด คนที่สนใจเพียงเทคนิคการเขียนพรอมต์แต่ไม่ได้คิดจะสร้างระบบจริง หรือคนที่ยังไม่พร้อมเปิดสิทธิ์ให้ agent รันงานในสภาพแวดล้อมของโปรเจกต์จริง ส่วนกลุ่มเป้าหมายของคอร์สมีสามกลุ่ม คือผู้ที่ใช้ coding agent อยู่แล้วและต้องการให้งานเสถียรและมีคุณภาพขึ้น คนที่อยากเข้าใจการออกแบบ harness อย่างเป็นระบบ และ Technical Lead หรือหัวหน้าทีมสายเทคนิคที่ต้องเข้าใจว่าการวางสภาพแวดล้อมมีผลต่องานของ agent อย่างไร

ปัจจุบันเนื้อหามีฉบับแปลไปแล้วถึง 15 ภาษา แม้จะยังไม่มีภาษาไทย แต่ก็เลือกอ่านเป็นภาษาอังกฤษหรือภาษาอื่นที่สะดวกได้ โดยเนื้อหาทั้งหมดเปิดให้อ่านและนำไปใช้ฟรีภายใต้สัญญาอนุญาตแบบเปิดอย่าง MIT License

มาถึงตรงนี้ ทางเลือกในการเริ่มต้นมีอยู่ 2 แนวทาง: ถ้าคุณมีโปรเจกต์ที่ใช้ agent อยู่แล้ว การนำเทมเพลต 4 ไฟล์และสคริปต์ตรวจสอบไปติดตั้ง ก็เป็นทางลัดที่เริ่มได้เร็วที่สุด แต่ถ้าคุณต้องการออกแบบ harness ให้ตอบโจทย์เฉพาะทางของโปรเจกต์ตัวเอง แทนที่จะแค่คัดลอกไฟล์แม่แบบมาวาง การสละเวลาลงมือเรียนตามลำดับเนื้อหาจะช่วยให้เห็นภาพชัดเจนที่สุด เพราะแต่ละช่วงออกแบบมาให้ต่อยอดกันอย่างเป็นขั้นตอน

และถ้าย้อนนึกถึงการทดลองของ Anthropic บทเรียนสำคัญคือ เงินก้อนที่แพงที่สุดอาจไม่ใช่ 200 ดอลลาร์ที่เราจ่ายเพื่อแลกกับผลงานที่ใช้งานได้จริง แต่คือ 9 ดอลลาร์ที่จ่ายไปแล้วได้เพียงโค้ดพังๆ ที่นำไปใช้อะไรไม่ได้เลย

ที่มา: โปรเจกต์ Learn Harness Engineering บน GitHub