Claude 5.5: เลิกจ่ายค่าเสียหายจากงานที่ล้มเหลว

การตั้งค่า Sonnet และ Opus ที่สำคัญจริง ๆ: effort, cache, การตรวจสอบ และต้นทุนต่องานที่เสร็จสมบูรณ์

โมเดลที่ถูกที่สุดไม่ใช่โมเดลที่มีราคา token ต่ำที่สุด

แต่คือโมเดลที่ทำงานจบ ผ่านการตรวจสอบ และไม่ทำให้คุณต้องจ่ายเงินซื้อ context เดิมซ้ำอีกห้ารอบ

Sonnet 5.5 และ Opus 5.5 ทำให้ความแตกต่างนี้สำคัญเป็นพิเศษ ตัวหนึ่งตั้งราคามาเพื่อรองรับงานปริมาณมาก อีกตัวตั้งราคามาเพื่องานที่ยากกว่า ทั้งสองมีพฤติกรรม effort แบบใหม่ และทั้งคู่อาจถูกอย่างน่าประหลาดใจเมื่ออยู่ใน agent loop ที่จัดการ cache ได้ดี

ถ้าคุณก๊อปปี้ config เก่ามาใช้กับโมเดลใดโมเดลหนึ่ง ผลลัพธ์อาจช้าลง แพงขึ้น หรือเจอ error 400

นี่คือการตั้งค่าที่ผมจะสร้างขึ้นมาแทน

1งาน → SONNET 5.5 → ตรวจสอบ → OPUS 5.5 หากจำเป็น → ผลลัพธ์ที่ผ่านการตรวจสอบแล้ว
2             ↘ effort ↗         ↘ cache + บัญชีการใช้งาน ↗

ผมเผยแพร่บทความวิเคราะห์เชิงปฏิบัติเกี่ยวกับ AI agent, workflow และระบบ production บน Substack

สมัครรับจดหมายข่าวได้ที่นี่

ตัวเลขที่ควรใช้ตัดสิน stack ของคุณ

การเปรียบเทียบโมเดลส่วนใหญ่เริ่มต้นที่ราคาดอลลาร์ต่อล้าน token

แต่ agent ของคุณไม่ได้ส่งมอบ token มันส่งมอบงานที่ทำเสร็จแล้ว

https://x.com/claudeai/status/2102435511222890900

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

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

และให้แยกตรวจส่วนหางของการกระจาย (hard tail) ด้วย ถ้าการตั้งค่าที่ถูกที่สุดจัดการคำขอของคุณได้ 90% แต่เผางบไปครึ่งหนึ่งกับอีก 10% ที่เหลือ ค่าเฉลี่ยของมันอาจซ่อนส่วนของ workflow ที่ต้องใช้โมเดลอื่นไว้ก็ได้

ตารางราคา 5.5 บอกอะไรเราจริง ๆ

ณ วันที่ 3 ตุลาคม 2026 ตามอัตรา Claude API มาตรฐาน ต่อล้าน token:

1SONNET 5.5
2อินพุตใหม่  $2       เอาต์พุต  $10
3อ่าน cache   $0.20    เขียน cache  $2.50 / 5 นาที, $4 / 1 ชั่วโมง
4
5OPUS 5.5
6อินพุตใหม่  $4       เอาต์พุต  $20
7อ่าน cache   $0.20    เขียน cache  $5 / 5 นาที, $8 / 1 ชั่วโมง

ทั้งสองโมเดลมี context window ขนาด 1M token และเอาต์พุตสูงสุด 128K token นี่คือเพดานจำกัด ไม่ใช่เหตุผลที่คุณจะต้องยัดข้อมูลให้เต็ม

ข้อกำหนดและราคาของโมเดล

บรรทัดที่แปลกคือ cache read

