คู่มือฉบับสมบูรณ์สำหรับ Claude Fable 5.1: วิวัฒนาการ การประหยัด Token และการสร้างทักษะ

วิวัฒนาการ การประหยัด Token พรอมต์ Harness และการสร้างทักษะ

ในวันที่ 1 กันยายน 2026 Anthropic ได้เปิดตัว "Claude Fable 5.1" ณ วันที่ 2 กันยายน 2026 ซึ่งเป็นวันที่ฉันกำลังเขียนบทความนี้ ผ่านไปเพียงวันเดียวเท่านั้นนับตั้งแต่เปิดตัว ดังนั้น แทนที่จะเป็นรีวิวตามอัตวิสัยบนโซเชียลมีเดีย ฉันจะรวบรวมข้อมูลนี้โดยอ้างอิงจากเอกสารทางการของ Anthropic เอกสาร API และข้อกำหนดล่าสุดของ Claude Code

เพื่อสรุปให้คุณทราบก่อน: Fable 5.1 ไม่ใช่แค่ "โมเดลที่ตอบคำถามทั่วไปได้ฉลาดขึ้นเล็กน้อย"

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

อย่างไรก็ตาม ราคานั้นสูงเป็นสองเท่าของ Opus 5 และห้าเท่าของ Sonnet 5 ยิ่งไปกว่านั้น การคิดภายในไม่สามารถปิดได้ หากคุณโยนทุกอย่างให้ Fable 5.1 คุณจะหมดขีดจำกัดการใช้งานและงบประมาณก่อนที่จะใช้ความสามารถของมันได้อย่างแท้จริง

กุญแจสำคัญในการควบคุม Fable 5.1 ไม่ใช่แค่การเขียนพรอมต์ที่ยอดเยี่ยม

มันคือ การออกแบบว่างานเฉพาะใดที่ควรกำหนดให้ Fable ทำ ข้อมูลใดที่ควรโหลด และกระบวนการใดที่ควรโอนไปยังโมเดลหรือสคริปต์ที่ถูกกว่า

ส่วนที่ 1: คำอธิบายแบบครบถ้วนของ Claude Fable 5.1

1. Claude Fable 5.1 คืออะไร?

Claude Fable 5.1 ถูกวางตำแหน่งให้เป็นโมเดลที่มีความสามารถสูงที่สุดในบรรดาโมเดลที่ Anthropic เปิดตัวสู่สาธารณะ

