บล็อก
แผงควบคุม

CLAUDE.md หลัง Opus 5: ทำไมคำสั่งยาว ๆ จึงขัดขวางการทำงานของ Claude

Markdown

Claude Opus 5 ฉลาดขึ้น และกฎเก่า ๆ ที่ยืดยาวใน CLAUDE.md กำลังขัดขวางการทำงานของมัน ควรเก็บอะไรไว้ ย้ายอะไรไปไว้ในสกิล และเปิดใช้หน่วยความจำอัตโนมัติอย่างไร พร้อมพรอมป์ต์ที่นำไปใช้ได้ทันที

อ่านบทความฉบับเต็ม

ประเด็นสำคัญ

Claude Opus 5 เปิดตัวเมื่อวันที่ 24 กรกฎาคม 2026 และ Anthropic ก็ทำสิ่งที่ขัดกับสามัญสำนึก นั่นคือเอาคำสั่งออกจาก system prompt ของ Claude Code มากกว่า 80% แนวคิดนั้นเรียบง่าย: โมเดลฉลาดขึ้นแล้ว และกฎที่ตายตัวเพิ่มเติมกลับขัดขวางการทำงานของมัน เรื่องเดียวกันนี้ใช้กับ CLAUDE.md ของคุณด้วย ฉันจะอธิบายว่าควรเอาอะไรออก ย้ายอะไรไปไว้ในสกิล และเปิดใช้หน่วยความจำอัตโนมัติอย่างไร เพื่อให้ Claude ทำตามคำสั่งได้ดีขึ้นอีกครั้ง

ดูข้อมูลเกี่ยวกับการใช้งาน Ailoot ได้ในเอกสารประกอบ

Claude เปลี่ยนไปอย่างไรหลัง Opus 5 เปิดตัว?

ประเด็นสำคัญ

เมื่อมี Opus 5 Anthropic ก็เปลี่ยนแนวทางการสั่งงานโมเดล ก่อนหน้านี้ Claude Code มี system prompt ขนาดใหญ่มากซึ่งมีกฎหลายร้อยข้อ ในเวอร์ชันใหม่ เนื้อหาถูกตัดออกไปมากกว่า 80% โดยคุณภาพการเขียนโค้ดไม่ลดลง เหตุผลคือโมเดลรุ่นที่ห้าฉลาดพอจะตัดสินใจจากบริบทได้แล้ว จึงไม่จำเป็นต้องมีรายการคำสั่งที่ตายตัว

Opus 5 เปิดตัวเมื่อวันที่ 24 กรกฎาคม 2026 และกลายเป็นโมเดลเริ่มต้นใน Claude Code ทันที ตัวโมเดลเอง ทั้งราคา เกณฑ์วัดประสิทธิภาพ และโหมดความพยายาม มีอธิบายโดยละเอียดในคู่มืออีกฉบับ “Should You Switch to Claude Opus 5?” บทความนี้พูดถึงอีกเรื่องหนึ่ง นั่นคือการเปิดตัวโมเดลยังเปลี่ยน วิธีพูดคุยกับโมเดลให้ได้ผล ด้วย

Anthropic เผยแพร่บทวิเคราะห์บนบล็อกของ Claude ประเด็นหลักมีดังนี้:

เราลบเนื้อหากว่า 80% ออกจาก system prompt ของ Claude Code และไม่เห็นว่าคุณภาพงานเขียนโค้ดลดลงอย่างเห็นได้ชัด เราจำกัด Claude มากเกินไป

— Anthropic, https://claude.com/blog/the-new-rules-of-context-engineering-for-claude-5-generation-models