Opus มีราคาอินพุตและเอาต์พุตใหม่แพงกว่าสองเท่า แต่ prefix ที่อยู่ใน cache แล้วมีราคาเท่ากันที่ $0.20 ต่อล้านในทั้งสองโมเดล นี่ไม่ได้แปลว่าการรัน Opus จะถูกเท่ากัน เพราะมันยังจ่ายแพงกว่าสำหรับอินพุตใหม่ เอาต์พุต และการเขียน cache แต่มันหมายความว่าช่องว่างด้านราคาระหว่างโมเดลสามารถแคบลงได้ในเซสชันที่เน้นการอ่าน

มีความแตกต่างที่สองที่คนมักมองข้าม คำว่า "ถูกกว่า Opus 5 อยู่ 40%" ของ Anthropic เป็นการประมาณการ \ต้นทุนการรัน\ โดยทั่วไป ราคา token ใหม่ของ Opus 5.5 ลดลง 20% ส่วนราคา cache-read ลดลง 60% ตัวเลขเหล่านี้เกี่ยวข้องกัน แต่ใช้แทนกันไม่ได้

Effort คือการตัดสินใจเลือกเส้นทาง ไม่ใช่แถบเลื่อนปรับคุณภาพ

Sonnet 5.5 รองรับ low, medium, high, xhigh และ max บน API ค่าเริ่มต้นคือ high ส่วนในแอป Claude ทาง Anthropic บอกว่าค่าเริ่มต้นคือ medium ขณะที่ Opus 5.5 ใช้ medium เป็นค่าเริ่มต้นบน API ระดับเหล่านี้ไม่ได้ถูกปรับเทียบมาให้มีความหมายตรงกับคำเดียวกันในโมเดลรุ่นก่อนเป๊ะ ๆ

แผนที่เริ่มต้นของผม:

• Sonnet low สำหรับคำขอแคบ ๆ ที่อ่อนไหวต่อ latency และมีขั้นตอนตรวจสอบที่ถูก
• Sonnet medium สำหรับงานเขียนโค้ดที่กำหนดสเปกชัดเจน และงานหลายขั้นตอนทั่วไป
• Sonnet high เมื่อการรันระดับ medium ไม่ผ่านการตรวจสอบจริง หรืองานนั้นมีรูปแบบความซับซ้อนที่พิสูจน์แล้ว
• Opus medium สำหรับงานที่คลุมเครือ ข้ามไฟล์ หรือระยะยาว ซึ่ง Sonnet ต้องวนหลายรอบอยู่กับปัญหาเดิม
• Xhigh/max ใช้เฉพาะเมื่อการประเมิน (eval) ของคุณแสดงให้เห็นว่าคุ้มค่ากับเวลาและ token ที่เพิ่มขึ้น

นี่เป็นสมมติฐานเริ่มต้น ไม่ใช่ลำดับขั้นที่ใช้ได้กับทุกกรณี ในผลลัพธ์ FrontierCode ของ Sonnet 5.5 ที่ Anthropic รายงาน ระดับ xhigh ทำคะแนนได้สูงกว่า max การใช้ effort มากขึ้นไม่ได้การันตีผลลัพธ์ที่ดีกว่า

เชิงอรรถของ Anthropic อธิบายผลที่ดูขัดกับสามัญสำนึกนี้ว่า: ที่ระดับ max โมเดลมักจะเริ่มงานตรวจสอบโค้ดเพิ่มเติมเอง ในสองกรณีที่ศึกษา สิ่งนี้นำไปสู่ timeout หรือการแก้ไขที่เกินขอบเขตของงาน

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

https://x.com/edwinarbus/status/2104675431853248816

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

https://x.com/claudeai/status/2104633115620823187

นั่นเป็นคำเคลมตอนเปิดตัวที่น่าสนใจ แต่ config สำหรับ production ยังไงก็ต้องเอาชนะ baseline ของคุณเองให้ได้

ลองทดสอบแบบ sweep เล็ก ๆ ก่อนจะไปประดิษฐ์ model router

