วิธีรัน Claude Code และ Codex ควบคู่กันบนโค้ดเบสเดียว

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

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

Sharkly ไม่ใช่ตัวแทนของ Claude Code หรือ Codex แต่เพิ่มเลเยอร์ Task, Computer, บริบท และการรีวิวที่ใช้ร่วมกันรอบเครื่องมือที่คุณรันอยู่แล้ว เพื่อให้เซสชัน Claude Code และเซสชัน Codex กลายเป็นสองงานในเวิร์กโฟลว์เดียว แทนที่จะเป็นสองเทอร์มินัลที่คุณต้องคอยเฝ้า

ทำไมคุณถึงอยากใช้ Claude Code และ Codex บนรีโปเดียวกัน

มีสามเหตุผลที่เจอบ่อยครั้ง และแต่ละข้อไม่ใช่ปัญหาเดียวกัน

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

การเทียบกันตรงๆ บนงานจริง มาตรฐานวัดที่ซื่อสัตย์ที่สุดคือโค้ดเบสของคุณ ไม่ใช่ลีดเดอร์บอร์ด การรันทั้งสองตัวบนตั๋วเดียวกันแล้วเทียบ diff บอกอะไรได้มากกว่าคะแนนที่เผยแพร่ เราอธิบายวิธีไว้ใน วิธีเปรียบเทียบเอเจนต์เขียนโค้ดบนโค้ดเบสของคุณเอง

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

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

ขั้นที่ 1: ให้เอเจนต์แต่ละตัวมี worktree ของตัวเอง

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

# One checkout per task, each on its own branch
git worktree add ../app-refactor -b agent/refactor
git worktree add ../app-tests    -b agent/tests

git worktree list

ชี้เครื่องมือที่ต่างกันไปยังแต่ละไดเรกทอรี:

cd ../app-refactor && claude          # Claude Code on the refactor
cd ../app-tests    && codex           # Codex on the test suite

โหมดความล้มเหลวถ้าข้ามขั้นนี้: ทั้งสองเครื่องมือรัน cd เข้าไปในรีโปเดียวกัน แย่งกันบนไฟล์เดียวกัน และตัวหนึ่งเขียนทับงานที่ยังไม่คอมมิตของอีกตัวโดยไม่รู้ตัว Worktrees ทำให้เรื่องนี้เป็นไปไม่ได้ในทางกายภาพ การทำความสะอาด afterward มีจุดที่ต้องระวังเป็นของตัวเอง การจัดการ worktrees โดยไม่ปวดหัวกับการทำความสะอาด ครอบคลุม git worktree remove และปัญหาแบรนช์ค้าง

ขั้นที่ 2: ชี้เครื่องมือแต่ละตัวไปยังคำสั่งที่ถูกต้อง

Claude Code และ Codex อ่านไฟล์โปรเจกต์ต่างกัน Claude Code มองหา CLAUDE.md ส่วน Codex อ่าน AGENTS.md ถ้ารีโปของคุณมีแค่ไฟล์ใดไฟล์หนึ่ง เอเจนต์ตัวหนึ่งจะทำงานโดยไม่รู้ธรรมเนียมปฏิบัติของคุณเลย

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

<!-- CLAUDE.md and AGENTS.md both start with -->
See ./docs/agent-conventions.md for build, test, and style rules.

# Verify each tool actually loads its file before you turn it loose
claude --version   # Claude Code reads CLAUDE.md from the worktree root
codex --version    # Codex reads AGENTS.md from the worktree root

โหมดความล้มเหลวถ้าข้ามขั้นนี้: Codex ทำตามคอนฟิก lint ชุดหนึ่ง ขณะที่ Claude Code ทำตามอีกชุด และทุกการ merge ก็กลายเป็นการทะเลาะเรื่องสไตล์ที่ไม่มีใครจดไว้ หมายเหตุส่วนตัวตรงนี้สำคัญ โทเค็นการติดตั้งไม่ได้พาธรรมเนียมปฏิบัติของคุณไปด้วย และไฟล์โลคัลที่อยู่ใน .gitignore ก็ไม่ได้ตามไปที่ worktree ให้ใส่กฎที่ใช้ร่วมกันไว้ในไฟล์ที่ถูก track ไม่งั้น worktree ใหม่ทุกอันจะเริ่มต้นว่างเปล่า

ขั้นที่ 3: เปิดใช้งาน แล้วดูช่องว่างการประสานงานเปิดออก

ด้วยสอง worktrees และสองไฟล์คอนฟิก กลไกมันทำงานได้ คุณมี Claude Code บนแบรนช์หนึ่งและ Codex บนอีกแบรนช์หนึ่ง โดยไม่แตะไฟล์ของกันและกัน สำหรับหนึ่งบ่ายกับสองเอเจนต์ แค่นี้ก็พอ

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

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