วลีสำคัญคือ “จำกัดมากเกินไป” เมื่อโมเดลยังอ่อนกว่า พวกมันต้องการโครงค้ำช่วยกำกับ: ทำแบบนี้ อย่าทำแบบนั้น นี่คือตัวอย่าง แล้วก็ย้ำอีกครั้ง Opus 5 ไม่ต้องการโครงค้ำเหล่านั้นแล้ว และที่แย่กว่านั้นคือมันอาจเริ่มขัดขวางการทำงานของโมเดล Anthropic กล่าวถึงหลักการใหม่นี้อย่างเรียบง่ายว่า ให้ Claude ใช้วิจารณญาณของตัวเอง

ในทางปฏิบัติ เรื่องนี้หมายความว่าอย่างไรสำหรับคุณ?

  • CLAUDE.md ของคุณเป็น system prompt แบบเดียวกัน แต่ใช้กับโปรเจกต์ของคุณ หาก Anthropic ลดของตัวเองลง 80 เปอร์เซ็นต์ ของคุณก็น่าจะมีเนื้อหามากเกินไปเช่นกัน
  • รายการกฎยาว ๆ ไม่ได้รับประกันว่าโมเดลจะทำตามอีกต่อไป ตรงกันข้าม ยิ่งมีบรรทัดมาก โมเดลก็ยิ่งทำตามได้ไม่ครบถ้วน (ด้านล่างจะอธิบายเพิ่ม พร้อมตัวเลขจากเอกสารประกอบ)
  • มีกลไกใหม่เกิดขึ้น ได้แก่ หน่วยความจำอัตโนมัติและสกิล ซึ่งช่วยรับช่วงงานบางส่วนที่คุณเคยต้องเขียนอธิบายเองใน CLAUDE.md

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

ทำไม CLAUDE.md ที่ยาวจึงขัดขวางการทำงานในตอนนี้?

ประเด็นสำคัญ

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

การทำงานเป็นแบบนี้ CLAUDE.md คือไฟล์กฎที่ Claude อ่านตอนเริ่มต้นทุกเซสชัน คู่มืออีกฉบับ “How to Set Up CLAUDE.md” อธิบายวิธีสร้างไฟล์ตั้งแต่ต้น ส่วนบทความนี้พูดถึงการทำย้อนกลับ: ตอนนี้ควรเอาอะไรออกจากไฟล์ ทุกอย่างที่คุณเขียนไว้จะเข้าสู่บริบท ก่อน คำขอแรก และคงอยู่ตลอดบทสนทนา บริบทไม่ได้มีไม่จำกัด และทุกบรรทัดของกฎที่เพิ่มเข้ามาก็ใช้พื้นที่ซึ่งอาจนำไปใช้กับงานของคุณได้

เอกสาร Claude Code ระบุไว้อย่างตรงไปตรงมาว่า:

จำกัดไฟล์ไว้ไม่เกิน 200 บรรทัด ไฟล์ที่ยาวกว่านั้นใช้บริบทมากขึ้นและทำให้การทำตามคำสั่งลดลง

— เอกสาร Claude Code, https://code.claude.com/docs/en/memory

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

แนวทางเปลี่ยนไปอย่างไรบ้าง:

ก่อนหน้านี้ (โมเดลที่อ่อนกว่า)ตอนนี้ (Opus 5 และโมเดลรุ่นที่ห้า)
แนวคิดกฎมากขึ้นหมายถึงผลลัพธ์ที่เชื่อถือได้มากขึ้นกฎน้อยลงหมายถึงทำตามได้มากขึ้น
CLAUDE.mdรายการยาวสำหรับทุกสถานการณ์สั้น: มีเพียงสิ่งที่โมเดลอนุมานเองไม่ได้
คำสั่งคำสั่งตายตัว: “ทำแบบนี้”เชื่อมั่นในวิจารณญาณของโมเดล
กฎที่ซ้ำกันย้ำเพื่อให้แน่ใจการย้ำมีแต่จะขัดขวาง