หยิบงาน 10-30 อย่างที่คุณสนใจจริง ๆ มา รวมงานง่าย ๆ งานที่คลุมเครือ และความล้มเหลวที่น่าหงุดหงิดจาก log ของคุณด้วย กำหนด verifier ให้กับแต่ละงาน เช่น test suite, การเปรียบเทียบแบบมีโครงสร้าง, คำตอบที่รู้ล่วงหน้า หรือ rubric ของคนที่กำหนดไว้ก่อนรัน

นี่คือ API probe ที่เล็กที่สุดและมีประโยชน์ ซึ่งจะ log ฟิลด์การใช้งานที่คุณต้องการ นำไปรันกับแต่ละโมเดลและแต่ละระดับ effort กับงานเดียวกัน แล้วแนบการตรวจสอบ pass/fail ของคุณเองเข้าไป นี่ไม่ใช่ benchmark เต็มรูปแบบของ agent

1import anthropic
2
3client = anthropic.Anthropic()
4response = client.messages.create(
5    model="claude-sonnet-5-5",  # ทำซ้ำด้วย claude-opus-5-5
6    max_tokens=8192,
7    output_config={"effort": "medium"},  # ทำซ้ำที่ระดับ high
8    messages=[{"role": "user", "content": "เปลี่ยนข้อความนี้เป็นงานจริง"}],
9)
10
11answer = "".join(b.text for b in response.content if b.type == "text")
12usage = response.usage
13print(answer)
14print("fresh", usage.input_tokens, "output", usage.output_tokens)
15print("cache read", usage.cache_read_input_tokens)
16print("cache write", usage.cache_creation_input_tokens)

โค้ดนี้ตั้งอยู่บนสมมติฐานว่าคุณกำลังใช้แพ็กเกจ Python อย่างเป็นทางการของ Anthropic และมี environment variable ชื่อ ANTHROPIC_API_KEY นี่เป็นการเรียก API แบบโดด ๆ ครั้งเดียวโดยไม่ได้เปิดใช้งาน cache จึงคาดว่า cache read และ write จะเป็นศูนย์ ส่วนถัดไปจะแสดงว่าอะไรที่ทำให้สิ่งนี้เปลี่ยนไป

สำหรับ agent จริง ให้รวมการใช้งานจากการเรียก API ทั้งหมดภายใต้ task ID เดียวกัน รวมถึงการ retry และการเรียก tool นับว่าผ่านก็ต่อเมื่อ verifier บอกว่างานเสร็จแล้ว

เปรียบเทียบจำนวนเงินทั้งหมดต่อการผ่านหนึ่งครั้งก่อนเลือกค่าเริ่มต้น

รักษาความซื่อสัตย์ของการทดสอบ:

• ล็อกชุดงานและ verifier ไว้ก่อนเปรียบเทียบ config
• ใช้ tools, permissions, context และข้อกำหนดเอาต์พุตเดียวกันกับผู้เข้าทดสอบทุกราย
• บันทึกอัตราการผ่าน ยอดใช้จ่ายทั้งหมด ต้นทุนต่อการผ่าน latency และความล้มเหลวที่ใช้เวลานานหรือแพงที่สุด
• นับ stop_reason: "max_tokens" ว่าเป็นความพยายามที่ไม่สมบูรณ์ ไม่ใช่ความสำเร็จราคาถูก

ตัวอย่างโค้ดสั้น ๆ ด้านบนใช้ขีดจำกัดเอาต์พุต 8K สำหรับการทดสอบแบบเทิร์นเดียว อย่านำขีดจำกัดนั้นไปใช้กับ coding agent ระยะยาว

Anthropic แนะนำให้มีพื้นที่เผื่อมากกว่านี้มากสำหรับงาน agentic เพราะการคิดแบบซ่อน (hidden thinking) ก็ถูกนับรวมในขีดจำกัดเดียวกัน