Fable 5.1 และ Claude Mythos 5.1 ที่ต้องได้รับคำเชิญนั้นเป็นโมเดลเดียวกันโดยพื้นฐาน ความแตกต่างหลักอยู่ที่มาตรการด้านความปลอดภัย Fable ที่เปิดให้สาธารณะใช้มีตัวจำแนกประเภทที่แข็งแกร่งเพื่อตรวจจับพื้นที่ที่มีความเสี่ยงสูง เช่น ความปลอดภัยทางไซเบอร์ วิทยาศาสตร์ชีวภาพ และเคมี ในขณะที่ Mythos ถูกใช้โดยองค์กรที่ผ่านการตรวจสอบเพื่อการวิจัยเชิงป้องกันและวัตถุประสงค์อื่นๆ (Anthropic

ข้อกำหนดหลักมีดังนี้:

สำหรับผู้ใช้ Claude ทั่วไป มีให้บริการสำหรับผู้ใช้ Pro, Max, Team และ Enterprise บน API มีให้บริการสำหรับลูกค้าทั่วไปโดยไม่ต้องผ่านการคัดกรองพิเศษ (Claude Platform

บริบท 1 ล้าน Token โดยการคำนวณอย่างง่าย สามารถจัดการหนังสือหลายเล่มถึงเป็นโหล โค้ดเบสขนาดใหญ่ หรือประวัติการสนทนาระยะยาวได้ในครั้งเดียว

อย่างไรก็ตาม "สามารถใส่ 1 ล้าน Token ได้" นั้นแตกต่างจาก "คุณควรใส่ 1 ล้าน Token เข้าไป"

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

2. วิวัฒนาการของ Fable 5.1 คือ "การทำงานที่นานขึ้น"

วิวัฒนาการที่สำคัญที่สุดของ Fable 5.1 ไม่ใช่ความแม่นยำในการตอบครั้งเดียว แต่คือ ความสามารถในการรักษาความสม่ำเสมอระหว่างงาน agent ที่กินเวลานาน

โดยทั่วไป AI agent มักจะก่อให้เกิดปัญหาต่อไปนี้เมื่องานยาวขึ้น:

• ลืมเป้าหมายเริ่มต้น
• ทำเพียงการแก้ไขตามอาการโดยไม่สืบสวนสาเหตุ
• อ่านไฟล์หรือหน้าเว็บเดียวกันซ้ำๆ
• ลดขนาดงานตามอำเภอใจระหว่างทาง
• ประกาศว่า "จะทดสอบต่อไป" แล้วก็จบไปเฉยๆ
• ทำการเปลี่ยนแปลงครั้งใหญ่แต่ไม่ตรวจสอบการทำงานครั้งสุดท้าย

Fable 5.1 มุ่งเน้นอย่างมากในการปรับปรุงการพังทลายเหล่านี้ระหว่างการทำงานระยะยาว คำอธิบายอย่างเป็นทางการระบุว่าการเขียนโค้ด การทำงานของเบราว์เซอร์ การวิจัย และการสร้างเอกสาร/สเปรดชีต/สไลด์ที่กินเวลาหลายชั่วโมงถึงหลายวันเป็นกรณีการใช้งานหลัก มันถูกออกแบบมาให้กู้คืนจากขั้นตอนที่ล้มเหลว จัดลำดับความสำคัญใหม่ และดำเนินการต่อไปในขณะที่รักษาบันทึกการทำงานของตัวเอง (Anthropic

บริษัทที่นำไปใช้ในช่วงแรกได้รายงานกรณีต่อไปนี้:

ที่ MongoDB มีรายงานว่าสามารถตรวจสอบโค้ดบริการและเอกสารเพื่อสร้างการออกแบบใหม่ โดยทำงานอัตโนมัติเป็นเวลาหลายชั่วโมงจนเสร็จสิ้นต้นแบบที่ซับซ้อนในเวลาประมาณสามวัน ที่ Ramp มันทำงานต่อเนื่อง 38 ชั่วโมงในปัญหาการเรียนรู้ของเครื่อง ค้นพบปัญหาการติดฉลากในผลลัพธ์ที่ผ่านมา และดำเนินการทดลองหกครั้งแบบขนานหลังจากแก้ไข (Anthropic

นอกจากนี้ ในกรณีจาก Millennium มีรายงานว่าสำหรับข้อขัดข้องที่เกิดขึ้นเพียงครั้งเดียวในล้านครั้ง โมเดลได้แยกส่วนประกอบไลบรารีภายนอก ตรวจสอบข้ามกับ core dump และไปถึงสาเหตุที่ไม่มีใครค้นพบมานานหลายปี แม้ว่าสิ่งเหล่านี้จะเป็นเรื่องราวของลูกค้าบนหน้าเว็บทางการและไม่ใช่ผลลัพธ์ที่ทำซ้ำโดยหน่วยงานอิสระ แต่ก็แสดงให้เห็นทิศทางที่ Fable 5.1 มุ่งเป้าไปอย่างชัดเจน (Anthropic

พูดสั้นๆ คือ Fable 5.1 ไม่ใช่ "AI ที่เขียนโค้ดเยอะๆ" แต่เป็น:

หัวหน้าทีมที่รับผิดชอบซึ่งแยกปัญหาที่ยาก รวบรวมข้อมูลที่จำเป็น ลองหลายวิธี ตรวจสอบหลักฐาน และสุดท้ายรวบรวมผลลัพธ์

3. อะไรดีขึ้นใน Benchmark?

ตามคะแนนหลักที่เผยแพร่โดย Anthropic Fable 5.1 มีการเติบโตอย่างมีนัยสำคัญใน agent ระยะยาว การวิจัยทางวิทยาศาสตร์ และระบบอัตโนมัติทางธุรกิจ

ใน Terminal-Bench-Science 0.1 ซึ่งวัดงานเทอร์มินัลทางวิทยาศาสตร์ เพิ่มขึ้นจาก 24.7% ใน Fable 5 เป็น 52.6% ใน Terminal-Bench 4.0 ซึ่งวัดการเขียนโค้ด agent ทั่วไป ได้คะแนน 55.8% เทียบกับ 42.0% ของ Fable 5 Mythos 5.1 ซึ่งมีขีดจำกัดความปลอดภัยต่างกัน ได้คะแนน 60.9%

ใน AutomationBench ซึ่งวัดระบบอัตโนมัติทางธุรกิจ เพิ่มขึ้นจาก 17.1% ใน Fable 5 เป็น 31.4% ใน CursorBench 3.2 Fable 5.1 ได้คะแนน 73.4% เทียบกับ 70.5% ของ Fable 5 และ 70.0% ของ Opus 5

นอกจากนี้ ใน Humanity's Last Exam ซึ่งวัดการใช้เหตุผลขั้นสูงในหลายสาขา ได้คะแนน 60.9% โดยไม่มีเครื่องมือ และ 65.0% พร้อมเครื่องมือ (Anthropic

อย่างไรก็ตาม จำเป็นต้องใช้ความระมัดระวังในการอ่านตัวเลขเหล่านี้

สิ่งเหล่านี้เป็นผลการประเมินที่เผยแพร่โดย Anthropic ยิ่งไปกว่านั้น Fable มีตัวจำแนกประเภทความปลอดภัยในการผลิตเปิดใช้งานอยู่ ในปัญหาที่ตัวจำแนกประเภทเข้ามาแทรกแซง มันอาจได้คะแนนเป็นศูนย์ หรือกระบวนการอาจเปลี่ยนไปใช้โมเดลอื่น ดังนั้น ความแตกต่างระหว่าง Fable และ Mythos อาจรวมถึงความแตกต่างในการตั้งค่าความปลอดภัย มากกว่าแค่ความสามารถของโมเดลล้วนๆ (Anthropic

นอกจากนี้ ในช่วงวันหลังจากเปิดตัว สิ่งที่สำคัญมากกว่าการเป็นอันดับ 1 ใน benchmark คือ "อัตราความสำเร็จของงาน" ในงานจริงของคุณ

ตัวอย่างเช่น ในการผลิตบทความ การประเมินข้อความเพียงอย่างเดียวนั้นไม่เพียงพอ:

• มันสามารถตรวจสอบข้อเท็จจริงกับแหล่งข้อมูลปฐมภูมิได้หรือไม่?
• มันเป็นไปตามจำนวนตัวอักษรที่ระบุหรือไม่?
• มันลบความซ้ำซ้อนและความขัดแย้งออกไปหรือไม่?
• มันแยกความแตกต่างระหว่างการอ้างอิงและการสรุปความได้หรือไม่?
• มันสอดคล้องกันตั้งแต่ชื่อเรื่องจนถึงบทสรุปหรือไม่?

เว้นแต่คุณจะเตรียมการประเมินเชิงปฏิบัติเช่นนี้ การใช้ Fable ที่มีราคาแพงอาจส่งผลให้มันคิดเป็นเวลานานโดยไม่มีผลลัพธ์ที่ดีกว่า

4. Adaptive Thinking เปิดตลอดเวลาตอนนี้

ใน Fable 5.1 Adaptive Thinking เปิดตลอดเวลา

ต่างจากโมเดลก่อนหน้านี้ การคิดไม่สามารถปิดได้อย่างสมบูรณ์ การระบุ thinking: {type: "disabled"} ใน API จะทำให้เกิดข้อผิดพลาด วิธีการที่มนุษย์ระบุจำนวน token การคิดแบบตายตัวก็ไม่สามารถใช้ได้เช่นกัน โมเดลจะปรับปริมาณการคิดตามปัญหา (Claude Platform

สิ่งที่ผู้ใช้ปรับคือ "ความพยายาม"

มีห้าระดับให้เลือก:

• ต่ำ
• ปานกลาง
• สูง
• สูงมาก
• สูงสุด

ค่าเริ่มต้นคือสูง

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

Fable 5.1 กล่าวกันว่าสร้างประสิทธิภาพใกล้เคียงกับ Fable 5 รุ่นเก่าแม้ในระดับปานกลาง และในระดับต่ำ อาจมีอัตราส่วนต้นทุนต่อประสิทธิภาพที่ดีกว่าการรันโมเดลขนาดเล็กกว่าที่ความพยายามสูงสำหรับงานบางอย่าง (Claude Platform

สิ่งสำคัญที่นี่คือการคิดภายในจะถูกคิดเงินเป็น token เอาต์พุตและกิน max_tokens ด้วย

ตัวอย่างเช่น แม้ว่าต้นฉบับสุดท้ายที่แสดงบนหน้าจอจะเป็น 10,000 Token แต่ถ้ามันใช้ Token เทียบเท่า 10,000 Token ในการคิดก่อนหน้านั้น รวมทั้งหมด 20,000 Token จะถูกเรียกเก็บเงินทางฝั่งเอาต์พุต เนื่องจากราคาต่อหน่วยเอาต์พุตของ Fable อยู่ที่ $50 ต่อ 1 ล้าน Token การใช้ max โดยไม่จำเป็นจะทำให้การบริโภคเพิ่มขึ้นอย่างรวดเร็ว (Claude Platform

Fable 5.1 ไม่ใช่โมเดลที่ "ความพยายามสูงกว่าย่อมให้ผลกำไรเสมอ"

การใช้ max สำหรับการจัดรูปแบบข้อความหรือการสรุปความอาจเพิ่มกรณีที่โมเดลเขียนร่างภายในแล้วเขียนอีกครั้งในฟิลด์คำตอบเท่านั้น Anthropic ยังแนะนำให้ใช้สูงสำหรับงานที่ส่งมอบระยะยาวตามหลักการ และอัปเกรดเป็นสูงมากหรือสูงกว่าได้ก็ต่อเมื่อสามารถวัดการปรับปรุงคุณภาพได้ (Claude Platform

5. ราคาสูง แต่แคชถูกมาก

อัตรามาตรฐานของ Fable 5.1 คือ $10 ต่อ 1 ล้าน Token อินพุต และ $50 ต่อ 1 ล้าน Token เอาต์พุต

เนื่องจาก Opus 5 อยู่ที่ $5/$25 และ Sonnet 5 อยู่ที่ $2/$10 ดังนั้น Fable จึงมีราคาเป็นสองเท่าของ Opus และห้าเท่าของ Sonnet ในแง่ของการกำหนดราคา Token อย่างง่าย (Claude Platform Docs

ในทางกลับกัน การเปลี่ยนแปลงครั้งใหญ่ใน Fable 5.1 คือราคาอ่านแคช

ในขณะที่ Fable 5 อยู่ที่ $1 ต่อ 1 ล้าน Token แต่ Fable 5.1 กลายเป็น $0.25 ซึ่งคิดเป็น 2.5% ของราคาอินพุตปกติ Anthropic ประมาณว่าในการประมวลผลทั่วไป จะส่งผลให้ต้นทุนลดลงประมาณ 25% เมื่อเทียบกับ Fable รุ่นเก่า และสูงถึงประมาณ 45% สำหรับการประมวลผล agent ที่อ่านแคชซ้ำๆ (Anthropic

ตัวอย่างเช่น หากคุณอ่านบริบทคงที่ 100,000 Token ทุกครั้ง จะมีค่าใช้จ่าย $0.10 ต่อครั้งในอัตราอินพุตปกติ แต่เพียง $0.0025 หากเป็นการเข้าถึงแคช

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

ในทางกลับกัน การใช้งานที่เขียน system prompt ใหม่ทุกครั้ง จัดลำดับรายการเครื่องมือใหม่ หรือลบและสร้างประวัติการสนทนาเก่าขึ้นมาใหม่จะทำให้แคชเสีย

ใน Fable 5.1 โครงสร้างพรอมต์ที่ไม่ทำให้แคชเสีย นั้นเชื่อมโยงกับต้นทุนโดยตรงมากกว่าพรอมต์ที่ชาญฉลาด

6. Fable 5.1 อาจทำให้ Harness API ที่มีอยู่พัง

เมื่อเปลี่ยนเฉพาะชื่อโมเดลจาก Fable 5 หรือ Opus มีสามประเด็นที่ต้องระวังเป็นพิเศษ:

การบังคับเรียกใช้เครื่องมือไม่พร้อมใช้งาน

การบังคับ any หรือชื่อเครื่องมือเฉพาะใน tool_choice จะทำให้เกิดข้อผิดพลาด 400

เหตุผลคือการบังคับให้เรียกใช้เครื่องมือทำให้โมเดลข้ามกระบวนการคิดปกติและเริ่มคิดภายในอาร์กิวเมนต์ของเครื่องมือ ซึ่งทำให้คุณภาพของอาร์กิวเมนต์ลดลง

ให้ใช้ tool_choice: auto และระบุอย่างชัดเจนว่า "โปรดใช้เครื่องมือ XX สำหรับกระบวนการนี้" ภายในพรอมต์แทน หากคุณต้องการรับประกันรูปแบบ JSON ให้ใช้ strict: true หรือ Structured Outputs (Claude Platform

ประวัติการสนทนาต้องไม่ถูกเขียนทับระหว่างทาง

บล็อกการคิดใน Fable 5.1 นั้นเชื่อมโยงกับ system prompt เครื่องมือ และข้อความในอดีต ณ เวลาที่สร้างการคิดนั้น

หากคุณลบข้อความเก่า สร้าง system prompt ใหม่ หรือเขียนทับคำจำกัดความของเครื่องมือเก่าระหว่างทาง บล็อกการคิดที่ตามมาจะใช้ไม่ได้ สำหรับบัญชีใหม่ กลไกที่ทำให้การละเมิดเงื่อนไขนี้เป็นข้อผิดพลาดได้ถูกนำไปใช้แล้ว (Claude Platform

หลักการพื้นฐานคือ อย่าแก้ไขประวัติ ให้เพิ่มต่อท้ายเท่านั้น

ควรเพิ่มคำแนะนำชั่วคราวเป็นข้อความระบบตามรอบ และควรจัดระเบียบบริบทแบบยาวโดยใช้ server-side compaction หรือการแก้ไขบริบท

การคิดภายในไม่สามารถถ่ายโอนได้เมื่อเปลี่ยนกลับไปใช้โมเดลที่ถูกกว่า

Fable 5.1 สามารถอ่านบล็อกการคิดที่สร้างโดยโมเดลก่อนหน้า เช่น Opus 5, Fable 5 หรือ Sonnet

อย่างไรก็ตาม สิ่งที่ตรงกันข้ามนั้นเป็นไปไม่ได้ หากคุณส่งบล็อกการคิดที่สร้างโดย Fable 5.1 ไปยัง Opus หรือ Sonnet โมเดลเหล่านั้นจะไม่สามารถอ่านได้ (Claude Platform Docs

ดังนั้น หากคุณสลับโมเดลภายในบทสนทนาเดียวกัน ลำดับต่อไปนี้โดยทั่วไปปลอดภัย:

สำรวจด้วยโมเดลราคาถูก → เลื่อนระดับเป็น Fable

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

7. ข้อจำกัดด้านความปลอดภัยและการเก็บรักษาข้อมูล

ใน Fable 5.1 คำขอบางอย่างเกี่ยวกับความปลอดภัยทางไซเบอร์หรือวิทยาศาสตร์ชีวภาพถูกจำกัดโดยตัวจำแนกประเภทความปลอดภัย

ในแอป Claude มาตรฐาน กระบวนการที่เกี่ยวข้องอาจถูกส่งต่อไปยัง Opus 4.8 หรือ Opus 5 โดยอัตโนมัติ ใน API คุณต้องตั้งค่า fallback คุณจะไม่ถูกเรียกเก็บเงินในอัตรา Fable สำหรับกระบวนการที่เปลี่ยนไปใช้โมเดลอื่น (Anthropic

นอกจากนี้ โดยทั่วไป Fable 5.1 ต้องการการเก็บรักษาข้อมูล 30 วัน เว้นแต่คุณจะได้รับอนุญาตอย่างชัดแจ้งจาก Anthropic ไม่สามารถใช้ในสภาพแวดล้อม Zero Data Retention มาตรฐานได้

เมื่อจัดการกับโค้ดลับของบริษัท ข้อมูลลูกค้า หรือเอกสารการวิจัยที่ไม่ได้เผยแพร่ คุณควรนำมาใช้หลังจากยืนยันสัญญาและเงื่อนไขการเก็บรักษาแล้วเท่านั้น ไม่ใช่แค่ใช้ "เพราะประสิทธิภาพสูง" (Claude Platform

8. ท้ายที่สุดแล้ว ใครต้องการ Fable 5.1?

Fable 5.1 มีไว้สำหรับคนที่ อัตราความสำเร็จของงานทั้งหมด ไม่ใช่การตอบสนองของโมเดลเพียงครั้งเดียว คือคุณค่า

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

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

Anthropic เองแนะนำให้เริ่มการประมวลผลทั่วไปด้วย Opus 5 และอัปเกรดเป็น Fable ก็ต่อเมื่อคุณภาพไม่เพียงพอแม้จะรัน Opus ที่ความพยายามสูงแล้วก็ตาม (Claude Platform Docs

Fable 5.1 ไม่ใช่ "โมเดลมาตรฐานสำหรับทุกคนที่จะใช้ตั้งแต่เริ่มต้น" แต่เป็นโมเดลระดับสูงสำหรับฝ่าฟันจุดที่ยาก

ส่วนที่ 2: การประหยัด Token พรอมต์ Harness และการสร้างทักษะ

1. เทคนิคการประหยัด Token สำหรับ Fable 5.1

เคล็ดลับการประหยัด 1: อย่าให้ Fable ทำทุกอย่างตั้งแต่การสำรวจ

วิธีการประหยัดที่มีประสิทธิภาพที่สุดไม่ใช่การเขียนประโยคสั้นๆ

มันคือ การลดจำนวนครั้งที่คุณเรียกใช้ Fable เอง

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

ใช้ Fable สำหรับขั้นตอนเหล่านี้:

• การตัดสินนโยบายการวิจัย
• การเลือกสมมติฐานที่มีแนวโน้มมากที่สุดจากหลายๆ ข้อ
• การบูรณาการข้อมูลที่ขัดแย้งกัน
• การระบุสาเหตุที่แท้จริง
• การตรวจสอบผลงานส่งมอบขั้นสุดท้าย
• การตรวจสอบปัญหาที่โมเดลอื่นล้มเหลวอีกครั้ง

เอกสารทางการยังแนะนำการกำหนดค่าโดยใช้หลายโมเดล โดยใช้โมเดลราคาถูกเป็นผู้ดำเนินการ และโมเดลระดับสูงเป็นที่ปรึกษาหรือผู้ดูแล (Claude Platform Docs

เคล็ดลับการประหยัด 2: เปลี่ยนความพยายามในแต่ละขั้นตอน

คุณไม่จำเป็นต้องตั้งค่าทั้งเซสชันเป็นสูงสุด

ฉันแนะนำการจัดสรรดังนี้:

Fable 5.1 ยังมีกลไกในการเปลี่ยนความพยายามระหว่างการสนทนา แทนที่จะเขียนทับการตั้งค่าระดับบนสุด การเพิ่มการเปลี่ยนแปลงความพยายามเป็นข้อความระบบระหว่างทางจะช่วยให้คุณรักษาแคชพรอมต์ไว้ได้ (Claude Platform

แนวทางที่ถูกต้องไม่ใช่ "ความสามารถสูงสุดตลอดเวลา" แต่คือ "ความสามารถสูงสุดเฉพาะสำหรับการเคลื่อนไหวที่ยาก"

เคล็ดลับการประหยัด 3: เก็บประวัติแบบต่อท้ายเท่านั้นเพื่อปกป้องแคช

ใน Fable 5.1 ให้เก็บเนื้อหาต่อไปนี้ให้คงที่:

• System prompt
• คำจำกัดความของเครื่องมือและลำดับ
• กฎทั่วไปของโครงการ
• ข้อความในอดีต
• บล็อกการคิด

เพิ่มการเปลี่ยนแปลงทั้งหมดต่อท้าย

หากคุณกำลังสร้าง API ของคุณเอง การรักษาคำนำหน้าแบบไบต์ต่อไบต์เดียวกันนั้นปลอดภัยกว่าการประกอบ system prompt ใหม่ทุกครั้ง

ใน Claude Code การประมวลผลแคช基本上是自動化的 แต่คุณสามารถใช้ cache_control ใน API สำหรับการสนทนาหลายรอบ ให้ใช้การแคชอัตโนมัติ สำหรับการแยกวัสดุคงที่แบบยาว ให้ใช้ขอบเขตแคชที่ชัดเจน (Claude

เคล็ดลับการประหยัด 4: อย่าส่งเอาต์พุตของเครื่องมือตามที่เป็น

การส่งบันทึก 10,000 บรรทัดให้ Claude และขอให้ "หาข้อผิดพลาด" นั้นสิ้นเปลือง

กรองมันก่อนด้วยสคริปต์หรือ hooks

คู่มือต้นทุนอย่างเป็นทางการของ Claude Code ยังแนะนำให้ประมวลผลบันทึกยาวๆ ล่วงหน้าด้วย hooks และส่งเฉพาะสองสามร้อยบรรทัดที่จำเป็นให้กับโมเดล นอกจากนี้ยังอธิบายว่าการใช้ CLI เช่น gh, aws หรือ gcloud เมื่อมีให้นั้นง่ายกว่าสำหรับการระงับการใช้บริบทจากคำจำกัดความของเครื่องมือมากกว่าการเชื่อมต่อเซิร์ฟเวอร์ MCP จำนวนมาก (Claude

ก่อนที่จะให้ AI อ่าน ให้ตัดสิ่งที่สามารถตัดได้โดยเครื่องจักรก่อน

เคล็ดลับการประหยัด 5: จัดกลุ่มการเรียกใช้เครื่องมือที่เป็นอิสระ

เมื่ออ่านไฟล์ห้าไฟล์ หากคุณแบ่งเป็นห้ารอบโดยอ่านทีละไฟล์ ประวัติการสนทนาจะถูกส่งทุกครั้ง

การรวมคำสั่งต่อไปนี้ใน Fable 5.1 นั้นมีประสิทธิภาพ:

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

Anthropic ยังอธิบายว่าการสนับสนุนให้จัดกลุ่มการเรียกใช้เครื่องมืออิสระในการตอบสนองครั้งเดียว คุณสามารถลดรอบ Token และเวลารอได้ (Claude Platform

เคล็ดลับการประหยัด 6: อย่าปล่อยให้มันเขียนไฟล์ใหม่ทั้งหมดเพื่อการแก้ไขเล็กน้อย

Fable 5.1 อาจเขียนไฟล์ใหม่ทั้งหมดแม้จะเปลี่ยนแปลงเพียงเล็กน้อย

รวมประโยคนี้ในกฎทั่วไปของคุณ:

"หากผลลัพธ์สุดท้ายไม่เปลี่ยนแปลง อย่าเขียนไฟล์ใหม่ทั้งหมด ให้แก้ไขเฉพาะส่วนที่จำเป็นด้วย diff ที่น้อยที่สุด"

วิธีนี้มีประสิทธิภาพโดยเฉพาะสำหรับ Markdown แบบยาว, JSON, ไฟล์คอนฟิก, LP และซอร์สโค้ดขนาดใหญ่ การป้องกันการสร้างใหม่ทั้งหมดจะช่วยระงับ Token เอาต์พุตและภาระในการตรวจสอบ diff (Claude Platform

เคล็ดลับการประหยัด 7: อย่าทำงานที่ไม่เกี่ยวข้องต่อในเซสชันเดียวกัน

ใน Claude Code ให้ใช้ /clear เมื่อย้ายไปทำงานที่ไม่เกี่ยวข้อง

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

หากคุณไม่ต้องการทำให้ประวัติเสียด้วยคำถามชั่วคราว ให้ใช้ /btw หากคุณต้องการเก็บเฉพาะเนื้อหาที่จำเป็น ให้ใช้ /compact โอนการสำรวจโค้ดเบสไปยัง subagent และส่งเฉพาะบทสรุปกลับไปยังการสนทนาหลัก (Claude

2. พรอมต์เชิงปฏิบัติสำหรับ Fable 5.1

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

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

บทบาท

คุณคือผู้รับผิดชอบในการดำเนินการตามคำขอนี้ให้เสร็จสมบูรณ์

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

วัตถุประสงค์

[เขียนผลิตภัณฑ์สุดท้ายที่จะสร้างหรือปัญหาที่จะแก้ไข]

อินพุต

[เขียนไฟล์, URL, วัสดุ และข้อกำหนดเบื้องต้น]

ขอบเขต

สิ่งที่ต้องทำ:

• [งานบังคับ]
• [งานบังคับ]

สิ่งที่ไม่ต้องทำ:

• [นอกขอบเขต]
• [เนื้อหาที่คุณไม่ต้องการให้เปลี่ยนแปลงตามอำเภอใจ]

เงื่อนไขความสำเร็จ

งานจะเสร็จสมบูรณ์เมื่อตรงตามเงื่อนไขทั้งหมดต่อไปนี้:

1. [เงื่อนไขสำหรับฟังก์ชัน/เนื้อหา]
2. [เงื่อนไขสำหรับรูปแบบ/จำนวนตัวอักษร/คุณภาพ]
3. [วิธีการตรวจสอบ]
4. [หลักฐานที่แสดงว่าไม่มีข้อผิดพลาด]

กฎการดำเนินการ

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

รายงานสุดท้าย

สุดท้าย ให้รายงานโดยย่อตามลำดับต่อไปนี้:

1. สิ่งที่เสร็จสมบูรณ์
2. การเปลี่ยนแปลงที่ทำ
3. ผลการตรวจสอบและหลักฐาน
4. ปัญหาที่เหลืออยู่
5. ตัวเลือกการปรับปรุงที่สังเกตเห็นแต่อยู่นอกขอบเขต

Fable 5.1 สามารถทำงานต่อไปได้เป็นเวลานาน แต่ถ้ามันคลุมเครือว่าอะไรคือความสำเร็จ มันจะสำรวจต่อไปมากกว่าที่จำเป็น

ดังนั้น การเขียนเงื่อนไขความสำเร็จและการหยุด จึงสำคัญกว่าการพูดว่า "คิดให้ลึกซึ้ง"

3. การออกแบบ Harness เพื่อใช้ประโยชน์จาก Fable 5.1

Harness คือกลไกการทำงานที่อยู่รอบๆ โมเดล

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

ฉันแนะนำโครงสร้าง 6 ชั้นดังนี้:

ชั้นที่ 1: กฎทั่วไป

ใน CLAUDE.md ให้ใส่เฉพาะข้อเท็จจริงของโครงการที่จำเป็นทุกครั้ง

โครงการ

• พื้นที่เก็บนี้มีไว้สำหรับบริการ XX
• สภาพแวดล้อมการผลิตคือ XX
• ใช้ pnpm สำหรับการจัดการแพ็คเกจ

การตรวจสอบที่จำเป็น

• pnpm lint หลังการเปลี่ยนแปลง
• pnpm test หลังการเปลี่ยนแปลง
• การตรวจสอบประเภทเมื่อมีการเปลี่ยนแปลง API

ข้อจำกัด

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

เนื่องจาก CLAUDE.md ถูกอ่านในทุกเซสชัน การทำให้ยาวเกินไปจะกินบริบททุกครั้ง เอกสารทางการแนะนำให้เก็บไฟล์เดียวให้ต่ำกว่า 200 บรรทัด และย้ายขั้นตอนยาวๆ ไปไว้ใน Skills (Claude

เลเยอร์ 2: เราเตอร์

เมื่อได้รับคำขอ ให้จัดประเภทของงานแทนที่จะเริ่ม Fable ทันที

• การแยกข้อมูล/จัดรูปแบบอย่างง่าย -> Haiku หรือสคริปต์
• การใช้งาน/วิจัยทั่วไป -> Sonnet
• การออกแบบ/วิเคราะห์ที่ซับซ้อน -> Opus
• งานระยะยาว/ปัญหาที่ยาก -> Fable
• เฉพาะจุดที่ยากและล้มเหลว -> Fable xhigh

เมื่อสร้างเราเตอร์อัตโนมัติ ให้ตัดสินโดยพิจารณาจาก "ความเสียหายหากผิดพลาด" "เวลาทำงานอัตโนมัติที่ต้องการ" และ "ความยากในการตรวจสอบ" มากกว่าราคา

เลเยอร์ 3: หัวหน้าการสำรวจ

แยกการสำรวจโค้ด การรวบรวมวัสดุ และการวิจัยคู่แข่งออกเป็นซับเอเจนต์

ซับเอเจนต์แต่ละตัวทำงานในบริบทที่เป็นอิสระ และส่งคืนเฉพาะข้อสรุปและหลักฐานให้กับเอเจนต์หลักเท่านั้น วิธีนี้ป้องกันไม่ให้ผลการอ่านไฟล์หลายสิบไฟล์ทำให้ประวัติหลักพองตัว (Claude

เลเยอร์ 4: หัวหน้างาน Fable

Fable ตัดสินใจโดยใช้ผลลัพธ์ที่ส่งกลับมาจากหัวหน้าการสำรวจ

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

แทนที่จะให้ Fable รับผิดชอบทุกอย่างจนถึงการรวบรวมข้อมูลดิบ ให้ส่งหลักฐานที่จัดระเบียบแล้วให้มัน และปล่อยให้มันมุ่งเน้นที่การตัดสินใจ

เลเยอร์ 5: การตรวจสอบแบบกำหนดตายตัว

อย่าปล่อยให้การตรวจสอบขึ้นอยู่กับพรอมพ์เพียงอย่างเดียว

• สำหรับโค้ด: การทดสอบ, Lint, การตรวจสอบชนิดข้อมูล
• สำหรับบทความ: จำนวนตัวอักษร, สำนวนที่ซ้ำกัน, URL, การอ้างอิง
• สำหรับสเปรดชีต: ข้อผิดพลาดของสูตร, ค่าที่หายไป, ยอดรวม
• สำหรับ LP: ลิงก์, เลย์เอาต์ที่พัง, การเปรียบเทียบภาพหน้าจอ

การใช้ hooks คุณสามารถเรียกใช้การตรวจสอบก่อนและหลังการดำเนินการเครื่องมือ แทนที่จะเดิมพันว่า LLM จะจำต้องตรวจสอบ ให้ดำเนินการโดยอัตโนมัติภายใต้เงื่อนไขที่กำหนดตายตัว (Claude Platform Docs

เลเยอร์ 6: วงจรการซ่อมแซม

กลับไปที่ Fable เฉพาะเมื่อการตรวจสอบล้มเหลว

การสร้าง -> การตรวจสอบเชิงกล -> สำเร็จ (เสร็จสมบูรณ์) / ล้มเหลว -> วิเคราะห์สาเหตุ -> แก้ไขน้อยที่สุด -> ตรวจสอบซ้ำ

สิ่งสำคัญคืออย่าวนซ้ำไม่รู้จบ

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

สำหรับกระบวนการที่ใช้ซับเอเจนต์หลายสิบถึงหลายร้อยตัว ให้ย้ายไปใช้ Dynamic Workflow แทนที่จะปล่อยให้ Claude จัดการตามลำดับ ใน Workflow คุณสามารถเก็บผลลัพธ์ระหว่างกลางไว้ในตัวแปรสคริปต์ และส่งคืนเฉพาะผลลัพธ์สุดท้ายไปยังบริบทหลัก ทำให้เหมาะสำหรับการวิจัยขนาดใหญ่หรือการประมวลผลไฟล์จำนวนมาก (Claude

4. Skills ไม่ใช่ "พื้นที่เก็บพรอมพ์ยาว"

Skills เป็นกลไกในการบันทึกขั้นตอนการทำงานที่ใช้ซ้ำเป็น SKILL.md

ความแตกต่างจาก CLAUDE.md คือเนื้อหาจะถูกอ่านเมื่อจำเป็นเท่านั้น

• ข้อมูลโครงการและกฎสั้นๆ ที่ต้องปฏิบัติตามเสมอ: CLAUDE.md
• ขั้นตอนสำหรับการผลิตบทความ, การปรับใช้, การวิจัย, การตรวจสอบ ฯลฯ: Skills
• ตัวอย่างหรือข้อกำหนดจำนวนมาก: ไฟล์อ้างอิงสำหรับ Skills

การแยกนี้เชื่อมโยงโดยตรงกับการประหยัดโทเค็น (Claude Platform Docs

ฉันขอแนะนำโครงสร้างดังต่อไปนี้:

1.claude/
2├── CLAUDE.md
3├── skills/
4│   └── deep-article/
5│       ├── SKILL.md
6│       ├── research-rules.md
7│       ├── writing-rules.md
8│       ├── examples.md
9│       └── scripts/
10│           ├── count_chars.py
11│           └── check_repetition.py
12├── agents/
13│   ├── researcher.md
14│   └── critic.md
15└── settings.json

ใน SKILL.md ให้วางเฉพาะภาพรวม เงื่อนไขการดำเนินการ ขั้นตอน และเงื่อนไขความสำเร็จ

แยกคำอธิบายจำนวนมาก ข้อกำหนด API และเรื่องราวความสำเร็จออกเป็นไฟล์ต่างๆ และให้ Claude อ่านเมื่อจำเป็นเท่านั้น เอกสารทางการแนะนำให้เก็บ SKILL.md ไว้ต่ำกว่า 500 บรรทัด และแยกวัสดุที่มีรายละเอียดออกเป็นไฟล์สนับสนุน (Claude Platform Docs

5. เทมเพลต SKILL.md ที่ใช้งานได้จริง

ด้านล่างนี้คือตัวอย่างของ Skill สำหรับการสร้างบทความวิจัย

name: deep-article

description: ค้นคว้าข้อมูลปฐมภูมิและสร้างบทความแนวยาวพร้อมหลักฐาน ใช้เมื่อมีการร้องขอคำอธิบายอย่างละเอียดเกี่ยวกับ AI, บริษัท, ระบบ หรือผลิตภัณฑ์ล่าสุด

argument-hint: "[หัวข้อ] [จำนวนตัวอักษรเป้าหมาย]"

effort: high

วัตถุประสงค์

สร้างบทความแนวยาวที่ตรวจสอบข้อเท็จจริงเกี่ยวกับ $ARGUMENTS

กฎพื้นฐาน

• ค้นหาเสมอว่าข้อมูลล่าสุดเกี่ยวข้องหรือไม่
• ให้ความสำคัญกับข้อมูลปฐมภูมิ
• แยกแยะระหว่างข้อเท็จจริง ประกาศของบริษัท การประเมินของบุคคลที่สาม และการคาดเดา
• แนบช่วงเวลาเป้าหมายและคำจำกัดความกับตัวเลข
• อย่าพูดซ้ำข้อสรุปหรือตัวอย่างเดียวกัน
• อธิบายคำศัพท์เทคนิคเมื่อกล่าวถึงครั้งแรก
• อย่าจบด้วยจำนวนตัวอักษรน้อยกว่า 90% ของจำนวนที่ระบุ
• สุดท้าย รายงานจำนวนตัวอักษรและรายการที่ไม่ได้รับการตรวจสอบ

ขั้นตอนการทำงาน

1. แบ่งหัวข้อออกเป็น 3-7 จุดวิจัย
2. ค้นคว้าจุดที่เป็นอิสระแบบขนาน
3. รวบรวมข้อมูลปฐมภูมิ
4. ตรวจสอบหลักฐานค้านหรือข้อมูลที่ไม่เอื้ออำนวย
5. สร้างรายการข้อเท็จจริง
6. ตัดสินใจโครงสร้าง
7. สร้างร่างแรก
8. ตรวจสอบความซ้ำซ้อน การข้ามประเด็น การอ้างอิง วันที่ และตัวเลข
9. แก้ไข
10. ตรวจสอบจำนวนตัวอักษร

เงื่อนไขความสำเร็จ

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

วัสดุที่ต้องอ่านเมื่อจำเป็นเท่านั้น

• มาตรฐานการวิจัย: research-rules.md
• มาตรฐานรูปแบบ: writing-rules.md
• ตัวอย่างที่ดี: examples.md

การตรวจสอบขั้นสุดท้าย

ดำเนินการดังต่อไปนี้:

• python ${CLAUDE_SKILL_DIR}/scripts/count_chars.py <output-file>
• python ${CLAUDE_SKILL_DIR}/scripts/check_repetition.py <output-file>

คำอธิบายของ Skill ทำหน้าที่เป็นเราเตอร์ ไม่ใช่แค่คำอธิบาย

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

เนื่องจาก Claude Code ใส่รายการคำอธิบาย Skill ลงในบริบท การเขียนคำอธิบายจำนวนมากจะเพิ่มต้นทุนคงที่ ใส่การใช้งานที่สำคัญไว้ที่ตอนต้นและทำให้สั้น (Claude Platform Docs

6. การใช้งาน Skills ขั้นสูง

Skills ที่ต้องไม่ถูกดำเนินการอัตโนมัติ

การปรับใช้ การส่ง การลบ การเผยแพร่ และการชำระเงินต้องไม่เริ่มต้นโดย Claude ตามอำเภอใจ

ตั้งค่า disable-model-invocation: true และเรียกใช้เฉพาะเมื่อผู้ใช้ป้อน /deploy ฯลฯ อย่างชัดเจน

Skills ที่ไม่ควรทำให้การสนทนาปนเปื้อน

สำหรับ Skills ที่ทำการวิจัยจำนวนมากหรือการสำรวจโค้ด ให้ตั้งค่า context: fork

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

Skills ที่ฉีดสถานะปัจจุบันอัตโนมัติ

ภายใน Skill คุณสามารถแทรกผลลัพธ์ของคำสั่งล่วงหน้าได้

สถานะปัจจุบัน

!git status --short

!git diff --stat

Claude ได้รับผลลัพธ์การดำเนินการ ไม่ใช่สตริงคำสั่ง

อย่างไรก็ตาม การฉีด git diffs แบบเต็มหรือบันทึกจำนวนมากทุกครั้งนั้นไร้ประโยชน์ ใส่เฉพาะ --stat หรือบรรทัดข้อผิดพลาดก่อน และให้อ่านรายละเอียดเมื่อจำเป็นเท่านั้น (Claude Platform Docs

การตั้งค่า effort สำหรับ Skills

ตั้งค่า Skills ธรรมดาเป็น medium การตรวจสอบการออกแบบและการวิจัยเชิงลึกเป็น high และการตรวจสอบที่ยากมากเป็น xhigh

หากคุณให้ effort ของตัวเองกับแต่ละ Skill ผู้ใช้ไม่จำเป็นต้องสลับทุกครั้ง

7. ประเมิน Skills เชิงเปรียบเทียบเสมอ

การสร้าง Skill เพียงอย่างเดียวไม่ได้บอกคุณว่าคุณภาพดีขึ้นหรือไม่

เอกสารทางการแนะนำให้ประเมินสองสิ่งแยกกัน:

1. Skill เริ่มต้นอย่างถูกต้องสำหรับคำขอที่จำเป็นหรือไม่
2. ผลลัพธ์ที่ได้ดีขึ้นจริงหรือไม่จากการเริ่มต้น

ดำเนินการคำขอเดียวกันในเซสชันใหม่ทั้ง "มี Skill" และ "ไม่มี Skill"

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

การทดสอบในการสนทนาต่อเนื่องที่คุณสร้าง Skill จะซ่อนข้อบกพร่องด้วยข้อมูลเสริมจากการสนทนา ประเมินในเซสชันใหม่เสมอ Claude Code ยังมีปลั๊กอิน skill-creator อย่างเป็นทางการเพื่อสนับสนุนการเปรียบเทียบนี้ (Claude Platform Docs

บทสรุปสุดท้าย

Claude Fable 5.1 ไม่ใช่โมเดลที่ทำให้ซีรีส์ Claude เร็วขึ้นเท่านั้น

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

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

ดังนั้น วิธีที่แข็งแกร่งที่สุดในการใช้งานมีดังนี้:

**จำกัดข้อมูลให้แคบลงด้วย Sonnet หรือสคริปต์

แยกการสำรวจด้วยซับเอเจนต์

มอบหมาย Fable ให้กับการตัดสินใจที่ยากและการรวมเข้าด้วยกัน

ตรวจสอบด้วยกลไกด้วย hooks และการทดสอบ

เพิ่ม effort สำหรับจุดที่ยากและล้มเหลวเท่านั้น

บันทึกขั้นตอนที่ทำซ้ำใน Skills

เก็บประวัติการสนทนาแบบ append-only เพื่อปกป้องแคช**

หากคุณใช้ Fable 5.1 เป็น "แชทระดับสูงที่ตอบได้ทุกอย่าง" ราคาจะสูงเท่านั้น

ความแตกต่างที่แท้จริงจากรุ่นก่อนหน้าจะเกิดขึ้นก็ต่อเมื่อคุณวางตำแหน่ง Fable 5.1 เป็นหัวหน้างานที่รวมโมเดลราคาถูก, Skills, ซับเอเจนต์, hooks และวงจรการตรวจสอบเข้าด้วยกัน