ยังมีปัญหาอีกอย่าง: ความขัดแย้ง เมื่อไฟล์ยาวขึ้น ก็มักจะมีกฎที่ขัดแย้งกันสะสมอยู่แทบจะหลีกเลี่ยงไม่ได้ จุดหนึ่งบอกว่า “เขียนเทสต์เสมอ” แต่อีกจุดบอกว่า “อย่าแตะโฟลเดอร์ tests” เอกสารเตือนว่าหากกฎสองข้อขัดแย้งกัน Claude อาจเลือกข้อใดข้อหนึ่งแบบสุ่ม กล่าวอีกอย่างคือ ไฟล์ที่ยาวเกินไปทำให้พฤติกรรมของโมเดลคาดเดาได้ น้อยลง

กฎง่าย ๆ คือ CLAUDE.md เป็นบันทึกสั้น ๆ เกี่ยวกับสิ่งที่ Claude อนุมานเองไม่ได้ สิ่งอื่นนอกเหนือจากนั้นมีแต่จะกินความสนใจของโมเดล

ควรเก็บอะไรไว้ใน CLAUDE.md และควรลบอะไรออก?

ประเด็นสำคัญ

เก็บไว้ใน CLAUDE.md เฉพาะสิ่งที่ Claude อนุมานจากโค้ดเองไม่ได้ ได้แก่ จุดที่ควรระวังเฉพาะโปรเจกต์ ธรรมเนียมที่ไม่ชัดเจน คำสั่ง build และธรรมเนียมที่ต่างจากค่าเริ่มต้น ลบสิ่งที่ชัดเจนอยู่แล้วซึ่งโมเดลรู้ และสิ่งที่อ่านได้จากโค้ดโดยตรง กฎจากเอกสารคือ เพิ่มบรรทัดเมื่อ Claude ทำผิดแบบเดิมเป็นครั้งที่สอง ไม่ใช่ก่อนหน้านั้น และไม่ใช่เผื่อไว้ก่อน

เอกสารให้เกณฑ์ชัดเจนในการตัดสินว่ากฎใดควรอยู่ใน CLAUDE.md ให้เพิ่มกฎเมื่อ:

  1. Claude ทำ ผิดแบบเดิมเป็นครั้งที่สอง
  2. การตรวจโค้ดพบสิ่งที่โมเดลควรรู้เกี่ยวกับโปรเจกต์นี้
  3. คุณกำลังพิมพ์คำแก้ไขเดิมในแชตเป็นครั้งที่สอง
  4. คนใหม่ในทีมจำเป็นต้องรู้บริบทเดียวกันเพื่อไม่ให้ทำโปรเจกต์พัง

หลักทั่วไปคือเก็บ จุดที่ควรระวังเฉพาะโปรเจกต์ และลบสิ่งที่ชัดเจนอยู่แล้ว Claude Code ยังมีการตรวจ claude doctor ในตัว ซึ่งจะแนะนำให้เก็บกวาด CLAUDE.md ที่ยาวเกินไป โดยจะตัดรายละเอียดที่โมเดลอนุมานจาก codebase ได้ เช่น โครงสร้างโฟลเดอร์ รายการ dependency และภาพรวมสถาปัตยกรรม แล้วเก็บจุดที่ควรระวัง เหตุผล และธรรมเนียมที่ต่างจากค่าเริ่มต้นไว้

กฎสำคัญข้อที่สองคือ ความเฉพาะเจาะจง ถ้อยคำที่คลุมเครือใช้ไม่ได้ ลองเปรียบเทียบ:

คลุมเครือ (ไม่ตรงจุด)เฉพาะเจาะจง (ตรงจุด)
จัดรูปแบบโค้ดให้เหมาะสมใช้การเยื้อง 2 ช่องว่าง
ทดสอบการเปลี่ยนแปลงรัน npm test ก่อน commit
จัดระเบียบไฟล์ให้ดีตัวจัดการ API อยู่ใน src/api/handlers/
เขียนข้อความ commit ให้ดีเริ่มข้อความ commit ด้วยประเภท: fix:, feat:

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

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