ตั้งขีดจำกัดให้เหมาะกับงาน แล้วควบคุมค่าใช้จ่ายด้วย effort, caching และงบประมาณต่องาน แทนที่จะบังคับให้คำตอบหยุดกลางคัน

ทำ cache ส่วนที่เสถียรของงาน

Agent มักส่ง system instructions, คำนิยาม tool, repository map และบทสนทนาก่อนหน้าเดิม ๆ ซ้ำแล้วซ้ำเล่า ถ้า prefix นั้นเสถียร การใช้ prompt caching จะเปลี่ยนความคุ้มค่าทางเศรษฐศาสตร์ได้มากกว่าการแก้ prompt เล็กน้อย

ตัวอย่างเช่น token ใน cache 200K ที่ถูกอ่าน 50 ครั้ง เท่ากับ cache-read token 10M ที่ราคา $0.20 ต่อล้าน การอ่านเหล่านี้จะมีต้นทุน $2 ไม่ว่าจะใช้โมเดล 5.5 ตัวไหน

บน Opus 5.5 การส่ง 10M token เดียวกันเป็นอินพุตใหม่จะมีต้นทุน $40 และการเขียน cache ห้านาทีครั้งแรกสำหรับ 200K token ก็บวกไปอีก $1

นี่เป็นภาพประกอบเรื่องค่าใช้จ่ายของ prefix เท่านั้น: อินพุตใหม่ เอาต์พุต การเขียนอื่น ๆ การหมดอายุ TTL และ cache miss จริง ๆ จะถูกบวกเพิ่มในบิล

กฎที่ใช้ได้จริง:

• บน Claude API ให้เลือกใช้ prompt caching ผ่าน cache_control={"type": "ephemeral"} ระดับบนสุด หรือระบุ cache breakpoints อย่างชัดเจน probe ด้านบนไม่ได้ทำทั้งสองอย่าง ตัวนับ cache จึงมักอยู่ที่ศูนย์
• วาง instruction และ tool ที่เสถียรไว้ก่อนคำขอของผู้ใช้ที่เปลี่ยนแปลง
• รักษา prefix ที่ใช้ร่วมกันให้เหมือนกันทุกเทิร์น และตรวจสอบ cache_read_input_tokens จริง ๆ
• ถือว่าการเปลี่ยนโมเดลคืองบประมาณการสนทนาใหม่ ไม่ใช่การทำต่อฟรี ๆ เพราะ cache แยกตามโมเดล: คำขอ Opus ไม่สามารถอ่าน prefix ที่ Sonnet เพิ่ง cache ไว้ได้
• หลีกเลี่ยงการเปลี่ยน effort ระดับบนสุดในทุกเทิร์น เพราะจะทำให้ prompt ที่ render ออกมาเปลี่ยน และทำให้ prefix ที่ cache ไว้ใช้ไม่ได้

ในโมเดลที่รองรับ การเปลี่ยน effort แบบรายข้อความ สามารถรักษา cache ก่อนหน้าไว้ได้ แต่ต้องใช้ beta header ของ Anthropic และไม่เหมือนกับการเปลี่ยน output_config ระดับบนสุด

Sonnet 5.5 ยังมีข้อควรระวังเรื่อง between_tools: ในโหมดนั้นจะเปลี่ยน effort กลางบทสนทนาไม่ได้

เอกสาร Prompt caching

อย่าเดาว่า cache hit จากการตอบสนองที่เร็ว ให้อ่าน object usage มันแยกอินพุตใหม่ การสร้าง cache และการอ่าน cache ไว้อย่างชัดเจน

โมเดล 5.5 ทั้งสองต้องการ prefix ที่ cache ได้อย่างน้อย 512 token system prompt สั้น ๆ จะไม่ทำให้เกิดการประหยัดแบบในตัวอย่างข้างต้น อายุ cache เริ่มต้นคือห้านาที ซึ่งเหมาะกับ tool loop ที่ทำงานเร็ว

