คำตอบแบบสั้น: การแบ่งโปรเจกต์ที่ยากให้ coding agent สองตัวทำงานร่วมกัน ให้แต่ละตัวมีบทบาทที่ผลลัพธ์สามารถตรวจสอบโดยอีกตัวหนึ่งได้: ตัวหนึ่งสำรวจและจดบันทึกสิ่งที่ค้นพบ อีกตัวสร้างงานโดยอ้างอิงจากบันทึกนั้น หรือไม่ก็ให้ทั้งสองตัวลองทำขั้นตอนเดียวกันแล้วคุณเปรียบเทียบผลลัพธ์ เก็บบริบทที่ใช้ร่วมกันไว้ในไฟล์เดียวที่ทั้งสอง agent อ่าน และให้มนุษย์อนุมัติทุกครั้งก่อนการกระทำที่กระทบกับโลกจริง
นักพัฒนาคนหนึ่งมีรถ Jeep Cherokee ปี 1994 ที่ไม่มีพอร์ต OBD2 ซ็อกเก็ตวินิจฉัยมาตรฐานของรถยุคหลัง และในคำพูดของเขาคือ “ไม่มีเครื่องมือสแกนตัวไหนใช้ได้กับมัน” ไม่มีอะไรอ่านคอมพิวเตอร์ของเครื่องยนต์ (ECU) ได้ เขาต่อสาย Arduino Nano ราคา $3 เข้ากับพลักวินิจฉัย แล้วมอบงานให้ coding agent สองตัวคือ Claude Code และ Codex วิดีโอของโปรเจกต์นี้ ได้รับ 450 คะแนนและคอมเมนต์มากกว่า 230 รายการบน Hacker News ในเดือนนี้
สิ่งที่ทีมของคุณนำไปใช้ประโยชน์ได้คือวิธีที่โปรเจกต์ยาก ๆ ที่ไม่คุ้นเคยหนึ่งชิ้นถูกขับเคลื่อนด้วย agent สองตัวที่ต่างกันและมนุษย์หนึ่งคนที่ระมัดระวัง คู่มือนี้จะเปลี่ยนสิ่งนั้นให้เป็นรูปแบบที่นำกลับมาใช้ซ้ำได้ พร้อมชี้ให้เห็นว่า Sharkly เข้ามามีบทบาทอย่างไรเมื่อ agent สองตัวเริ่มใหญ่เกินสองแท็บเทอร์มินัล
โปรเจกต์ Jeep ECU สอนอะไรเรื่องการใช้ coding agent สองตัว
นี่คือสิ่งที่แหล่งข้อมูลระบุไว้ และไม่มีอย่างอื่นเลย ในคำอธิบายวิดีโอ ผู้เขียนเขียนว่าในช่วงประมาณหนึ่งสัปดาห์ agent ทั้งสอง “อ่านคอมพิวเตอร์แบบเรียลไทม์ บันทึกการขับขี่ คัดลอกโปรแกรมทั้งหมดของมัน และรันโค้ดของตัวเองภายในนั้น” รายการบทในวิดีโอระบุว่า Claude เป็นผู้ไขปริศนาเรื่องสายไฟและรันทดสอบปั๊มน้ำมัน ส่วน Codex เป็นผู้รันโค้ดภายในคอมพิวเตอร์ มีหนึ่งบทที่ชื่อว่า “การขับตอนกลางคืน: เครื่องมือให้ค่าผิด”
repository xj-scanner ที่เกิดขึ้นจากโปรเจกต์นี้เป็นสิ่งของที่น่าสนใจกว่า มีสามรายละเอียดที่โดดเด่น:
- ไฟล์คำสั่งเดียวที่ใช้ร่วมกัน
AGENTS.mdเป็นจุดเริ่มต้นสำหรับ “agent ใด ๆ ที่ทำงานใน repo นี้”CLAUDE.mdเป็นข้อความบรรทัดเดียวที่ชี้กลับไปที่ไฟล์นั้น ทำให้ Claude Code และ Codex อ่านกฎชุดเดียวกัน - ความรู้ที่ถูกจดบันทึกไว้ โฟลเดอร์
docs/เก็บ pinout ของพลัก โปรโตคอล และพารามิเตอร์ทุกตัวพร้อมสเกลของมัน ทำให้ agent ตัวถัดไปเริ่มจากสิ่งที่ตัวก่อนหน้าเรียนรู้มา - จุดหยุดให้มนุษย์ตัดสินใจ กฎระบุว่าการอ่านค่าปลอดภัย แต่การลบรหัสข้อผิดพลาด การรีเซ็ต fuel trim และการทดสอบ actuator ที่ “สั่งงานฮาร์ดแวร์จริง” แต่ละอย่างต้องได้รับอนุมัติจากมนุษย์ก่อน
วิดีโอไม่ได้เผยแพร่การแบ่งงานอย่างเป็นทางการ ดังนั้นให้ถือว่าการแบ่งด้านล่างนี้เป็นรูปแบบที่สรุปจากผลลัพธ์ ไม่ใช่บันทึกการทำงานจริงของเขา
เมื่อไรที่โปรเจกต์ที่ยากต้องการ coding agent สองตัว
ใช้สอง agent เมื่องานมีต้นทุนสูงหากมั่นใจผิด งาน reverse engineering, migration, โปรโตคอลที่ไม่คุ้นเคย และการ debug โดยไม่มีเอกสาร ล้วนเข้าข่ายนี้ agent ตัวที่สองที่ใช้โมเดลต่างกันจะให้มุมมองที่เป็นอิสระจากกัน และความเห็นที่ขัดแย้งกันระหว่างสองตัวคือสัญญาณที่คุณนำไปใช้ตัดสินใจได้
ข้าม agent ตัวที่สองไปเมื่องานเล็กและระบุชัดเจน เอกสาร Sharkly เรื่อง Crews กล่าวถึงประเด็นเดียวกันนี้ในบริบทของการประสานงานโดยรวม: มอบงานเล็ก ๆ ที่ชัดเจนให้ Agent เดียว และใช้ทีมเมื่อมีคนต้องตีความเป้าหมายและรวมผลลัพธ์เท่านั้น
สามวิธีในการแบ่งโปรเจกต์ให้ coding agent
เลือกหนึ่งรูปแบบต่อหนึ่งเฟส ไม่ใช่ต่อหนึ่งโปรเจกต์ การค้นคว้า การสร้างงาน และการทดสอบแบบเรียลไทม์ที่มีความเสี่ยง ต่างต้องการการแบ่งที่แตกต่างกัน
| รูปแบบ | Agent A | Agent B | ใช้เมื่อ |
|---|---|---|---|
| นักสำรวจและนักสร้าง | สำรวจ เขียนผลการค้นพบลงไฟล์ | สร้างงานโดยอ้างอิงผลการค้นพบเหล่านั้น | โดเมนไม่รู้จักและเอกสารมีน้อย |
| พยายามอย่างอิสระสองทาง | แก้ขั้นตอนนั้นเอง | แก้ขั้นตอนเดียวกันเอง | คำตอบที่ผิดมีต้นทุนสูงและตรวจจับยาก |
| นักสร้างและผู้ตรวจ | เขียนการเปลี่ยนแปลง | ตรวจสอบกับสเปกและข้อมูล | การเปลี่ยนแปลงชัดเจนแต่ความเสี่ยงสูง |
นักสำรวจและนักสร้าง: ใครเขียนแผนที่?
ผลลัพธ์ของนักสำรวจคือเอกสาร ไม่ใช่โค้ด ใน xj-scanner ก็คือโฟลเดอร์ docs/: ขั้วต่อที่วัดทีละช่อง โปรโตคอล และตารางพารามิเตอร์ นักสร้างทำงานจากไฟล์นั้นและไม่ต้องค้นพบ pinout ซ้ำ หากนักสร้างเจอข้อมูลที่ขัดแย้งกัน มันจะอัปเดตเอกสาร ทำให้แผนที่ยังเป็นแหล่งความจริงเดียวอยู่
พยายามอย่างอิสระสองทาง: เปรียบเทียบกันอย่างไร?
ให้ agent ทั้งสอง prompt เดียวกันและ input เดียวกัน และไม่ให้ตัวใดเห็นคำตอบของอีกตัว จากนั้นเปรียบเทียบผลลัพธ์กับข้อมูลที่คุณเชื่อถือได้ สำหรับตัวถอดรหัสโปรโตคอล หมายความว่าป้อน log ที่บันทึกไว้ชุดเดียวกันให้ทั้งสองแล้ว diff ค่าที่ถอดออกมา เรากล่าวถึงการตั้งค่าที่เป็นธรรมสำหรับเรื่องนี้ใน Claude Code vs Codex บนบั๊กเดียวกัน
นักสร้างและผู้ตรวจ: ผู้ตรวจตรวจอะไร?
ผู้ตรวจตรวจสอบข้อกล่าวอ้างกับหลักฐาน ไม่ใช่ตรวจสไตล์ “fuel trim อ่านได้ +40%” เป็นข้อกล่าวอ้าง ผู้ตรวจจะถามว่าสูตรการสเกลถูกต้องหรือไม่ก่อนที่ใครจะนำไปใช้ กฎของ xj-scanner สะท้อนเรื่องนี้: “ค่าที่อ่านแล้วดูผิดอาจเป็นเพราะลักษณะการสเกล” คู่มือของเราเรื่อง mixed-model Crews ที่มีผู้ตรวจแยกต่างหาก อธิบายการจับคู่ worker ที่ถูกกว่ากับผู้ตรวจที่แข็งแกร่งกว่าอย่างละเอียดกว่านี้
coding agent สองตัวส่งต่อบริบทให้กันอย่างไร
Agent ไม่ได้แชร์หน่วยความจำร่วมกัน ดังนั้นการส่งมอบงานต้องอาศัยไฟล์และบันทึกงาน มีสี่ชิ้นที่แบกรับภาระส่วนใหญ่:
- ไฟล์คำสั่งหนึ่งไฟล์ที่ทั้งสอง agent อ่าน AGENTS.md เป็นฟอร์แมตเปิดที่ Codex อ่าน Claude Code อ่าน
CLAUDE.mdและเอกสารเรื่อง memory ของมันอธิบายการ import ไฟล์อื่น การใช้CLAUDE.mdบรรทัดเดียวที่ชี้ไปที่AGENTS.mdทำให้ทั้งสองอยู่บนกฎชุดเดียวกัน - เอกสารผลการค้นพบแยกตามโดเมน pinout, โปรโตคอล และลักษณะเฉพาะต่าง ๆ ไปไว้ใน
docs/ไม่ใช่ในประวัติแชทที่หายไป - log เป็นหลักฐานร่วม xj-scanner เขียนข้อมูลการขับทุกครั้งลง
pc/logs/เป็น CSV ทำให้ agent ตัวใดก็ได้วิเคราะห์การรันเดียวกัน - โน้ตส่งมอบงานต่อหนึ่งขั้นตอน สิ่งที่ลองแล้ว สิ่งที่ได้ผล สิ่งที่ยังไม่ได้ตรวจสอบ และคำสั่งถัดไป
โน้ตส่งมอบงานสามารถสั้นแค่นี้ได้ (ค่าตัวอย่าง ไม่ได้มาจาก repo ของ Jeep):
## Handoff: SCI read of live sensor data
- Done: Nano bridge sketch flashed, DEMO mode passes on the laptop side
- Confirmed: cavities 2 (ground), 3, 4 measured with key ON
- Unverified: fuel trim scaling; reading looks high on idle
- Next: Codex decodes pc/logs/xj_2026-11-03.csv with both scaling formulas
- Needs a human: any actuator test or code erase
สำหรับฟอร์แมตเพิ่มเติม ดู เทมเพลตส่งมอบงานสำหรับ coding agent ของเรา และคู่มือ การรักษาบริบทเมื่อสลับระหว่าง coding agent
มนุษย์ตรวจสอบผลลัพธ์ตรงจุดไหน
ให้มนุษย์อยู่ทุกขั้นตอนที่ย้อนกลับได้ยาก และไม่ต้องอยู่ที่อื่นเลย กฎของ xj-scanner เป็นเทมเพลตที่สะอาด:
- ก่อนทำอะไรที่กระทบกับสิ่งมีอยู่จริง “ห้ามให้มีอะไรถูกเชื่อมต่อกับช่องไฟ 12 V เด็ดขาด” มนุษย์ต้องวัดทุกช่องก่อน
- ก่อนรันคำสั่งที่ทำลายข้อมูล การลบรหัสยังล้างข้อมูล fuel ที่ระบบเรียนรู้ไว้ด้วย ดังนั้น agent ต้องถามและอธิบาย
- ก่อนเชื่อการวินิจฉัย “อย่าเดาการวินิจฉัย รายงานสิ่งที่ข้อมูลแสดงและสิ่งที่ข้อมูลไม่ได้แสดง”
- หลังเกิดเรื่องไม่คาดคิด บทการขับตอนกลางคืนบอกว่าเครื่องมือให้ค่าผิด ข้อมูลจากโลกจริงคือการตรวจสอบที่ไม่มี agent ตัวใดข้ามได้
กฎเดียวกันนี้ใช้กับทีมซอฟต์แวร์ด้วย การ merge เข้า main, schema migration และสิ่งใดก็ตามที่ส่งอีเมลหรือใช้เงิน ต้องมีด่านอนุมัติจากมนุษย์ ส่วนที่เหลือสามารถไหลระหว่าง agent ได้ ถ้าการ review เป็นคอขวดของคุณอยู่แล้ว อ่าน การออกแบบ review สำหรับ agent แบบขนาน
การรันรูปแบบสอง agent ใน Sharkly
ในเทอร์มินัล การแบ่งงานอยู่ในหัวคุณ: แท็บไหนรัน agent ตัวไหน และใครกำลังรอคุณอยู่ Sharkly ย้ายสิ่งนี้ไปไว้บน task
คุณเชื่อมต่อ Computer แล้ว Sharkly จะตรวจจับเครื่องมือ agent บนเครื่องนั้นเป็น Runtimes เช่น Claude Code และ Codex คุณสร้าง Agent หนึ่งตัวต่อหนึ่งบทบาท จากนั้นสร้าง Crew: Agent หัวหน้าบวกกับ Agent นักสำรวจ นักสร้าง หรือผู้ตรวจ และ People ที่ทำหน้าที่อนุมัติ
มอบ task ให้ Crew แล้วการทำงานจะรันโดยเริ่มจากหัวหน้าก่อน ตามเอกสาร Crews หัวหน้าอ่าน task และคำสั่งของ Crew ระบุ Agent สมาชิกที่ต้องการ และสมาชิกเหล่านั้นจะทำงานกับ task เดียวกันและโพสต์ผลลัพธ์ไปยังแชทของ task นั้น หัวหน้ารวมผลลัพธ์เข้าด้วยกัน คำอธิบายบทบาทของคุณกลายเป็นคำสั่งของ Crew: ควรเรียกผู้ตรวจเมื่อไร จะรวมผลจากสองความพยายามอย่างไร และเมื่อไรที่มนุษย์ต้องตัดสินใจ
มีสองรายละเอียดที่สำคัญสำหรับรูปแบบนี้ งานที่เกี่ยวกับ repository สามารถใช้ git worktree แยกกันต่อหนึ่งการรัน ทำให้สอง agent ที่พยายามทำขั้นตอนเดียวกันไม่เขียนทับกัน (เอกสารการรัน task) และทุกการรันมีสถานะใน execution log ของ task ทำให้คุณเห็นว่า agent ตัวใดกำลังรอคิว กำลังรัน หรือเสร็จแล้ว โดยไม่ต้องเปิดเทอร์มินัล
ทางเลือกอื่นแทน Crew สอง agent
คุณมีตัวเลือกอื่น และบางตัวอาจเหมาะกว่า:
- หนึ่ง agent สองรอบ ให้ agent ตัวเดิมสร้างงานก่อน แล้ว review ใน session ใหม่ ถูกกว่า แต่โมเดลเดิมมักทำซ้ำจุดอ่อนของตัวเอง
- สองเทอร์มินัล หนึ่ง repo ร่วม ใช้ได้กับโปรเจกต์สุดสัปดาห์อย่าง Jeep แต่จะตามได้ยากเมื่อมีหลาย task และมีเพื่อนร่วมทีม ดู การรัน Claude Code และ Codex ร่วมกันบน codebase เดียว
- agent แบบขนานบน task แยกกัน มีประโยชน์ด้าน throughput ไม่ใช่การตรวจสอบกันและกัน ระวังสอง agent แก้ไขไฟล์เดียวกัน
บทสรุป
โปรเจกต์ Jeep สำเร็จเพราะความรู้อยู่ในไฟล์ ทั้งสอง agent อ่านกฎชุดเดียวกัน และมนุษย์ยืนขวางการกระทำที่มีความเสี่ยงทุกอย่าง ลอกทั้งสามนิสัยนี้มาใช้ แล้ว coding agent สองตัวจะกลายเป็นเครื่องมือตรวจสอบกันและกัน แทนที่จะเป็นสองแหล่งของการเดาแบบมั่นใจ
ก้าวต่อไป: เลือกงานที่ยากหนึ่งงานในสัปดาห์นี้ เขียนกฎ AGENTS.md และโน้ตส่งมอบงานของมัน แล้วรันเป็น Crew ใน Sharkly โดยมี Agent ผู้ตรวจและมนุษย์ทำหน้าที่อนุมัติ
คำถามที่พบบ่อย
Claude Code และ Codex ทำงานบนโปรเจกต์เดียวกันได้ไหม?
ได้ ทั้งสองอ่านไฟล์คำสั่งใน repo: Codex อ่าน AGENTS.md และ Claude Code อ่าน CLAUDE.md ซึ่งสามารถชี้ไปที่ AGENTS.md ได้ ให้แต่ละตัวมี worktree แยกกันหรือทำขั้นตอนแยกกัน เพื่อไม่ให้แก้ไขไฟล์เดียวกันพร้อมกัน
coding agent แชร์บริบทกันอย่างไร?
ผ่านไฟล์และบันทึกงาน ไม่ใช่ผ่านหน่วยความจำ เก็บกฎไว้ใน AGENTS.md ผลการค้นพบไว้ในโฟลเดอร์ docs ข้อมูลดิบไว้ใน log และโน้ตส่งมอบงานสั้น ๆ ต่อหนึ่งขั้นตอน
มนุษย์ควรอนุมัติงานของ agent ตรงจุดไหน?
ก่อนทำสิ่งที่ย้อนกลับได้ยาก: การกระทำกับฮาร์ดแวร์ คำสั่งที่ทำลายข้อมูล การ merge เข้า main, migration และสิ่งใดก็ตามที่ส่งข้อความหรือใช้เงิน ส่วนที่เหลือให้ไหลระหว่าง agent ไป
Claude Code และ Codex reverse engineer ECU ของ Jeep เองทั้งหมดหรือ?
ไม่ใช่ นักพัฒนาเป็นผู้ต่อสาย วัดค่า และขับรถ และกฎของ repo กำหนดให้ต้องได้อนุมัติจากมนุษย์ก่อนรันคำสั่งที่มีความเสี่ยง agent เป็นผู้อ่านคอมพิวเตอร์ บันทึกการขับ คัดลอกโปรแกรมของมัน และรันโค้ดภายในนั้น
จำเป็นต้องมีแพลตฟอร์มในการรัน coding agent สองตัวไหม?
ไม่จำเป็น สองเทอร์มินัลและ repo ร่วมใช้ได้กับโปรเจกต์เดียว แพลตฟอร์มเริ่มคุ้มค่าเมื่อมีหลาย task เพื่อนร่วมทีม และการอนุมัติกำลังดำเนินอยู่พร้อมกัน และคุณต้องการบันทึกรวมชิ้นเดียวว่าใครทำอะไร