เคล็ดลับ

วิธีตรวจสอบแต่ละบรรทัดใน CLAUDE.md อย่างรวดเร็ว: “Claude อนุมานเรื่องนี้ได้เองจากการดูโค้ดของฉันหรือไม่?” ถ้าได้ ให้ลบทิ้ง เก็บไว้เฉพาะสิ่งที่อนุมานจากตัวโปรเจกต์เองไม่ได้

ควรย้ายกฎที่ไม่เหมาะกับ CLAUDE.md ไปไว้ที่ไหน?

ประเด็นสำคัญ

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

นี่คือจุดที่เครื่องมือซึ่งถูกประเมินค่าต่ำเกินไปเข้ามามีบทบาท เมื่อก่อนคำสั่งทั้งหมดต้องอยู่ใน CLAUDE.md แต่ตอนนี้มีที่อยู่แยกสำหรับขั้นตอนยาว ๆ แล้ว นั่นคือสกิล คู่มืออีกฉบับ “How to Choose Claude Code Skills” อธิบายวิธีเลือกสกิลที่เหมาะสมโดยไม่เพิ่มมากเกินไป

ความแตกต่างนี้สำคัญมาก CLAUDE.md โหลดเต็มไฟล์ตอนเริ่มทุกเซสชัน แต่สกิลไม่ใช่ เอกสารอธิบายไว้ว่า:

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

— เอกสาร Claude Code, https://code.claude.com/docs/en/skills

กระบวนการนี้เรียกว่าการเปิดเผยข้อมูลแบบค่อยเป็นค่อยไป หรือการโหลดข้อมูลเมื่อจำเป็น แนวคิดคือให้บริบทแก่โมเดลเป็นส่วน ๆ ในเวลาที่เหมาะสม Anthropic ย้ายคำสั่งโดยละเอียด เช่น คำสั่งสำหรับการตรวจทานโค้ด ไปไว้ในสกิลและเอาออกจาก system prompt

เกณฑ์การย้ายสิ่งใดไปไว้ในสกิลนั้นง่ายมาก: ส่วนหนึ่งของ CLAUDE.md เปลี่ยนจากข้อเท็จจริงเป็นขั้นตอนแล้ว บันทึกหนึ่งบรรทัดว่า “build ทำงานผ่าน npm run build” เป็นข้อเท็จจริงและควรอยู่ใน CLAUDE.md ส่วนสิบขั้นตอนเกี่ยวกับ “วิธีเผยแพร่โปรเจกต์ของเรา” เป็นขั้นตอนและควรอยู่ในสกิล

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

สิ่งที่มีประโยชน์ต่อการย้ายไปไว้ในสกิล:

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

ยังมีทางเลือกขั้นกลางด้วย: กฎเฉพาะโฟลเดอร์ หากคำสั่งมีความสำคัญเฉพาะกับส่วนหนึ่งของโปรเจกต์ คุณสามารถใส่ไว้ใน .claude/rules/ และเชื่อมโยงกับไฟล์ที่เกี่ยวข้องได้ จากนั้นคำสั่งจะโหลดเฉพาะเมื่อ Claude ทำงานกับไฟล์เหล่านั้น แทนที่จะค้างอยู่ในบริบทตลอดเวลา

หน่วยความจำอัตโนมัติคืออะไร และทำไมจึงควรใช้ใน 2026?

ประเด็นสำคัญ

หน่วยความจำอัตโนมัติคือการที่ Claude บันทึกสิ่งที่ควรจดจำด้วยตัวเอง เช่น คำสั่ง build สิ่งที่ค้นพบระหว่างแก้ปัญหา ความชอบของคุณ และคำแก้ไข เมื่อก่อนคุณต้องเพิ่มสิ่งเหล่านี้ลงใน CLAUDE.md เอง ตอนนี้ Claude จดบันทึกของตัวเองแยกจากกฎของคุณ และนำกลับมาใช้ในเซสชันต่อ ๆ ไป หน่วยความจำอัตโนมัติเปิดใช้เป็นค่าเริ่มต้นในโมเดลรุ่นที่ห้า