การเขียนแบบหนึ่งชั่วโมงมีต้นทุนสูงกว่า และสมเหตุสมผลเฉพาะเมื่อเซสชันจริงมักหยุดพักนานพอที่จะพลาดหน้าต่างห้านาที วัดช่วงห่างเหล่านั้นก่อนจ่ายเงินซื้อ TTL ที่ยาวกว่า

ยกระดับโมเดลเมื่อมีหลักฐาน ไม่ใช่เพราะกังวล

ทีมส่วนใหญ่สร้าง router กลับหัวกลับหาง: จัดประเภทงานว่า "ยาก" ส่งไปโมเดลแพง แล้วไม่เคยเรียนรู้เลยว่าเส้นทางที่ถูกกว่าจะผ่านเกณฑ์หรือไม่

ใช้ verifier เป็นสัญญาณในการเลือกเส้นทาง

11  Sonnet 5.5 · effort ที่เลือก  → รันงาน
22  Verifier                    → ยอมรับหากผ่าน
33  Opus 5.5 · medium           → ลองใหม่เฉพาะเมื่อมีหลักฐานว่าล้มเหลว
44  Verifier                    → ยอมรับหรือส่งต่อพร้อมหลักฐาน

การตรวจสอบอาจเป็น test suite, schema validation, คำตอบที่รู้ล่วงหน้า หรือผู้ตรวจทาน มันควรอธิบายได้ว่า อะไรที่ล้มเหลว

"คำตอบรู้สึกว่ามันยังไม่แน่น" เป็นสัญญาณยกระดับที่แย่ แต่ "endpoint ที่แก้ไขตก integration test สองรายการ" เป็นสัญญาณที่มีประโยชน์

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

คุณสามารถทดสอบการ retry ด้วย Sonnet high ในการ sweep แบบออฟไลน์ได้ เก็บไว้ในเส้นทาง live เฉพาะเมื่อมันช่วยลดต้นทุนต่องานที่ผ่านการตรวจสอบเท่านั้น ไม่มีเหตุผลใดที่ต้องให้ความล้มเหลวทุกครั้งจ่ายค่ารัน Sonnet สองรอบก่อนไปถึง Opus

การเปลี่ยนโมเดลเองก็สามารถทำลาย prefix ที่ cache ไว้ได้ คำนึงถึงเรื่องนี้ด้วยเมื่อเปรียบเทียบเส้นทางกู้สถานการณ์กับเส้นทางที่ใช้ Opus ตั้งแต่แรก

จุดตัดนั้นสังเกตได้ง่าย สมมติว่าการลองด้วย Sonnet มีต้นทุน $0.06 และผ่านงานของคุณ 80%

ถ้างานที่ล้มเหลวแต่ละชิ้นมีต้นทุน $0.20 เพื่อให้เสร็จบน Opus ค่าเฉลี่ยเชิงภาพประกอบของคุณคือ $0.10 ต่องานที่เสร็จ: $0.06 บวกกับการกู้สถานการณ์ $0.20 ในหนึ่งงานจากทุกห้างาน ซึ่งดีกว่าการจ่าย $0.20 ให้ Opus ในทุกงาน แต่ถ้า Sonnet มีต้นทุน $0.14 และผ่านแค่ครึ่งเดียว ขั้นบันไดเดียวกันจะมีต้นทุน $0.24 ยังไม่นับราคาของการเปลี่ยนโมเดล ใน workload แบบนั้น การใช้ Opus ตั้งแต่แรกจะถูกกว่าและเร็วกว่า