จุดที่สองเทอร์มินัลเริ่มขยายไม่ไหว

บททดสอบที่ซื่อสัตย์ว่าคุณโตเกินเซตอัป DIY หรือยัง:

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

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

นี่คือเส้นแบ่งที่ควรพูดให้ชัด Claude Code และ Codex ทำหน้าที่รัน ส่วนเลเยอร์คำสั่งจัดการการมอบหมาย Computers ที่เชื่อมต่อ บริบทของงาน ความคืบหน้า อุปสรรค ผลลัพธ์ และการรีวิวโดยมนุษย์ในทั้งสองฝั่ง ใน Sharkly คุณมอบหมาย Task หนึ่งให้ Claude Code Runtime และอีกอันให้ Codex Runtime แต่ละอันรันใน worktree ที่แยกออกมาต่างหากบน Computer ที่เชื่อมต่อ และการรัน อุปสรรค และผลลัพธ์จะกลับเข้าสู่ไทม์ไลน์ของ Task แทนที่จะหายไปในเทอร์มินัลส่วนตัว

การแบ่งงานยังคงสะอาด เอเจนต์ค้นคว้า รัน ทดสอบ และรายงาน ส่วนคนกำหนดทิศทาง มอบอำนาจ และรับผลลัพธ์ การทำงานอัตโนมัติหยุดตรงจุดที่ต้องใช้วิจารณญาณของคุณ และส่งคืน diff พร้อมหลักฐานการตรวจสอบแนบมาด้วย คุณยังใช้เครื่องมือที่จ่ายเงินอยู่แล้ว การใช้โมเดลยังคงวิ่งผ่านซับสคริปชันและ API key ที่ตั้งค่าไว้ในแต่ละตัว และคุณได้ที่เดียวที่เห็นว่าใครทำอะไรอยู่

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

เช็กลิสต์ที่คุณรันได้วันนี้

รันตามนี้จากบนลงล่างในครั้งถัดไปที่คุณวางเครื่องมือทั้งสองบนรีโปเดียว:

• [ ] สร้าง git worktree หนึ่งอันต่อหนึ่งงาน แต่ละอันอยู่บนแบรนช์ของตัวเอง ห้ามชี้สองเครื่องมือไปยังไดเรกทอรีเดียวกันเด็ดขาด
• [ ] คอมมิตทั้ง CLAUDE.md และ AGENTS.md โดยแต่ละอันชี้ไปยังไฟล์ธรรมเนียมปฏิบัติที่ใช้ร่วมกันไฟล์เดียวในซอร์สที่ถูก track
• [ ] ยืนยันว่าเครื่องมือแต่ละตัวโหลดคอนฟิกจากรูทของ worktree ก่อนที่คุณจะมอบหมายงาน
• [ ] มอบหมาย Task ที่มีขอบเขตชัดเจนหนึ่งอันต่อเอเจนต์หนึ่งตัว งานที่ต้องใช้บริบทกว้างให้ตัวหนึ่ง งานแคบที่ขับเคลื่อนด้วยเทสต์ให้อีกตัว
• [ ] ตัดสินใจด่านรีวิวไว้ล่วงหน้า ไม่มีแบรนช์ไหน merge จนกว่าคนจะอ่าน diff และผลเทสต์
• [ ] เมื่อคุณรันพร้อมกันเกินสองหรือสามตัว หยุดขยาย bash แล้วย้ายการมอบหมาย สถานะ และการรีวิวไปไว้ในเลเยอร์เดียว

ถ้าคุณอยากใช้ทั้ง Claude Code และ Codex ต่อไปแทนที่จะผูกกับระบบนิเวศเดียว นั่นคือปัญหาที่ Sharkly ถูกออกแบบมาเพื่อแก้ ดาวน์โหลด Sharkly เชื่อมต่อ Computer หนึ่งเครื่อง แล้วมอบหมาย Task แรกของคุณให้เอเจนต์ที่เหมาะกับงาน

คำถามที่พบบ่อย

Claude Code และ Codex แก้ไฟล์เดียวกันได้อย่างปลอดภัยไหม? ไม่ได้ในไดเรกทอรีเดียวกัน ให้แต่ละตัวมี git worktree ของตัวเองเพื่อให้ทำงานบนแบรนช์แยกกัน แล้ว merge ผ่านการรีวิว การทำงานพร้อมกันในไดเรกทอรีเดียวกันคือจุดที่งานที่ยังไม่คอมมิตหายไป

ต้องมีสองซับสคริปชันไหม? คุณต้องมีสิ่งที่แต่ละเครื่องมือต้องการ การใช้โมเดลยังคงวิ่งผ่านซับสคริปชันหรือ API key ที่ตั้งค่าไว้ใน Claude Code และ Codex เลเยอร์การประสานงานไม่ได้เปลี่ยนหรือขายต่อการเข้าถึงนั้น

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