กลไกใหม่อีกอย่างที่ช่วยลดภาระของ CLAUDE.md คือหน่วยความจำอัตโนมัติ แนวคิดคือ Claude จดจำได้แล้วไม่เพียงแต่สิ่งที่คุณเขียน แต่ยังรวมถึงสิ่งที่มันสังเกตเห็นเองด้วย คู่มืออีกฉบับ “Claude Memory vs. CLAUDE.md” อธิบายว่ากลไกของหน่วยความจำนี้ต่างจาก CLAUDE.md อย่างไร

ความแตกต่างระหว่างหน่วยความจำสองประเภท:

CLAUDE.mdหน่วยความจำอัตโนมัติ
ใครเป็นผู้เขียนคุณClaude เอง
มีเนื้อหาอะไรคำสั่งและกฎสิ่งที่ค้นพบและรูปแบบต่าง ๆ
ตัวอย่าง“การเยื้อง 2 ช่องว่าง”“build ล้มเหลวถ้า Redis ไม่ทำงาน”
อัปเดตเมื่อไรคุณแก้ไขด้วยตนเองClaude อัปเดตระหว่างทำงาน

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

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

สิ่งที่เปลี่ยนไปในทางปฏิบัติสำหรับคุณคือ ตอนนี้ Claude บันทึกบางอย่างที่คุณเคยเพิ่มลงใน CLAUDE.md ด้วยตนเองหลังทำผิดแต่ละครั้งได้แล้ว ทำให้ไฟล์กฎของคุณสั้นลงไปอีก ซึ่งเป็นเรื่องดี

หมายเหตุ

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

ทำไม Opus 5 จึงโต้แย้งคำสั่งของคุณ?

ประเด็นสำคัญ

Opus 5 ฉลาดพอที่จะไม่เห็นด้วยกับคำสั่งที่ตายตัวได้ในบางครั้ง หากเห็นทางเลือกที่ดีกว่าในบริบท สำหรับคนที่ตั้งค่าสกิลและปลั๊กอินเก่าซึ่งออกแบบมาสำหรับโมเดลรุ่นก่อน เรื่องนี้อาจให้ความรู้สึกว่า “โมเดลเริ่มควบคุมยาก” ที่จริงแล้วมันเพียงเลิกทำตามคำสั่งที่เห็นว่าไม่เหมาะสมอย่างไม่ลืมหูลืมตา ควรตรวจสอบการตั้งค่าเก่าก่อนเปลี่ยนมาใช้

เรื่องนี้มีอีกด้านหนึ่ง

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

หากคุณอัปเกรดเป็น Opus 5 แล้วพบปัญหา เรื่องนี้หมายความว่าอย่างไรสำหรับคุณ:

  1. ตรวจสอบสกิลและปลั๊กอินเก่าของคุณอีกครั้ง การตั้งค่าที่สร้างไว้สำหรับโมเดลรุ่นก่อนอาจขัดแย้งกับแนวคิดใหม่ สิ่งที่เคยทำงานได้ราบรื่นก็ควรนำมาทดสอบใหม่
  2. เอาถ้อยคำที่ตายตัวที่สุดออก โมเดลรุ่นที่ห้าจัดการคำสั่งอย่าง “ห้ามทำ X เด็ดขาด ให้ทำเฉพาะ Y เสมอ” ได้แย่กว่าถ้อยคำที่ยืดหยุ่นและอธิบายเหตุผล
  3. สังเกตจุดที่โมเดลหยุดเร็วเกินไป บางครั้งนั่นเป็นสัญญาณว่าคำสั่งขัดแย้งกับตัวเองหรือไปชนกับกฎใน CLAUDE.md ที่ยาวเกินไป