ตัวเลขเหล่านั้นเป็นเพียงตัวอย่าง ไม่ใช่ผลลัพธ์ที่วัดได้จาก Claude จุดประสงค์คือทำให้กฎการเลือกเส้นทางสามารถพิสูจน์ว่าผิดได้ ขั้นบันไดจะคู่ควรก็ต่อเมื่อจำนวนการเรียก Opus ที่ประหยัดได้ มีน้ำหนักมากกว่าการลองด้วย Sonnet ที่ล้มเหลว, cache miss และ latency ที่เพิ่มขึ้น

ยังมีทางสายกลาง: advisor tool เวอร์ชันเบต้าของ Anthropic Sonnet สามารถรันงานต่อไปได้และขอความช่วยเหลือจาก Opus ในจุดที่ต้องตัดสินใจยาก แทนที่จะโยนงานทั้งหมดให้ Opus

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

ในโมเดล 5.5 เหล่านี้ คำแนะนำจะถูกส่งกลับไปยัง client แบบเข้ารหัส ดังนั้นให้ประเมินผลงานที่ได้ มากกว่าจะแกล้งทำเป็นว่าคุณสามารถ audit ข้อความคำแนะนำส่วนตัวนั้นได้

รูรั่วสี่อย่างที่ดันบิลให้สูงขึ้นก่อนที่การเลือกโมเดลจะสำคัญ

ไม่ใช่ทุกปัญหาด้านต้นทุนที่ต้องใช้ router ใหม่

ตรวจสิ่งเหล่านี้ก่อน:

• เอาต์พุตที่พองขึ้นเรื่อย ๆ ในโมเดล 5.5 ทั้งสอง token เอาต์พุตมีราคาแพงกว่า token อินพุตใหม่ห้าเท่า ในการสนทนา คำตอบยาว ๆ อาจถูกส่งกลับมาเป็น context ในเทิร์นถัดไปด้วย ขอให้ส่งมอบ artifact พร้อมโน้ตสรุปสั้น ๆ ไม่ใช่ transcript บรรยายทุกขั้นตอน การคิดแบบซ่อนก็ถูกคิดเงินเป็นเอาต์พุตเช่นกัน ดังนั้นคำตอบสุดท้ายที่กระชับอย่างเดียวจะไม่แก้ปัญหา effort อย่าไปกดทับหลักฐานที่คุณต้องใช้ตรวจสอบผลลัพธ์
• รูปภาพที่ใหญ่เกินความจำเป็นของงาน Sonnet 5.5 ประมวลผลภาพความละเอียดสูงกว่า Sonnet รุ่นเก่าได้ ซึ่งอาจเพิ่มจำนวน image token ถ้า agent ต้องการแค่ป้ายปุ่มหรือย่อหน้าเดียว ให้ crop หรือ resize ก่อน ถ้าต้องการกราฟหนาแน่นหรือรายละเอียด UI เล็ก ๆ ให้คงความละเอียดไว้แล้ววัดต้นทุนแทนที่จะย่อขนาดแบบหลับตาปิดหู
• Context ที่ไม่มีใครใช้ คำนิยาม tool, log เก่า, ผลการค้นหาเก่า และ CLAUDE.md ที่ยืดเยื้ออาจตามไปกับทุกคำขอ ใส่กฎถาวรไว้ใน prefix สั้น ๆ ที่เสถียร เก็บหลักฐานชั่วคราวไว้ใกล้กับงานที่ต้องการ การตัด context ไม่ควรลบข้อเท็จจริงที่โมเดลยังต้องใช้ทำงานให้เสร็จอย่างถูกต้อง
• ราคาแบบ interactive สำหรับงานที่ไม่มีใครรอ Message Batches API ลดราคาอินพุตและเอาต์พุต 50% ในทั้งสองโมเดล ซึ่งมีประโยชน์สำหรับการประเมินแบบออฟไลน์ การเติมเอกสารย้อนหลัง และงาน asynchronous อื่น ๆ แต่มันใช้แทน live tool loop ที่คนต้องการขั้นตอนถัดไปทันทีไม่ได้

