สายผลิตภัณฑ์ Claude Opus ของ Anthropic (Opus 4 / Claude Opus 4.1) และ GPT-5 ของ OpenAI แสดงให้เห็นถึงประสิทธิภาพที่ล้ำสมัยบนเกณฑ์มาตรฐานการเขียนโค้ดสมัยใหม่ แต่ทั้งสองก็แลกจุดแข็งกัน: Opus เน้นเวิร์กโฟลว์แบบเอเจนต์หลายขั้นตอนและครอบคลุมบริบทระยะยาว ขณะที่ GPT-5 เน้นการปรับปรุงส่วนหน้า (front-end) หลักสรีรศาสตร์สำหรับนักพัฒนา และการผสานรวมผลิตภัณฑ์ที่หลากหลาย ตัวเลือกที่ดีที่สุดขึ้นอยู่กับงานที่คุณต้องการให้ทำงานอัตโนมัติ (การสร้างไฟล์เดียวเทียบกับการรีแฟกเตอร์หลายไฟล์) ข้อจำกัดด้านต้นทุน/ทรูพุตของคุณ และวิธีที่คุณจะวัด "ความสำเร็จ" (การผ่านการทดสอบยูนิต ความถูกต้องของรันไทม์ หรือค่าใช้จ่ายในการตรวจสอบโดยมนุษย์)
เหตุใดคำถามนี้จึงสำคัญตอนนี้
ผู้จำหน่ายทั้งสองรายได้เปิดตัวรุ่นหลักในช่วงต้นเดือนสิงหาคม 2025 โดย Anthropic ได้ประกาศเปิดตัว Claude Opus 4.1 (5 สิงหาคม 2025) ในฐานะการปรับปรุงแบบวนซ้ำที่เน้นงานเชิงเอเจนต์และ "การเขียนโค้ดในโลกแห่งความเป็นจริง" และ OpenAI ก็ได้เผยแพร่ GPT-5 (การ์ดระบบและเอกสารสำหรับนักพัฒนาที่เผยแพร่ในช่วงต้นเดือนสิงหาคมเดียวกัน) พร้อมคำกล่าวอ้างอย่างชัดเจนว่าเป็น "โมเดลการเขียนโค้ดที่แข็งแกร่งที่สุดจนถึงปัจจุบัน" การเปิดตัวที่เกือบจะพร้อมกันเหล่านี้หมายความว่านักพัฒนาและทีมแพลตฟอร์มกำลังเปรียบเทียบประสิทธิภาพ ต้นทุน และเส้นทางการผสานรวมอย่างจริงจัง ดังนั้นเรื่องนี้จึงไม่ใช่เชิงวิชาการ: ทีมงานกำลังเลือกโมเดลที่จะส่งต่อคำแนะนำแบบ Copilot โมเดลที่จะนำไปใช้เบื้องหลังเอเจนต์โค้ดภายใน และโมเดลที่จะเชื่อถือสำหรับระบบอัตโนมัติที่คำนึงถึงความปลอดภัย
Claude Opus 4.1 คืออะไร?
Anthropic วางตำแหน่ง Opus 4.1 ให้เป็นการอัพเกรดเฉพาะสำหรับ Opus 4 โดยเน้นประสิทธิภาพที่ดีขึ้นสำหรับงานเขียนโค้ดเชิงเอเจนต์และงานจริง พวกเขากล่าวว่า Opus 4.1 พร้อมใช้งานสำหรับผู้ใช้ Claude แบบชำระเงินและใน Claude Code และได้รวมเข้ากับแพลตฟอร์มพันธมิตร (API, Bedrock, Vertex) แล้ว ข้อความของ Anthropic เน้นย้ำถึงความน่าเชื่อถือของตรรกะแบบหลายขั้นตอน ความแม่นยำของผลลัพธ์โค้ด และพฤติกรรมของเอเจนต์ที่ปลอดภัยยิ่งขึ้น
Claude Opus 4.1 – สถาปัตยกรรมและคุณลักษณะการเข้ารหัส
- บริบทที่ขยายและการใช้เหตุผลแบบขอบเขตยาว: พร้อมกับ c. โทเค็น 200K หน้าต่างบริบท ช่วยเพิ่มความสามารถในการรักษาความสอดคล้องกันระหว่างเวิร์กโฟลว์ที่ยาวนานและฐานโค้ดหลายไฟล์ได้อย่างมีนัยสำคัญ
- ประสิทธิภาพที่ผ่านการตรวจสอบ SWE-bench ที่สูงขึ้น: สำเร็จแล้ว 74.5% ความแม่นยำในการทดสอบ SWE-bench Verified (เพิ่มขึ้นจาก 72.5% ใน Opus 4) พร้อมด้วยการปรับปรุงที่เห็นได้ชัดในงานด้านตัวแทน (39.2% เป็น 43.3%) และการใช้เหตุผล (79.6% เป็น 80.9%)
- การปรับปรุงผ่านห่วงโซ่แห่งความคิดและ RLHF:ยังคงโครงสร้างสถาปัตยกรรมหลักของ Opus 4 ไว้ในขณะที่ปรับปรุงการใช้เหตุผลแบบห่วงโซ่ความคิด ความสอดคล้องหลายขั้นตอน และความใส่ใจในรายละเอียดผ่าน RLHF และการปรับแต่งตามข้อมูล
- การรวมเวิร์กโฟลว์ของตัวแทน:ออกแบบมาเพื่อจัดการเวิร์กโฟลว์หลายขั้นตอน รวมถึงการรีแฟกเตอร์โค้ดที่ซับซ้อนและการใช้เครื่องมือของตัวแทน ในขณะที่ยังคงรักษาสถานะภายในไว้ในช่วงเซสชันที่ขยายออกไป
- เครื่องมือที่ได้รับการปรับปรุงและการควบคุมเชิงสร้างสรรค์:นำเสนอ "บทสรุปเชิงความคิด" ที่สรุปเหตุผลภายในของโมเดล ช่วยเพิ่มความโปร่งใส Opus 4.1 ยังผสานรวมกับเครื่องมือของนักพัฒนาได้ดีขึ้นผ่าน Claude Code, API chaining และความสามารถในการเข้าถึงไฟล์
GPT-5 คืออะไร?
เอกสารสาธารณะของ OpenAI อธิบายว่า GPT-5 เป็นโมเดลการเขียนโค้ดที่แข็งแกร่งที่สุดเท่าที่พวกเขาเคยสร้างมา และได้เผยแพร่ผลการทดสอบประสิทธิภาพ (SWE-bench Verified และอื่นๆ) ซึ่งแสดงให้เห็นถึงการพัฒนาที่ดีขึ้นอย่างเห็นได้ชัดเมื่อเทียบกับโมเดลก่อนหน้า ข้อความของ OpenAI เน้นย้ำถึงความสามารถของ GPT-5 ในการจัดการกับการสร้างส่วนหน้าที่ซับซ้อน การดีบักคลังข้อมูลขนาดใหญ่ และประสิทธิภาพการใช้งานเครื่องมือที่ดีขึ้น การ์ดระบบที่แนบมาจะสรุปองค์ประกอบของโมเดล (โมเดลที่รวดเร็ว + โมเดลการให้เหตุผลเชิงลึก)
GPT-5 – สถาปัตยกรรมและคุณลักษณะการเข้ารหัส
- เราเตอร์แบบไดนามิกและโหมดการประมวลผลแบบคู่:สร้างขึ้นเป็นระบบรวมที่ผสานรวมเส้นทางการตอบสนองที่รวดเร็วและการใช้เหตุผลเชิงลึก เราเตอร์จะกำหนดเส้นทางการสอบถามแบบไดนามิกไปยังโหมดการสร้างอย่างรวดเร็วหรือโหมด "การคิด" แบบขยาย ซึ่งช่วยเพิ่มประสิทธิภาพสำหรับงานทั้งแบบง่ายและแบบซับซ้อน
- หน้าต่างบริบทขนาดใหญ่: รองรับได้ถึง โทเค็น 256K ของบริบท ช่วยให้สามารถจัดการอินพุตจำนวนมาก เช่น ฐานโค้ดขนาดใหญ่ เอกสารรูปแบบยาว และโปรเจ็กต์หลายเซสชันได้โดยไม่สูญเสียความสอดคล้อง
- ความเข้าใจและความจำแบบหลายโหมด:ประมวลผลข้อความ รูปภาพ เสียง และวิดีโอแบบเนทีฟภายในเซสชันเดียว มาพร้อมฟีเจอร์หน่วยความจำถาวรและการปรับแต่งส่วนบุคคลที่ช่วยเพิ่มความต่อเนื่องในการโต้ตอบระยะยาว
- ความปลอดภัยที่เพิ่มขึ้นและการใช้เหตุผลที่ซื่อสัตย์:แนะนำ "การเติมเต็มอย่างปลอดภัย" ที่สร้างสมดุลระหว่างประโยชน์และการยอมรับข้อจำกัดอย่างชัดเจน ในโหมดการให้เหตุผล GPT-5 ช่วยลดอาการประสาทหลอนและการหลอกลวงได้อย่างมาก โดยลดผลลัพธ์ที่หลอกลวงจาก ~86% เหลือ ~9% ในการทดสอบบางประเภท
- การควบคุมการใช้เหตุผลและความละเอียด:นักพัฒนาสามารถปรับได้
reasoning_effort(น้อยที่สุด/ต่ำ/สูง) และverbosity(ต่ำ/กลาง/สูง) ควบคุมความลึกและรายละเอียดของผลลัพธ์ นอกจากนี้ยังรองรับการจัดรูปแบบผลลัพธ์แบบมีโครงสร้างผ่าน regex หรือข้อจำกัดทางไวยากรณ์
ตัวเลขที่แน่นอนบอกอะไรบ้าง — คะแนนเกณฑ์มาตรฐาน, หน้าต่างบริบท และราคาโทเค็น?
เกณฑ์มาตรฐานและเปอร์เซ็นต์
- SWE-bench (ผ่านการตรวจสอบแล้ว):รายงานแอนโทรปิก คล็อด โอปุส 4.1: 74.5% ได้รับการยืนยันจาก SWE-bench OpenAI รายงาน GPT-5: 74.9% จากเกณฑ์มาตรฐานเดียวกัน (และ 88% จากเกณฑ์มาตรฐานโพลีกลอตบางฉบับ) ตัวเลขเหล่านี้ทำให้ทั้งสองโมเดลอยู่ในขอบเขตที่แคบในชุดงานการเขียนโค้ดที่ใช้งานได้จริง เกณฑ์มาตรฐานแสดงให้เห็นถึงความเท่าเทียมกันที่ระดับสูงสุด โดยมีความแตกต่างทางตัวเลขเพียงเล็กน้อย ซึ่งแทบจะไม่สามารถเทียบเคียงได้กับประสิทธิภาพการทำงานจริง
หน้าต่างบริบท (เหตุใดจึงสำคัญ)
บริบทรวมสูงสุดอย่างเป็นทางการของ GPT-5 (อินพุต + เอาท์พุต) คือ 400,000 โทเค็นโดยมี API ที่รองรับได้สูงสุดถึง ~272,000 โทเค็นอินพุต และขึ้นไป โทเค็นเอาต์พุต 128,000 รายการ (ทั้งสองรวมกันแล้วมีทั้งหมด 400 รายการ) ใน ChatGPT เวอร์ชันฟรีให้คุณเข้าถึงโมเดล GPT-5 หลัก รวมถึง GPT-5 Thinking แต่จะมีหน้าต่างบริบทที่เล็กที่สุดและขีดจำกัดการใช้งานที่เข้มงวดกว่า สมาชิกจะได้รับโมเดลเดียวกัน แต่มีขอบเขตที่ขยายใหญ่ขึ้นและหน้าต่างบริบทที่ใหญ่กว่าด้วยโทเค็น 32 รายการ เวอร์ชัน Pro คือจุดเริ่มต้นของทุกสิ่ง คุณจะได้รับ GPT-5, GPT-5 Thinking และ GPT-5 Pro ซึ่งเป็นเวอร์ชันระดับไฮเอนด์ที่ออกแบบมาเพื่อความลึกและความแม่นยำสูงสุดของการใช้เหตุผล หน้าต่างบริบทจะขยายเป็น 128 รายการ ผู้ใช้ระดับองค์กรจะได้รับหน้าต่างบริบท 128 รายการเช่นกัน ในขณะที่ Teams จะจำกัดไว้ที่ 32 รายการ
Claude Opus 4.1 (หน้าต่างบริบท) Claude Opus 4.1 ของ Anthropic ถูกส่งมาเป็นโมเดลการใช้เหตุผลแบบไฮบริดพร้อมด้วย ~200,000 โทเค็น หน้าต่างบริบทในเอกสารประกอบผลิตภัณฑ์ และได้รับการปรับแต่งโดยเฉพาะสำหรับการใช้เหตุผลแบบหลายขั้นตอนในขอบเขตยาว และเวิร์กโฟลว์การเขียนโค้ดแบบเอเจนต์ หน้าต่าง 200K นี้ช่วยให้ Opus 4.1 สามารถเก็บส่วนใหญ่ของที่เก็บ การทดสอบ และบันทึกการออกแบบไว้ในบริบทเดียว ซึ่งมีประโยชน์สำหรับการรีแฟกเตอร์หลายไฟล์ งานไมเกรชัน และการโต้ตอบกับเครื่องมือแบบลูกโซ่ ซึ่งการรักษาสถานะภายในและห่วงโซ่ความคิดในหลายขั้นตอนมีความสำคัญมากกว่าการลดเวลาแฝงที่ต่ำที่สุด
การกำหนดราคา (ตัวอย่างต้นทุนอินพุต/เอาท์พุต)
- โอเพ่นเอไอ (GPT-5) ตัวอย่างราคาที่เผยแพร่ เช่น อินพุต $1.25 / 1M โทเค็น เอาต์พุต $10 / 1M โทเค็น สำหรับ GPT-5 รุ่นมาตรฐานและระดับที่ต่ำกว่า (มินิ/นาโน) ที่มีต้นทุนต่อหน่วยต่ำกว่า ตัวเลขเหล่านี้มีประโยชน์ในการประมาณเวิร์กโฟลว์ CI ขนาดใหญ่
- แอนโทรปิก (Opus 4.1) แสดงต้นทุนต่อหน่วยที่สูงขึ้นในบางหน้าที่เผยแพร่ (ตัวอย่าง: โทเค็นอินพุต $15 / 1 ล้าน และโทเค็นเอาต์พุต $75 / 1 ล้าน บนหน้าที่อ้างอิง — แต่ Anthropic ยังโฆษณาการแคชที่รวดเร็ว การแบ่งกลุ่ม และกลไกการประหยัดต้นทุนอื่นๆ) โปรดตรวจสอบหน้าราคาของผู้ขายสำหรับแผนบริการที่คุณจะใช้เสมอ
ความหมาย: ในระดับขนาดใหญ่ การกำหนดราคาโทเค็น + ความละเอียดของผลลัพธ์ (จำนวนโทเค็นที่โมเดลปล่อยออกมา) มีความสำคัญอย่างมาก โมเดลที่เขียนโทเค็นมากขึ้นหรือต้องการการวนซ้ำมากขึ้น มักจะมีต้นทุนสูงขึ้น แม้ว่าอัตราต่อโทเค็นจะต่ำกว่าก็ตาม
จุดแข็งของพวกเขาเชื่อมโยงกับงานของนักพัฒนาจริงได้อย่างไร
การสร้างไฟล์เดี่ยว การสร้างต้นแบบ และโค้ด UI
GPT-5 ได้รับการเน้นย้ำถึงการสร้างโค้ด UI/UX (HTML/CSS/JS) ที่สวยงามและการใช้งานไฟล์เดียวที่สะอาดตาได้อย่างรวดเร็ว ซึ่งเหมาะกับการสร้างโครงร่างส่วนหน้า การสร้างต้นแบบ และเวิร์กโฟลว์ "สร้างแล้วขัดเกลาโดยมนุษย์" การทดสอบการตลาดและชุมชน GPT-5 ในช่วงแรกเน้นที่การเลือกใช้การออกแบบ ระยะห่าง และคุณภาพด้านสุนทรียศาสตร์ของส่วนหน้า
การรีแฟกเตอร์ไฟล์หลายไฟล์ การใช้เหตุผลที่ยาวนาน และเวิร์กโฟลว์แบบเอเจนต์
Anthropic นำเสนอ Claude (Opus) สำหรับการใช้เหตุผลแบบหลายขั้นตอนอย่างต่อเนื่องและงานแบบเอเจนต์ เช่น การรีแฟกเตอร์ขนาดใหญ่ การโยกย้าย API หลายไฟล์ และการประสานโค้ดอัตโนมัติ ซึ่งผู้ช่วยจำเป็นต้องให้เหตุผลข้ามไฟล์จำนวนมากและรักษาค่าคงที่ไว้ Opus 4.1 ระบุอย่างชัดเจนถึงการปรับปรุงสำหรับงานโค้ดแบบหลายขั้นตอนและการผสานรวมแบบเอเจนต์ จุดแข็งเหล่านี้ส่งผลให้การสูญเสียบริบทที่ร้ายแรงน้อยลงเมื่อให้เหตุผลผ่านโทเค็นหลายหมื่นรายการ
ทางเลือกการเข้ารหัสส่งผลต่อความแม่นยำ ภาพหลอน และการดีบักอย่างไร
การแลกเปลี่ยนระหว่างความซื่อสัตย์กับภาพหลอน: Anthropic ได้วางตำแหน่งโมเดลของ Claude ไว้อย่างเปิดเผยและสอดคล้องกับคำสั่ง (โดยลดอาการประสาทหลอนบางประเภท) ซึ่งเป็นส่วนหนึ่งของเหตุผลที่ Opus 4.1 ให้ความสำคัญกับ "การติดตามรายละเอียด" และการยึดมั่นตามกฎ GPT-5 ของ OpenAI มุ่งมั่นที่จะทำงานได้อย่างรวดเร็วและเชื่อถือได้มากขึ้นในงานที่หลากหลาย โดยอาศัยการกำหนดเส้นทางระดับระบบและความปลอดภัย/การบรรเทาผลกระทบเฉพาะตามที่อธิบายไว้ใน system card ผู้จำหน่ายทั้งสองรายยังคงรับทราบความเสี่ยงจากอาการประสาทหลอนที่เหลืออยู่และให้คำแนะนำในการบรรเทาผลกระทบ
การดีบักและการซ่อมแซมแบบวนซ้ำ: การเข้ารหัสผลลัพธ์จาก repo + test มากขึ้นในพรอมต์เดียวช่วยลดการสลับบริบท และช่วยให้โมเดลเสนอวิธีแก้ไขที่คำนึงถึงสถานะโครงการที่กว้างขึ้น Opus 4.1 โฆษณาจุดแข็งในการปฏิบัติตามคำสั่งดีบักแบบหลายขั้นตอน ขณะที่ GPT-5 โฆษณาการสร้าง front-end ที่รวดเร็ว คำนึงถึงการออกแบบ และการผสานรวมเครื่องมือที่สมบูรณ์ยิ่งขึ้น ทั้งสองอย่างนี้ช่วยปรับปรุงการดีบักแบบวนซ้ำ แต่ทั้งสองอย่างนี้ไม่ได้ช่วยลดความจำเป็นในการตรวจสอบการทดสอบโดยมนุษย์และการตรวจสอบโค้ด
ตารางเปรียบเทียบคุณสมบัติ
| ลักษณะ | GPT-5 (โอเพ่นเอไอ) | Claude Opus 4.1 (มานุษยวิทยา) |
|---|---|---|
| ปล่อย | สิงหาคม | สิงหาคม 5, 2025 |
| หน้าต่างบริบท | จนถึง โทเค็น 400K (เอกสารยาว, ฐานโค้ด) | ~200K โทเค็นปรับให้เหมาะสมสำหรับเวิร์กโฟลว์แบบหลายขั้นตอนและยาวนาน |
| โหมดการประมวลผล | โหมดคู่ (รวดเร็วและลึกซึ้ง "การใช้เหตุผล") พร้อมการกำหนดเส้นทาง | ห่วงโซ่ความคิดแบบยาวและการใช้เหตุผลที่ยั่งยืน |
| การสนับสนุนหลายรูปแบบ | ข้อความ รูปภาพ เสียง วิดีโอ หน่วยความจำถาวร | ส่วนใหญ่เป็นข้อความ (การใช้เหตุผลและการไหลลื่นของความคิดสร้างสรรค์ที่ดีขึ้น) |
| การเข้ารหัสและเกณฑ์มาตรฐาน | 74.9% SWE-bench ได้รับการยืนยัน, 88% บน Aider Polyglot | 74.5% SWE-bench ได้รับการตรวจสอบแล้ว; การรีแฟกเตอร์ไฟล์หลายไฟล์ที่แข็งแกร่ง |
| ความปลอดภัยและความน่าเชื่อถือ | ลดอาการประสาทหลอน ทำงานได้อย่างปลอดภัย ผลลัพธ์ที่ซื่อสัตย์ | พฤติกรรมอนุรักษ์นิยม ความถูกต้องและความปลอดภัยที่ได้รับการปรับปรุง |
| การควบคุมและเครื่องมือ | reasoning_effort, ความเยิ่นเย้อ, ผลลัพธ์ที่มีโครงสร้าง | การสรุปความคิด การรวมเครื่องมือผ่าน Claude Code SDK |
วิธีการวัดว่าอะไรดีกว่าสำหรับ ธุรกิจ codebase — แผนการประเมินเชิงปฏิบัติ (พร้อมโค้ด)
ด้านล่างนี้คือชุดควบคุมที่ใช้งานได้จริงและสามารถทำซ้ำได้ ซึ่งคุณสามารถรันเพื่อเปรียบเทียบ Claude Opus 4.1 และ GPT-5 บนคลังข้อมูลของคุณได้ ชุดควบคุมนี้จะดำเนินการโดยอัตโนมัติ: (1) แจ้งให้โมเดลดำเนินการหรือแก้ไขฟังก์ชัน (2) แทรกเอาต์พุตลงในไฟล์แซนด์บ็อกซ์ (3) รันการทดสอบยูนิต และ (4) บันทึกผลผ่าน/ไม่ผ่าน การใช้โทเค็น และจำนวนการวนซ้ำ
คำเตือน: การดำเนินการโค้ดที่สร้างขึ้นนั้นทรงพลังแต่มีความเสี่ยง — ควรรันคอนเทนเนอร์แซนด์บ็อกซ์เสมอ ใช้ทรัพยากร/จำกัดเวลา และอย่าอนุญาตให้โค้ดที่สร้างขึ้นเข้าถึงข้อมูลลับที่ละเอียดอ่อนหรือเครือข่าย เว้นแต่จะได้รับอนุญาตและตรวจสอบโดยเจตนา
1) สายรัดวัดอะไร
- อัตราการผ่านแบบทดสอบยูนิต (หลัก)
- จำนวนรอบการแก้ไข (จำนวนครั้งที่คุณต้องการขอให้แก้ไข)
- โทเค็นที่ใช้ไป (อินพุต + เอาท์พุต)
- ความหน่วงของนาฬิกาติดผนัง
2) ตัวอย่าง Python Harness (โครงกระดูก)
คุณสามารถใช้ CometAPI สำหรับการทดสอบได้ โดยการนำเสนอการตรวจสอบสิทธิ์ การจัดรูปแบบคำขอ และการจัดการการตอบสนองที่สอดคล้องกัน CometAPI ช่วยลดความซับซ้อนในการรวมความสามารถของ AI เข้ากับแอปพลิเคชันของคุณอย่างมาก
โคเมทเอพีไอ มอบการเข้าถึง "API เดียว" ให้กับโมเดลมากกว่า 500 โมเดล และจัดทำเอกสารอินเทอร์เฟซที่เข้ากันได้กับ OpenAI ซึ่งคุณสามารถเรียกใช้ด้วยคีย์ API ของ CometAPI และการแทนที่ URL พื้นฐาน ซึ่งทำให้การสลับจากไคลเอนต์ OpenAI โดยตรงเป็นเรื่องง่าย แทนที่จะรวม Anthropic และสลับไปมาระหว่าง openAI คล็อด โอปุส 4.1CometAPI เปิดเผยตัวระบุรุ่นเฉพาะ (ตัวอย่างเช่น claude-opus-4-1-20250805 และตัวแปรการคิด) และจุดสิ้นสุดการแชทที่ทุ่มเทสำหรับ จีพีที-5CometAPI เปิดเผยโมเดลเฉพาะ gpt-5” /“gpt-5-2025-08-07” /“gpt-5-chat-latest. ในการเริ่มต้น ให้สำรวจความสามารถของโมเดลใน สนามเด็กเล่น และปรึกษา คู่มือ API สำหรับคำแนะนำโดยละเอียด
python"""
side_by_side_eval.py
High-level harness:
- tasks: list of dicts {name, prompt, test_file_contents}
- apis: simple wrappers for OpenAI (GPT-5) and Anthropic (Claude Opus 4.1)
- run: for each task, call each model, write code, run pytest, collect metrics
NOTE: replace API_KEY_* with your keys and confirm official endpoints/params per vendor docs.
"""
import os
import json
import subprocess
import time
from typing import Dict, Any
import requests
# === CONFIG - fill these from your environment ===
# === Simple API wrappers (check vendor docs for exact endpoints/params) ===
def call_gpt5(prompt: str, max_tokens=1024) -> Dict:
url = "https://api.cometapi.com/v1/responses" # example; confirm actual endpoint headers = {"Authorization": f"Bearer {CometAPI_API_KEY}"}
body = {
"model": "gpt-5",
"input": prompt,
"max_output_tokens": max_tokens
}
t0 = time.time()
r = requests.post(url, headers=headers, json=body, timeout=60)
latency = time.time() - t0
r.raise_for_status()
resp = r.json()
# token info might be in resp depending on API; adapt as needed
return {"text": resp if "output_text" in resp else resp, "raw": resp, "latency": latency}
def call_claude(prompt: str, max_tokens=1024) -> Dict:
url = "https://api.cometapi.com/v1/chat/completions" # example; confirm actual endpoint headers = {"x-api-key": CometAPI_API_KEY}
body = {
"model": "claude-opus-4-1-20250805", "prompt": prompt,
"max_tokens_to_sample": max_tokens
}
t0 = time.time()
r = requests.post(url, headers=headers, json=body, timeout=60)
latency = time.time() - t0
r.raise_for_status()
resp = r.json()
return {"text": resp.get("completion", ""), "raw": resp, "latency": latency}
# === Test runner ===
def run_task(task: Dict, model_fn, model_name: str):
"""Run a single task: call model, write file, run pytest, collect result."""
prompt = task
result = model_fn(prompt, max_tokens=task.get("max_tokens", 2048))
code_text = result
# write task files into temporary folder
tmpdir = f"runs/{task}/{model_name}"
os.makedirs(tmpdir, exist_ok=True)
code_file = os.path.join(tmpdir, "submission.py")
with open(code_file, "w") as f:
f.write(code_text)
# write tests
test_file = os.path.join(tmpdir, "test_submission.py")
with open(test_file, "w") as f:
f.write(task)
# run pytest in subprocess with timeout
try:
proc = subprocess.run(
,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
timeout=30
)
passed = proc.returncode == 0
output = proc.stdout.decode()
except subprocess.TimeoutExpired:
passed = False
output = "pytest timeout"
return {
"model": model_name,
"task": task,
"passed": passed,
"latency": result,
"tokens_estimate": result.get("usage", {}),
"stdout": output,
"code": code_text
}
# === Example tasks: simple function to implement ===
TASKS = [
{
"name": "is_prime",
"prompt": "Implement a Python function `is_prime(n: int) -> bool` with proper docstring and edge case handling.",
"test_code": """
import submission
def test_prime():
assert submission.is_prime(2)
assert submission.is_prime(13)
assert not submission.is_prime(1)
assert not submission.is_prime(0)
assert not submission.is_prime(-7)
assert not submission.is_prime(15)
""",
"max_tokens": 256
}
]
# === Runner ===
if __name__ == "__main__":
results = []
for task in TASKS:
for model_fn, name in :
res = run_task(task, model_fn, name)
print(json.dumps(res, indent=2))
results.append(res)
# save to file
with open("results.json", "w") as f:
json.dump(results, f, indent=2)
ในการจำลองการรีแฟกเตอร์ไฟล์หลายไฟล์ ให้รวมงานที่พรอมต์ประกอบด้วยไฟล์หลายไฟล์ (หรือฟีดข้อมูลส่วนต่างๆ ของที่เก็บข้อมูลผ่านการดึงข้อมูล) สำหรับบริบทที่ยาว ให้วัดว่าโมเดลจำเป็นต้องดึงข้อมูลหรือบริบทในพรอมต์
คุณควรรายงานเมตริกใดบ้าง และเพราะเหตุใด?
- อัตราการผ่านการทดสอบหน่วย (ไบนารีต่องาน) — หลัก, วัตถุประสงค์
- เวลาแก้ไขของมนุษย์ — นักพัฒนาต้องแก้ไขนานแค่ไหนก่อนที่การทดสอบจะผ่าน
- การวนซ้ำเพื่อผ่าน — จำเป็นต้องมีรอบการแจ้งเตือน/ข้อเสนอแนะกี่รอบ
- โทเค็นที่ใช้ไป — ต้นทุนพร็อกซี (อินพุต + เอาต์พุต)
- ความหน่วงของนาฬิกาติดผนัง — เรื่องสำหรับการใช้งานแบบโต้ตอบ
- รูปแบบการใช้ในทางที่ผิดด้านความปลอดภัยและ API — เช่น โค้ดที่สร้างขึ้นใช้การเรียกประเมิน/เครือข่ายที่ไม่ปลอดภัยหรือไม่
รวบรวมสิ่งเหล่านี้ตามงานและนำมารวมกัน (อัตราการผ่านเฉลี่ย, โทเค็นมัธยฐาน, เวลาแฝง P95) ซึ่งจะทำให้เห็นภาพต้นทุนเทียบกับมูลค่าได้ชัดเจนยิ่งขึ้น
ข้อคิด
- จีพีที-5 โดดเด่นด้วย ความยืดหยุ่นแบบหลายโหมดการจัดการบริบทขนาดใหญ่ พลวัตการใช้เหตุผลแบบปรับตัว การควบคุมนักพัฒนาโดยละเอียด และความปลอดภัยที่ดีขึ้น เหมาะอย่างยิ่งสำหรับบริบทที่เกี่ยวข้องกับประเภทข้อมูลที่หลากหลาย ความต่อเนื่องของโครงการที่ยาวนาน การสร้างต้นแบบที่รวดเร็ว และงานแบบโต้ตอบที่เน้นตัวแทน
- คล็อด โอปุส 4.1 เอนเข้าไป การใช้เหตุผลเชิงลึกหลายขั้นตอนความสม่ำเสมอที่โดดเด่นในลำดับที่ยาว และประสิทธิภาพที่ปรับปรุงใหม่ในการทดสอบประสิทธิภาพการเขียนโค้ด การพัฒนาสายความคิดและเครื่องมือต่างๆ ทำให้เป็นตัวเลือกที่ยอดเยี่ยมสำหรับการแปลงฐานโค้ดที่ซับซ้อนและเวิร์กโฟลว์ของนักพัฒนาแบบเอเจนต์
วิธีที่ดีที่สุดของคุณอาจเป็นการผสมผสานทั้งสองสิ่งเข้าด้วยกัน: ใช้ GPT-5 สำหรับงานมัลติโหมดแบบโต้ตอบที่หลากหลายและการสร้างต้นแบบอย่างรวดเร็วและ อาศัย Claude Opus 4.1 สำหรับการใช้เหตุผลเชิงโครงสร้างอย่างลึกซึ้ง การรีแฟกเตอร์ไฟล์หลายไฟล์ และการดำเนินการโค้ดที่มีความเที่ยงตรงสูง.