คำเตือน

หากสกิลที่คุ้นเคยเริ่มทำงานแปลก ๆ ขึ้นมาหลังเปลี่ยนไปใช้ Opus 5 บ่อยครั้งคำสั่งเก่าภายในสกิลเป็นสาเหตุมากกว่าตัวโมเดลเอง เก็บกวาดสกิลนั้นเหมือน CLAUDE.md: ลบสิ่งที่ชัดเจนอยู่แล้วและความขัดแย้ง แล้วเก็บไว้เฉพาะรายละเอียดที่เจาะจง

วิธีเขียน CLAUDE.md ใหม่สำหรับ Opus 5: ทีละขั้นตอน

ประเด็นสำคัญ

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

นี่คือขั้นตอนสำหรับจัดการ CLAUDE.md ที่สืบทอดมาจากโมเดลรุ่นก่อน

  1. รันตัวตรวจสอบที่มีมาให้

    พิมพ์ claude doctor ในโปรเจกต์ ระบบจะแนะนำว่าควรเอาอะไรออกจากไฟล์ที่ยาวเกินไปและควรเก็บอะไรไว้

  2. เอาสิ่งที่ชัดเจนอยู่แล้วออก

    ลบบรรทัดทั้งหมดที่ Claude อนุมานจากโค้ดได้เอง เช่น โครงสร้างโฟลเดอร์ รายการไลบรารี และประโยคกว้าง ๆ อย่าง “เขียนโค้ดให้สะอาด”

  3. เอาความขัดแย้งออก

    ไล่อ่านไฟล์ตั้งแต่ต้นจนจบและหากฎที่ขัดแย้งกัน เก็บไว้หนึ่งข้อแล้วลบข้อที่ขัดแย้ง

  4. ย้ายขั้นตอนไปไว้ในสกิล

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

  5. ทำให้กฎที่เหลือเจาะจงขึ้น

    เขียนกฎแต่ละข้อใหม่ให้ตรวจสอบได้: “จัดรูปแบบให้เหมาะสม” เปลี่ยนเป็น “ใช้การเยื้อง 2 ช่องว่าง”

  6. เปิดใช้หน่วยความจำอัตโนมัติและตรวจสอบความยาว

    ตรวจสอบว่าหน่วยความจำอัตโนมัติทำงานอยู่ (/memory) และไฟล์มีความยาวไม่เกิน 200 บรรทัด หากไม่เป็นเช่นนั้น แสดงว่ายังมีสิ่งที่ต้องย้ายออกไปอีก

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

พรอมป์ต์: เก็บกวาด CLAUDE.md ที่ยาวเกินไป

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

ไล่อ่านไฟล์แล้วแบ่งกฎทั้งหมดออกเป็นสามกลุ่ม:

เก็บไว้ - จุดที่ควรระวังเฉพาะโปรเจกต์และธรรมเนียมที่คุณอนุมานเองจากโค้ดไม่ได้

ลบ - สิ่งที่ชัดเจนอยู่แล้วและคุณรู้อยู่แล้ว รวมถึงทุกอย่างที่อนุมานได้จากโค้ด

ย้ายไปไว้ในสกิล - ขั้นตอนหลายขั้นที่ตอนนี้เขียนเป็นข้อความอยู่ใน CLAUDE.md

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

สังเกตบรรทัดสุดท้าย: “อย่าเปลี่ยนอะไรจนกว่าฉันจะยืนยัน” เรื่องนี้สำคัญกับโมเดลที่ตอนนี้ใช้วิจารณญาณของตัวเองแล้ว ขอให้แสดงแผนก่อน แล้วให้การตัดสินใจอยู่กับคุณ

ทำไมบริบทจึงสำคัญกว่าพรอมป์ต์?

ประเด็นสำคัญ