รูปแบบเหมือนกันทั้งสี่ข้อ: กำจัดงานที่ task ไม่ต้องการออกไปก่อน ค่อยซื้อความฉลาดเพิ่มหรือลด effort จนกว่าคุณภาพจะพัง

กับดักการย้ายระบบที่เปลี่ยนการประหยัดเงินให้เป็น error 400

request body เก่าเป็นจุดเริ่มต้นที่แย่สำหรับครอบครัว 5.5

โดยเฉพาะอย่างยิ่ง:

• การคิดของ Opus 5.5 เปิดอยู่ตลอดเวลา ลบ thinking: {"type": "disabled"} และการตั้งค่า budget_tokens คงที่แบบเก่าออก ควบคุมความลึกด้วย output_config.effort
• การบังคับเลือก tool ล้มเหลวในโมเดล 5.5 ทั้งสอง

ค่า tool_choice ที่เป็น any และ tool จะคืนค่า 400 ให้ใช้ auto ระบุเวลาที่ควรใช้ tool และตรวจสอบผลลัพธ์ของ tool ในโค้ดของคุณเอง

• Thinking block ไม่ใช่ text block ให้อ่าน content ตาม type ไม่ใช่ content [0] ใน tool loop ให้ส่ง thinking block กลับไปโดยไม่เปลี่ยนแปลงพร้อมกับ assistant turn
• UI ของคุณอาจดูเหมือนเงียบ บน Opus 5.5 ความคืบหน้าระหว่าง tool อาจมาในรูปแบบ thinking block ที่ว่างเปล่าในการตั้งค่าแสดงผลเริ่มต้น ถ้าคุณเคย render โน้ตเหล่านั้นให้ผู้ใช้เห็น ให้ขอ thinking display mode ที่รองรับ และ render block ตาม type ไม่เช่นนั้น agent อาจกำลังทำงานอยู่ขณะที่อินเทอร์เฟซดูเหมือนค้าง
• เวอร์ชัน computer-use tool เก่าอาจล้มเหลว ตรวจสอบเวอร์ชัน tool ปัจจุบันก่อนย้าย browser/computer agent
• ขีดจำกัด max_tokens ที่เล็กลงอาจตัดงานขาดตอน

การคิดถูกรวมอยู่ด้วยแม้ข้อความจะถูกซ่อนไว้

เหล่านี้คือการเปลี่ยนแปลงพฤติกรรมของ API ไม่ใช่เทคนิคการเขียน prompt

คู่มือการย้ายระบบสำหรับ Opus และ คู่มือการย้ายระบบสำหรับ Sonnet

ใส่ข้อตกลงไว้ใน Claude Code ไม่ใช่แค่ในหัวคุณ

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

ใน Claude Code คำสั่ง **/model ใช้เลือกโมเดล และ /effort ใช้เลือกระดับ effort ที่รองรับ ให้ตรวจสอบการตั้งค่าที่ใช้งานอยู่ก่อนเปรียบเทียบเซสชัน ค่าเริ่มต้นของ Sonnet API ไม่ได้อธิบายอย่างน่าเชื่อถือว่าแอป Claude หรือเซสชัน Claude Code ของคุณกำลังใช้อะไรอยู่

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

1# สัญญาการทำงาน
2
3ทำการเปลี่ยนแปลงตามที่ร้องขอเท่านั้น รักษาส่วนที่ไม่เกี่ยวข้องไว้
4รัน test ที่เกี่ยวข้องหลังจากแก้ไข รายงานการตรวจสอบใด ๆ ที่คุณรันไม่ได้
5หยุดเมื่องานที่ร้องขอผ่านเกณฑ์ อย่าเพิ่มฟีเจอร์พิเศษหรือรอบการตรวจสอบ
6ปิดท้ายด้วย: สิ่งที่เปลี่ยน / สิ่งที่ตรวจสอบแล้ว / ความเสี่ยงที่เหลือ
7ถามก่อนดำเนินการที่ทำลายล้าง เผยแพร่ หรือเปลี่ยนแปลงนอก repository นี้