ถ้อยคำในคำขอของคุณสำคัญน้อยกว่าที่คนส่วนใหญ่คิด สิ่งที่สำคัญกว่ามากคือสิ่งที่โมเดลเห็นก่อนคำขอ ได้แก่ โครงสร้างโปรเจกต์ กฎ หน่วยความจำ และสกิล นี่คือวิศวกรรมบริบท หรือการทำงานกับบริบทในฐานะทักษะหลักของนักพัฒนาแบบ vibe coding การอัปเดต Opus 5 ยิ่งตอกย้ำแนวคิดนี้: ยิ่งโมเดลฉลาด สภาพแวดล้อมที่คุณจัดเตรียมให้ก็ยิ่งสำคัญ การเขียนคำขอมีความสำคัญรองลงมาเมื่อเทียบกัน

หากวางรายละเอียดเกี่ยวกับ Opus 5 ไว้ก่อนแล้วมองภาพรวม บทวิเคราะห์ทั้งหมดนี้พูดถึงแนวคิดเดียว: บริบทสำคัญกว่าพรอมป์ต์ งานที่สำคัญที่สุดเกิดขึ้นก่อนคำขอ ตอนจัดเตรียมสภาพแวดล้อมที่โมเดลจะทำงาน

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

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

การอัปเดต Opus 5 ทำให้แนวคิดนี้ชัดเจนขึ้น Anthropic แสดงให้เห็นจากงานของตัวเองว่า เมื่อโมเดลฉลาดพอ กฎที่เพิ่มเข้ามากลับส่งผลเสีย และผู้ที่ได้เปรียบคือคนที่จัดเตรียมบริบทอย่างรอบคอบ นี่คือทักษะที่จะติดตัวคุณไปในโมเดลรุ่นถัด ๆ ไป ไม่ว่าจะเป็น Opus 6 หรือรุ่นอื่นก็ตาม

ตอนนี้ควรเริ่มจากตรงไหน?

ประเด็นสำคัญ

เปิด CLAUDE.md แล้วมองผ่านหลักการใหม่: ไฟล์นี้เป็นบันทึกสั้น ๆ เกี่ยวกับจุดที่ควรระวังเฉพาะโปรเจกต์ ไม่มีอะไรเพิ่มเติม นำไฟล์ไปให้พรอมป์ต์พร้อมใช้ด้านบนตรวจ ย้ายขั้นตอนไปไว้ในสกิล และเปิดใช้หน่วยความจำอัตโนมัติ ใช้เวลาเพียงหนึ่งเย็น แล้ว Claude จะทำตามคำสั่งของคุณได้ดีขึ้นอย่างเห็นได้ชัด

อย่าผัดผ่อนไปจนถึง “สักวันหนึ่ง” ขั้นตอนแรกที่ง่ายที่สุดคือเปิด CLAUDE.md ตอนนี้ แล้วถามตัวเองอย่างตรงไปตรงมาทีละบรรทัดว่า นี่เป็นจุดที่ควรระวังซึ่ง Claude อนุมานเองไม่ได้ หรือเป็นสิ่งที่เห็นได้ชัดซึ่งฉันใส่ไว้เผื่อกันแน่ ทุกอย่างในกลุ่มหลังควรพิจารณาลบออก

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

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

แหล่งที่มา

ทำความรู้จักกับ Ailoot

รายละเอียดเพิ่มเติม

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

เมื่อไรควรเปลี่ยนเนื้อหา CLAUDE.md เป็นสกิล?

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

memory อัตโนมัติในเครื่องแปลว่าเนื้อหาไม่ถึงบริการโมเดลหรือไม่?

ไม่ใช่ ไฟล์อยู่ในเครื่องแต่บันทึกที่เลือกเข้าบริบทโมเดล ตรวจด้วย /memory ไม่เก็บความลับ และตรวจตัวควบคุมข้อมูลของบริการที่ตั้งไว้

บทความทั้งหมด

เขียนโค้ดด้วย AI ในงานประจำวัน

บทความทั้งหมด