บล็อกนั้นจะไม่เสกให้การรันทุกครั้งถูกขึ้นมา แต่มันทำให้ความสำเร็จและความล้มเหลวมองเห็นได้ จากตรงนั้น คุณสามารถเปรียบเทียบ workflow แบบ Sonnet-first กับ Opus-first ในงานชุดเดียวกันได้

ข้อความสั่งงานยังต้องมีความเฉพาะเจาะจง นี่คือความแตกต่างระหว่าง "แก้โค้ดชำระเงิน" กับงานที่ agent ทำจนจบได้จริง

1การเปลี่ยนแปลง: ย้าย payment endpoint ไปใช้ client ใหม่
2เสร็จสิ้น: ลบ client เก่าแล้ว, endpoint test ผ่าน, diff จำกัดอยู่เฉพาะ path นี้
3หยุด: ถามก่อนลบข้อมูลหรือเปลี่ยนแปลงสิ่งใดนอก repo
4รายงาน: ไฟล์ที่เปลี่ยน, การตรวจสอบที่รันจริง, ความเสี่ยงที่เหลือ

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

สำหรับโปรเจกต์ยาว ๆ ให้เก็บ checklist ไว้ในไฟล์ที่อยู่รอดจากการ compaction สำหรับ subagent ให้สั่ง lead agent ตรวจสอบหลักฐานของพวกมันก่อนยอมรับรายงาน และถ้าคุณแค่ขอไอเดีย ให้บอก Claude ว่าอย่าเพิ่งเริ่มสร้าง สิ่งเหล่านี้คือขอบเขตของ workflow ไม่ใช่ prompt สั่งให้ "ฉลาดขึ้น"

การตั้งค่าที่ผมจะนำไปใช้จริงเป็นอย่างแรก

• เลือกงานจริง 10-30 งาน และกำหนดการตรวจสอบสำหรับแต่ละงาน
• Sweep Sonnet 5.5 ที่ระดับ medium และ high จากนั้น Opus 5.5 ที่ระดับ medium
• Log อินพุตใหม่ เอาต์พุต การเขียน cache การอ่าน cache latency การ retry และ pass/fail ต่องาน
• รักษา prefix ที่เสถียรให้ cache ได้ และยืนยัน cache hit ใน usage
• ส่งเฉพาะงานที่ล้มเหลวขึ้นไปด้านบน พร้อมแนบหลักฐาน
• ทบทวนขั้นบันไดใหม่เมื่อ workload เปลี่ยนแปลง benchmark ที่บันทึกไว้ไม่ใช่ความจริงถาวร

ถ้า 10% ที่ยากมักพุ่งตรงจากความล้มเหลวของ Sonnet ไปสู่ความสำเร็จของ Opus ให้พิจารณา route กลุ่มงานที่จำแนกได้นั้นไปที่ Opus ตั้งแต่แรก แต่ถ้า Sonnet high ผ่านเคสเหล่านั้นได้ด้วยต้นทุนที่ต่ำกว่า ก็เก็บไว้ที่เดิม router คือนโยบายที่วัดผลได้ ไม่ใช่ความคิดเห็นถาวรว่าโมเดลไหนฉลาดกว่า

การอัปเกรด 5.5 ไม่ใช่แค่ "ใช้ Sonnet กับงานถูก ๆ และ Opus กับงานยาก ๆ"

แต่มันคือโอกาสที่จะเลิกตั้งราคาตามโมเดล และเริ่มตั้งราคาตามงานที่เสร็จสมบูรณ์

ถ้าคุณอ่านมาถึงตรงนี้

-> สมัครรับข่าวสาร Substack ของผม

-> เข้าร่วม Telegram ของผม

-> บุ๊กมาร์กบทความนี้

-> ติดตาม @0xwhrrari