ทำไม Coding Agents ถึงไม่ทำตามคำสั่งที่คุณตั้งไว้
พบกับ 4 สาเหตุหลักที่ทำให้ coding agents เพิกเฉยต่อคำสั่งของคุณ รวมถึงวิธีวินิจฉัยปัญหาผ่าน context window และการจัดการข้อมูลที่ขัดแย้งกัน เพื่อให้ AI ทำงานได้แม่นยำขึ้น
เหตุใด coding agents จึงเพิกเฉยต่อคำสั่งของคุณ
Coding agents เพิกเฉยต่อคำสั่งของคุณด้วย 4 สาเหตุ และไม่มีสาเหตุใดที่เกิดจากการที่คุณสุภาพเกินไป กฎดังกล่าวอาจไม่ได้อยู่ใน context window ตั้งแต่แรก กฎนั้นอาจคลุมเครือเกินกว่าจะใช้ตรวจสอบการกระทำได้ หรือมีข้อมูลอื่นใน context ขัดแย้งกับกฎนั้น ซึ่งมักเป็นโค้ดที่ agent เพิ่งอ่านไป หรือกฎนั้นยังคงถูกโหลดอยู่แต่ถูกดันไปอยู่ไกลจากลำดับการสนทนาปัจจุบัน ทำให้ agent ทำงานโดยอิงจากข้อมูลที่อยู่ใกล้ตัวมากกว่า
แต่ละสาเหตุมีวิธีแก้ไขเฉพาะตัว ดังนั้นงานแรกคือการแยกแยะให้ออก การใช้ตัวอักษรพิมพ์ใหญ่หรือคำว่า IMPORTANT ไม่ใช่การวินิจฉัยปัญหา กลไกที่ระบุไว้ด้านล่างนี้ใช้ Claude Code เป็นตัวอย่างประกอบ เนื่องจากพฤติกรรมการโหลดและการบีบอัดข้อมูลของเครื่องมือนี้ได้รับการบันทึกไว้อย่างละเอียด ณ เดือนตุลาคม 2026 เครื่องมืออื่นอาจมีรายละเอียดที่แตกต่างกันออกไป แต่มีโครงสร้างการทำงานในภาพรวมที่เหมือนกัน
ขออธิบาย 2 คำศัพท์ก่อน context window คือบล็อกของข้อความที่โมเดลมองเห็นในแต่ละรอบการสนทนา ได้แก่ system prompt, ไฟล์คำสั่งของคุณ, ประวัติการสนทนา และทุกไฟล์ที่ agent ได้อ่านไป ส่วน harness คือโปรแกรมที่ครอบโมเดลไว้อีกชั้นหนึ่ง ซึ่งทำหน้าที่อ่านไฟล์จากดิสก์และรวบรวมข้อมูลเหล่านั้นเข้าเป็นบล็อก ข้อร้องเรียนเกือบทั้งหมดในโพสต์นี้แท้จริงแล้วเป็นข้อร้องเรียนเกี่ยวกับตัว harness ไม่ใช่ตัวโมเดลเอง
ไฟล์คำสั่งของคุณเป็นเพียงข้อความ ไม่ใช่การตั้งค่า
ไฟล์คำสั่งไม่ใช่การตั้งค่าคอนฟิกูเรชัน ไม่มีส่วนใดในรันไทม์ที่อ่าน CLAUDE.md แล้วบังคับใช้กฎดังกล่าว ระบบจะอ่านไฟล์จากดิสก์แล้วนำข้อความไปวางในบทสนทนา ใน Claude Code เนื้อหานี้จะถูกส่งเป็นข้อความของผู้ใช้ที่วางต่อจาก system prompt ซึ่งหมายความว่าโมเดลจะมองเห็นกฎของคุณในลักษณะเดียวกับข้อความอื่น ๆ ที่คุณพิมพ์
ผลที่ตามมาคือ กฎของคุณต้องแข่งขันกับข้อความอื่นทุกส่วนในหน้าต่างด้วยสถานะที่เท่าเทียมกัน กฎเป็นเพียงข้อกล่าวอ้าง ส่วนไฟล์ที่เอเจนต์เพิ่งเปิดขึ้นมาคือหลักฐาน เมื่อทั้งสองอย่างขัดแย้งกัน หลักฐานมักจะเป็นฝ่ายชนะ และไม่มีการแจ้งเตือนข้อผิดพลาดใด ๆ เพราะในมุมมองของโมเดลนั้นไม่มีสิ่งใดผิดปกติเกิดขึ้น
เอกสารอย่างเป็นทางการระบุเรื่องนี้ไว้อย่างชัดเจนว่า ไฟล์คำสั่งจะถูกปฏิบัติเสมือนเป็นบริบท ไม่ใช่การตั้งค่าที่ถูกบังคับใช้ หากต้องการบล็อกการกระทำโดยไม่คำนึงถึงสิ่งที่โมเดลตัดสินใจ คุณต้องใช้ hook ไม่ใช่แค่ประโยคคำสั่ง โปรดจำหลักการนี้ไว้ให้ดี วิธีแก้ไขส่วนใหญ่ที่ท้ายโพสต์นี้คือการนำหลักการดังกล่าวไปประยุกต์ใช้กับกรณีเฉพาะเจาะจง
ไฟล์คำสั่งใดบ้างที่ถูกโหลด และโหลดเมื่อใด
Claude Code จะไล่ลำดับจากไดเรกทอรีที่คุณเริ่มใช้งานขึ้นไปจนถึง root ของระบบไฟล์ โดยไฟล์ CLAUDE.md และ CLAUDE.local.md ทั้งหมดจะถูกโหลดเข้ามาเต็มรูปแบบเมื่อเริ่มโปรแกรม ไฟล์เหล่านี้จะถูกนำมาต่อกันตามลำดับดังกล่าว ดังนั้นไฟล์ที่อยู่ใกล้กับตำแหน่งที่คุณเริ่มใช้งานมากที่สุดจะถูกอ่านเป็นลำดับสุดท้าย และภายในไดเรกทอรีเดียวกัน ไฟล์ .local จะถูกนำมาต่อท้ายไฟล์หลัก
ไฟล์ที่อยู่ในไดเรกทอรีย่อย ใต้ ตำแหน่งที่คุณกำลังทำงานอยู่จะมีพฤติกรรมต่างออกไป ไฟล์เหล่านี้จะไม่ถูกโหลดเมื่อเริ่มโปรแกรม แต่จะถูกโหลดเมื่อ agent อ่านไฟล์ในไดเรกทอรีนั้นๆ เช่นเดียวกับกฎที่กำหนดขอบเขตตาม path ใน .claude/rules/ ซึ่งมีฟิลด์ paths: ในส่วน frontmatter กฎเหล่านี้จะเข้าสู่บริบทเมื่อมีการอ่านไฟล์ที่ตรงกับเงื่อนไข ไม่ใช่ทุกครั้งที่มีการโต้ตอบ ตั้งแต่เวอร์ชัน v2.1.309 เป็นต้นไป ไฟล์ที่โหลดด้วยวิธีนี้จะมีข้อจำกัดขนาดต่อไฟล์ (40,000 ตัวอักษรบน context window ขนาด 200K) และ agent จะได้รับเฉพาะส่วนต้นของไฟล์ที่ยาวเท่านั้น ดังนั้นกฎที่อยู่ท้ายไฟล์ขนาดใหญ่ที่ซ้อนอยู่ลึกๆ อาจไม่ถูกนำเข้าสู่บริบทเลย
ความแตกต่างเพียงจุดเดียวนี้อธิบายถึงสาเหตุของปัญหาที่ได้รับรายงานส่วนใหญ่ คุณใส่กฎไว้ใน packages/api/CLAUDE.md แล้วถามคำถามเกี่ยวกับ API แต่ agent กลับตอบโดยไม่เคยเปิดไฟล์ภายใต้ packages/api/ เลย กฎนั้นไม่ได้ถูกเพิกเฉย แต่กฎนั้นไม่เคยถูกโหลดเข้ามาตั้งแต่แรก หาก repository ของคุณมีการแยกคำแนะนำไว้ตาม ไฟล์คำสั่งแยกตามแพ็กเกจใน monorepo นี่คือสิ่งแรกที่คุณต้องตรวจสอบทุกครั้ง
กับดักการโหลดอีกประการหนึ่งส่งผลต่อ repository ที่ใช้ AGENTS.md เป็นมาตรฐาน ตั้งแต่เวอร์ชัน v2.1.277 เป็นต้นไป Claude Code จะอ่าน AGENTS.md เป็นคำสั่งสำหรับโปรเจกต์ของคุณโดยอัตโนมัติ แต่จะทำเช่นนั้นก็ต่อเมื่อไม่มีไฟล์ CLAUDE.md, .claude/CLAUDE.md หรือ CLAUDE.local.md อยู่ในไดเรกทอรีที่คุณทำงานอยู่หรือไดเรกทอรีที่อยู่เหนือขึ้นไป (ไฟล์ ~/.claude/CLAUDE.md ส่วนตัวของคุณไม่นับรวมในกรณีนี้) หากคุณเพิ่มไฟล์ใดไฟล์หนึ่งเข้าไป แม้จะเป็นเพียง CLAUDE.local.md สำหรับบันทึกส่วนตัว Claude Code จะอ่านไฟล์ CLAUDE.md ของคุณแทนและข้าม AGENTS.md ไปโดยสิ้นเชิง หากต้องการโหลดทั้งสองอย่าง ให้ตั้งค่า Project instructions เป็น claude-md-and-agents-md ใน /config สำหรับเวอร์ชันก่อน v2.1.277 หรือในกรณีที่คุณต้องการเก็บ CLAUDE.md ไว้ วิธีเชื่อมต่อคือการใช้ CLAUDE.md ที่บรรทัดแรกคือ @AGENTS.md ซึ่งจะนำเข้าไฟล์ดังกล่าวเมื่อเริ่มโปรแกรม พร้อมกับบันทึกเฉพาะของ Claude ที่อยู่ด้านล่าง การใช้ symlink ก็สามารถทำได้เช่นกันหากคุณไม่มีข้อมูลอื่นที่ต้องการเพิ่ม ส่วนการตัดสินใจว่าข้อมูลใดควรอยู่ในไฟล์นั้นเป็นอีกประเด็นหนึ่ง ซึ่งครอบคลุมอยู่ใน การแยกคำสั่งสำหรับ agent ออกจากเอกสารสำหรับมนุษย์
ยืนยันว่าไฟล์ถูกโหลดก่อนทำการแก้ไข
ห้ามแก้ไขเนื้อหาจนกว่าคุณจะมีหลักฐานว่า agent มองเห็นไฟล์นั้น การตรวจสอบมี 2 ขั้นตอน โดยเริ่มจากวิธีที่ง่ายที่สุดก่อน
รัน /context ภายในเซสชัน คำสั่งนี้จะแสดงหน้าต่างปัจจุบันแยกตามหมวดหมู่ และรายการ Memory files จะระบุชื่อไฟล์คำสั่งทุกไฟล์ที่ถูกโหลดตอนเริ่มต้น หากไฟล์ใดไม่อยู่ในรายการนั้น แสดงว่าไฟล์ไม่ได้ถูกโหลดตอนเริ่มต้น ดังนั้นสิ่งที่คุณเขียนลงไปในไฟล์นั้นจะไม่มีผลจนกว่าจะมีกระบวนการโหลดไฟล์ขึ้นมา ไฟล์ที่ซ้อนอยู่ในไดเรกทอรีย่อยจะไม่ปรากฏในรายการนี้เนื่องจากจะถูกโหลดเมื่อมีการเรียกใช้เท่านั้น เมื่อมีการโหลดไฟล์ดังกล่าว บรรทัด Loaded พร้อมเส้นทางไฟล์จะปรากฏในเทอร์มินัล /memory จะแสดงรายการตำแหน่งไฟล์และเปิดไฟล์เหล่านั้นเพื่อแก้ไข รวมถึงไฟล์ที่ยังไม่มีอยู่จริงด้วย
สำหรับการตรวจสอบที่ละเอียดขึ้น ให้บันทึกการโหลดไฟล์ เหตุการณ์ hook InstructionsLoaded จะทำงานทุกครั้งที่มีไฟล์ CLAUDE.md หรือไฟล์กฎเข้าสู่บริบท และตัวจับคู่ (matcher) จะบอกคุณว่าเหตุใดการโหลดจึงเกิดขึ้น ได้แก่ session_start, nested_traversal, path_glob_match, include หรือ compact ให้ใส่คำสั่งนี้ลงใน .claude/settings.json:
{
"hooks": {
"InstructionsLoaded": [
{
"matcher": "nested_traversal",
"hooks": [
{
"type": "command",
"command": "cat >> /tmp/instructions-loaded.log"
}
]
}
]
}
}hook จะรับ payload ในรูปแบบ JSON ผ่าน standard input ดังนั้น cat จะทำการต่อท้ายบันทึกทั้งหมด ให้ตรวจสอบด้วย tail -f /tmp/instructions-loaded.log ในขณะที่คุณทำงาน สถานะการจบการทำงาน (exit status) ของเหตุการณ์นี้จะถูกละเว้น ดังนั้น hook จึงทำได้เพียงสังเกตการณ์เท่านั้น ไม่สามารถบล็อกการทำงานได้ หากไฟล์ที่ซ้อนอยู่ของคุณไม่ปรากฏใน log นั้นเลยในระหว่างเซสชันที่คุณคาดหวังไว้ ให้หยุดการแก้ไขเนื้อหา ปัญหาอยู่ที่ตำแหน่งการวางไฟล์ ข้อยกเว้นประการเดียวคือ AGENTS.md ที่ Claude Code อ่านโดยตรงจะไม่ทำให้เกิดเหตุการณ์นี้ ดังนั้นให้มองหาเส้นทางไฟล์ใน /memory แทน ส่วน AGENTS.md ที่ถูก import มาจาก CLAUDE.md จะทำให้เกิดเหตุการณ์นี้ตามปกติ
ผลกระทบของเซสชันที่ยาวนานต่อกฎของคุณ
มีผลกระทบสองประการที่เกิดขึ้นแยกกัน และจำเป็นต้องใช้วิธีรับมือที่แตกต่างกัน
ระยะห่าง (Distance): จนกว่ากระบวนการ compaction จะทำงาน กฎที่ระบุไว้ในเทิร์นที่ 1 จะยังคงอยู่ในหน้าต่างบริบทจนถึงเทิร์นที่ 90 โดยต้องแข่งขันกับข้อความอีก 90 เทิร์นที่ใหม่กว่าและเฉพาะเจาะจงกับสิ่งที่คุณกำลังทำอยู่ในขณะนี้ เมื่อ compaction ทำงานแล้ว กฎที่คุณพิมพ์ลงในแชทเพียงอย่างเดียวอาจไม่อยู่ในหน้าต่างบริบทอีกต่อไป เอกสารของ Claude Code ระบุเตือนว่าคำสั่งจากช่วงต้นของการสนทนาอาจสูญหายได้ ซึ่งเป็นผลกระทบประการที่สองที่กล่าวถึงด้านล่าง คุณไม่สามารถตั้งค่าเพื่อขจัดระยะห่างได้ แต่คุณสามารถวัดผลได้ ให้ลองรันงานเดียวกันในเซสชันใหม่ หากกฎยังคงทำงานได้ในเซสชันใหม่แต่ล้มเหลวเมื่ออยู่ในเซสชันที่ยาวนาน แสดงว่าสาเหตุมาจากระยะห่างหรือ compaction
การบีบอัดข้อมูล (Compaction): เมื่อหน้าต่างบริบทเต็ม ระบบจะสรุปการสนทนาที่ผ่านมาและดำเนินการต่อจากบทสรุปนั้น สิ่งที่ยังคงอยู่คือสิ่งที่ตัวสรุปผลตัดสินว่าสำคัญ ซึ่งอาจไม่ตรงกับสิ่งที่คุณให้ความสำคัญ Claude Code ได้ระบุผลลัพธ์ตามกลไกไว้ และมีความแตกต่างกันอย่างมาก กฎที่อยู่ใน project root CLAUDE.md และกฎที่ไม่มีขอบเขตจะถูกนำกลับเข้ามาจากดิสก์หลังจากผ่านการ compaction ส่วน Auto memory จะถูกนำกลับเข้ามาจากดิสก์เช่นกัน กฎที่มี frontmatter เป็น paths: จะสูญหายไปจนกว่าจะมีการอ่านไฟล์ที่ตรงกันอีกครั้ง ส่วนไฟล์ CLAUDE.md ที่ซ้อนอยู่ในไดเรกทอรีย่อยจะสูญหายไปจนกว่าจะมีการอ่านไฟล์ในไดเรกทอรีย่อยนั้นอีกครั้ง
หากคุณจัดลำดับคำสั่งของคุณตามตารางดังกล่าว คุณจะเห็นลำดับความเปราะบางของกฎ กฎที่คุณพิมพ์ลงในแชทเพียงอย่างเดียวคือสิ่งที่เปราะบางที่สุดในเซสชัน โดยจะคงอยู่ก็ต่อเมื่อบทสรุปเก็บกฎนั้นไว้ กฎที่อยู่ใน packages/api/CLAUDE.md จะมีความคงทนรองลงมา เนื่องจากถูกโหลดเพียงครั้งเดียว ถูกสรุปทิ้งไป และจะกลับมาอีกครั้งเมื่อมีการอ่านไฟล์ในไดเรกทอรีนั้นอีกครั้ง กฎที่อยู่ในไฟล์ project root จะมีความทนทานมากที่สุด เนื่องจากระบบจะอ่านกฎนั้นจากดิสก์ใหม่ทุกครั้ง
ดังนั้น หากคำสั่งใดจำเป็นต้องคงอยู่ตลอดทั้งเซสชัน คำสั่งนั้นควรอยู่ในไฟล์ project root โดยไม่มี frontmatter เป็น paths: ส่วนกรณีอื่นๆ คือการแลกเปลี่ยนที่คุณควรตัดสินใจอย่างตั้งใจ การจัดการสิ่งที่คงอยู่ในหน้าต่างบริบท ครอบคลุมถึง /compact ด้วยอาร์กิวเมนต์ focus และ /clear ระหว่างงานที่ไม่เกี่ยวข้องกัน ซึ่งทั้งสองอย่างนี้ส่งผลต่อความถี่ที่ตัวสรุปผลจะตัดสินว่ากฎของคุณคืออะไร
เหตุผลที่โค้ดโดยรอบมีน้ำหนักเหนือกว่ากฎ
นี่คือความล้มเหลวที่ผู้คนมักอธิบายบ่อยที่สุดแต่กลับวินิจฉัยน้อยที่สุด ไฟล์ของคุณระบุว่าการเข้าถึงฐานข้อมูลต้องผ่านชั้น repository แต่ตัว agent กลับเขียน handler ที่เรียกใช้ ORM (object relational mapper) โดยตรง คุณไม่ได้ถูกเพิกเฉยด้วยเหตุผลด้านสไตล์ แต่คุณถูกหักล้างด้วยหลักฐาน
กฎอธิบายถึงความพึงพอใจ แต่โค้ดแสดงให้เห็นถึงการปฏิบัติจริง เมื่อ agent เปิดไฟล์ 3 ไฟล์ในโมดูลที่กำลังจะแก้ไขแล้วพบว่าทั้ง 3 ไฟล์เรียกใช้ ORM โดยตรง บริบทจึงมีประโยคที่เป็นนามธรรมอยู่ฝั่งหนึ่ง และมีตัวอย่างที่เป็นรูปธรรม ทันสมัย และตรงกับงานอยู่อีกฝั่งหนึ่ง การคัดลอกรูปแบบในพื้นที่มักเป็นพฤติกรรมที่ถูกต้อง แต่มันผิดในกรณีนี้เพียงเพราะคุณรู้บางสิ่งที่บริบทไม่รู้ นั่นคือไฟล์เหล่านั้นเป็น legacy code
ดังนั้นให้เขียนสิ่งนั้นลงในกฎ กฎที่ระบุหลักฐานโต้แย้งของตัวเองจะสามารถคงอยู่ได้เมื่อต้องเผชิญกับ repository จริง ส่วนกฎที่ระบุเพียงความพึงพอใจลอยๆ จะไม่สามารถทำได้
การเข้าถึงฐานข้อมูลใหม่ต้องผ่านapp/repositories/ไฟล์ภายใต้app/legacy/ยังคงเรียกใช้ ORM โดยตรง นั่นเป็นโค้ดเก่า ไม่ใช่รูปแบบที่ควรทำตาม ห้ามคัดลอกรูปแบบดังกล่าว
ประโยคที่สองคือส่วนสำคัญ มันบอก agent ว่าสิ่งที่กำลังจะพบคืออะไรและควรตีความอย่างไรก่อนที่มันจะพบเสียอีก การแก้ไขแบบเดียวกันนี้ใช้ได้กับกฎทุกข้อที่ repository ของคุณขัดแย้งอย่างเห็นได้ชัด ไม่ว่าจะเป็นสไตล์การ commit ที่ประวัติของคุณไม่ได้ทำตาม, โครงสร้างการทดสอบที่ชุดทดสอบของคุณครึ่งหนึ่งไม่ได้สนใจ, หรือธรรมเนียมการ import ที่ใช้ได้เฉพาะในโค้ดใหม่เท่านั้น ในที่ใดก็ตามที่โค้ดไม่สอดคล้องกับไฟล์ ให้ระบุความขัดแย้งนั้นไว้ในไฟล์ด้วย
กฎที่คลุมเครือไม่สามารถตรวจสอบได้ จึงไม่สามารถปฏิบัติตามได้
"เขียนโค้ดให้สะอาด" "อย่าออกแบบซับซ้อนเกินจำเป็น" "ทำให้เรียบง่าย" "ระวังเรื่องการย้ายข้อมูล" ไม่มีข้อใดในนี้ที่สามารถทดสอบกับการกระทำที่เฉพาะเจาะจงได้ ไม่ว่าจะโดยตัวเอเจนต์หรือโดยตัวคุณเอง หากเอเจนต์ได้รับกฎที่ไม่สามารถตรวจสอบกับผลลัพธ์ของตัวเองได้ เอเจนต์นั้นก็กำลังเดา และคุณก็กำลังให้คะแนนการเดานั้นด้วยความรู้สึก
นี่คือแบบทดสอบที่ใช้กับทุกบรรทัดในไฟล์ของคุณ ให้เขียนคำสั่ง shell ที่จะ exit ด้วยสถานะ non-zero เมื่อกฎถูกละเมิด หากคุณไม่สามารถเขียนคำสั่งนั้นได้ แสดงว่ากฎนั้นตรวจสอบไม่ได้ ลองเปรียบเทียบตัวอย่างเหล่านี้:
- ตรวจสอบไม่ได้: "ทำให้ฟังก์ชันมีขนาดเล็ก" ตรวจสอบได้: "ฟังก์ชันที่ยาวเกิน 60 บรรทัดต้องมีคอมเมนต์อธิบายเหตุผลไว้ด้านบน"
- ตรวจสอบไม่ได้: "ทดสอบการเปลี่ยนแปลงของคุณ" ตรวจสอบได้: "รัน
npm testและวางจำนวนความผิดพลาดก่อนที่จะถือว่างานเสร็จสิ้น" - ตรวจสอบไม่ได้: "จัดระเบียบไฟล์ให้ดี" ตรวจสอบได้: "HTTP handlers ต้องอยู่ใน
src/api/handlers/ห้ามมีไฟล์อื่นอยู่ในไดเรกทอรีนั้น" - ตรวจสอบไม่ได้: "จัดรูปแบบโค้ดให้เหมาะสม" ตรวจสอบได้: "ใช้การเยื้อง 2 ช่องว่างในไฟล์
.ts"
"อย่าออกแบบซับซ้อนเกินจำเป็น" เป็นกฎข้อแรกที่ผู้คนมักยอมแพ้ เพราะวิธีแก้ไขไม่ใช่การทำให้ประโยคสั้นลง แต่เป็นการทำให้ยาวขึ้น: การระบุรายละเอียดว่าการเปลี่ยนแปลงที่เล็กที่สุดที่ใช้งานได้จริงหมายถึงอะไร จะช่วยให้เอเจนต์มีเกณฑ์ที่สามารถใช้ตรวจสอบ diff ของตัวเองได้
ขนาดของไฟล์ก็เป็นปัญหาเดียวกันในรูปแบบที่ต่างออกไป คำแนะนำของ Claude Code กำหนดให้ไฟล์คำสั่งหนึ่งไฟล์มีความยาวไม่เกิน 200 บรรทัด และระบุโดยตรงว่าไฟล์ที่ยาวขึ้นจะลดความสามารถในการปฏิบัติตามกฎ ไฟล์ขนาด 700 บรรทัดไม่ใช่คำสั่งที่แน่นหนาขึ้น แต่มันคือ 700 บรรทัดของข้อเรียกร้องที่มีโอกาสขัดแย้งกันเองมากขึ้น และยังถูกนำไปคำนวณรวมในหน้าต่างบริบท (context window) ของคุณในทุกๆ รอบ ซึ่ง ปรากฏให้เห็นโดยตรงในการใช้งานโทเคนของคุณ การจัดโครงสร้างไฟล์ให้แต่ละกฎอยู่ภายใต้หัวข้อที่ผู้อ่านสามารถกวาดสายตาดูได้นั้นครอบคลุมอยู่ใน การเขียนไฟล์คำสั่งที่เอเจนต์สามารถปฏิบัติตามได้ ยิ่งไปกว่านั้น ให้ตัดส่วนที่เป็นการบรรยายออกแล้วเปลี่ยนเป็นการสั่งการแทน: การแนะนำไดเรกทอรีว่า handler และ model อยู่ที่ไหน เป็นโครงสร้างที่เอเจนต์สามารถค้นหาได้ตามต้องการจาก แผนผังที่ถูกวิเคราะห์ของ repository แทนที่จะต้องแบกรับข้อมูลนั้นไว้ในหน้าต่างบริบทในทุกๆ รอบ
วิธีวินิจฉัยปัญหาภายในสิบนาที
ให้รันคำสั่งเหล่านี้ตามลำดับ การข้ามไปขั้นตอนสุดท้ายเป็นสาเหตุที่ทำให้ผู้ใช้หลายคนต้องลงเอยด้วยการเขียนกฎจำนวนมากที่ไม่ได้ผล
- ยืนยันว่าโหลดไฟล์แล้ว รัน
/contextแล้วตรวจสอบรายการ Memory files หรือหากเป็นไฟล์ที่ซ้อนอยู่ ให้มองหาบรรทัดLoadedในเทอร์มินัล หากไม่พบไฟล์ดังกล่าว ให้แก้ไขตำแหน่งที่ตั้งให้ถูกต้องแล้วหยุดดำเนินการ ขั้นตอนอื่นในรายการนี้ยังไม่มีผลจนกว่าจะทำขั้นตอนนี้สำเร็จ - จำลองปัญหาในเซสชันใหม่ เริ่มเซสชันใหม่และทดสอบด้วยงานที่เล็กที่สุดที่ควรจะกระตุ้นให้กฎทำงาน หากผ่านในขั้นตอนนี้แต่ล้มเหลวในเซสชันที่ยาวนาน แสดงว่าปัญหาเกิดจากระยะห่างหรือการบีบอัด (compaction) หากล้มเหลวตั้งแต่ขั้นตอนนี้ แสดงว่าตัวกฎเองคือปัญหา
- กำจัดปัจจัยรบกวน ลองใช้การเปลี่ยนแปลงเดียวกันในไดเรกทอรีที่โค้ดเดิมปฏิบัติตามกฎนั้นอยู่แล้ว หากผลลัพธ์กลับมาถูกต้อง แสดงว่าโค้ดโดยรอบเป็นตัวขัดแย้งกับคำสั่งของคุณ
- ค้นหาความขัดแย้ง การมีสองไฟล์ที่ให้คำแนะนำต่างกันสำหรับพฤติกรรมเดียวกันถือเป็นความผิดพลาดที่ระบุไว้ชัดเจน โมเดลอาจเลือกไฟล์ใดไฟล์หนึ่งโดยสุ่มและจะไม่แจ้งให้คุณทราบ
- ทำให้ตรวจสอบได้และทดสอบซ้ำ เขียนกฎใหม่โดยระบุ path และเงื่อนไขที่ชัดเจน หากอัตราการปฏิบัติตามกฎเพิ่มขึ้นอย่างมาก แสดงว่าปัญหาเกิดจากการใช้ถ้อยคำของคุณ
ขั้นตอนที่ 4 ใช้เพียงหนึ่งคำสั่ง ให้ใช้ grep ค้นหาแหล่งคำสั่งทั้งหมดในหัวข้อนั้น ไม่ใช่แค่ไฟล์ที่คุณกำลังแก้ไขอยู่:
grep -rni "migration" --include="CLAUDE.md" --include="CLAUDE.local.md" --include="AGENTS.md" .
grep -rni "migration" .claude/rules/ ~/.claude/CLAUDE.md ~/.claude/rules/ 2>/dev/nullหากพบข้อมูลในสองไฟล์ที่ระบุต่างกัน นั่นคือบั๊กของคุณ ให้ลบออกหนึ่งไฟล์ อย่าพยายามจัดลำดับความสำคัญด้วยการใช้ถ้อยคำที่รุนแรงขึ้น เพราะไม่มีกลไกการจัดลำดับให้ใช้งาน ใน Claude Code v2.1.283 หรือใหม่กว่า /doctor prompt-audit จะทำการค้นหาที่ครอบคลุมยิ่งขึ้นในไฟล์คำสั่ง กฎ และทักษะของคุณ พร้อมทั้งรายงานความขัดแย้งและเสนอการแก้ไขโดยที่ยังไม่มีการเปลี่ยนแปลงใดๆ จนกว่าคุณจะร้องขอ
การแก้ไขตามลำดับความสำคัญ
แต่ละขั้นตอนด้านล่างนี้มีผลกระทบสูงกว่าขั้นตอนก่อนหน้า แต่ก็มีต้นทุนในการตั้งค่าที่สูงกว่าเช่นกัน ให้เริ่มจากด้านบนเมื่อกฎนั้นสามารถปรับแก้ได้ง่าย และขยับลงมาเมื่อกฎมีความสำคัญจนไม่สามารถยอมรับความผิดพลาดที่อาจเกิดขึ้นได้
- ทำให้กฎมีความชัดเจน ระบุ path, command หรือเงื่อนไขให้ชัดเจน เพิ่มหลักฐานคัดค้านที่ agent จะพบใน repository ตามที่แสดงไว้ก่อนหน้านี้ วิธีนี้ไม่มีค่าใช้จ่ายและช่วยแก้ไขปัญหาได้เป็นจำนวนมากอย่างน่าประหลาดใจ
- ย้ายกฎไปไว้ใกล้กับสิ่งที่ควบคุม เช่น การใช้
CLAUDE.mdแบบซ้อนกัน, กฎที่กำหนดขอบเขตตาม path ใน.claude/rules/หรือการเขียน comment ไว้ที่ส่วนบนสุดของไฟล์ กฎจะถูกอ่านพร้อมกับโค้ดที่กฎนั้นบังคับใช้ทันที ยอมรับข้อแลกเปลี่ยนที่ว่า: สิ่งใดก็ตามที่โหลดด้วยวิธีนี้จะถูกลบออกเมื่อมีการ compaction และจะกลับมาใหม่ในการอ่านที่ตรงเงื่อนไขครั้งถัดไป - ย้ายการบังคับใช้ไปไว้ใน hook ข้อความที่เป็นคำบรรยายทำได้เพียงแค่ขอ แต่ hook คือตัวตัดสิน hook จะทำงานเป็นโค้ดในเหตุการณ์ lifecycle ที่กำหนดไว้ และจะมีผลบังคับใช้โดยไม่คำนึงถึงสิ่งที่โมเดลสรุป
- มอบกฎให้เครื่องมือที่เป็น deterministic และลบคำบรรยายทิ้ง เช่น การจัดรูปแบบ, ลำดับการ import, ความยาวบรรทัด, การห้าม import บางรายการ, รูปแบบของ commit message โดยใช้
ruff format,prettier --write,eslintหรือ hook ของpre-commitเครื่องมือจัดรูปแบบจะทำงานถูกต้องเสมอและไม่เสีย token ในขณะที่ประโยคคำสั่งจะถูกต้องเป็นส่วนใหญ่แต่ต้องเสีย token ในทุกรอบการทำงาน
ขั้นตอนที่ 3 โดยละเอียด สมมติว่าไฟล์ migration ต้องไม่ถูกแก้ไขโดย agent ให้ใส่สิ่งนี้ลงใน .claude/settings.json:
{
"hooks": {
"PreToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/guard-migrations.sh"
}
]
}
]
}
}และใส่สิ่งนี้ลงใน .claude/hooks/guard-migrations.sh:
#!/usr/bin/env bash
set -euo pipefail
path=$(jq -r '.tool_input.file_path // empty')
case "$path" in
*/migrations/*)
echo "Files under migrations/ are written by hand. Stop and ask first." >&2
exit 2
;;
esac
exit 0รัน chmod +x .claude/hooks/guard-migrations.sh จากนั้นเริ่ม session ใหม่และสั่งให้ agent แก้ไขไฟล์ภายใต้ migrations/ การแก้ไขจะถูกปฏิเสธและข้อความของคุณจะถูกส่งกลับมาเป็นเหตุผล Exit status 2 บน PreToolUse จะบล็อกการเรียกใช้เครื่องมือก่อนที่จะเริ่มทำงาน และข้อความ stderr ของคุณจะถูกส่งไปยังโมเดลในฐานะข้อความแจ้งเตือนการบล็อก ${CLAUDE_PROJECT_DIR} จะอ้างอิงไปยัง root ของโปรเจกต์ ดังนั้น hook จะทำงานได้ไม่ว่า agent จะอยู่ใน directory ใดก็ตาม agent ไม่จำเป็นต้องเห็นด้วยกับกฎ ไม่ต้องจำกฎ หรือต้องมีกฎอยู่ใน context การแก้ไขนั้นจะไม่เกิดขึ้น
สำหรับการห้ามแบบเด็ดขาดที่ไม่มีตรรกะซับซ้อน permissions.deny ในการตั้งค่าของคุณสามารถทำหน้าที่เดียวกันได้โดยไม่ต้องดูแลสคริปต์ และ โหมดสิทธิ์การเข้าถึงจะเป็นตัวตัดสินว่าสิ่งใดทำงานได้โดยไม่ต้องถามคุณก่อน หากคำสั่งจำเป็นต้องอยู่ในระดับ system prompt แทนที่จะเป็นข้อความของผู้ใช้ --append-system-prompt สามารถทำหน้าที่นั้นได้ แม้ว่าจะเป็น launch flag ที่ต้องส่งผ่านในทุก session ใหม่ ซึ่งเหมาะกับสคริปต์มากกว่าการทำงานแบบโต้ตอบ
สิ่งที่คุณไม่สามารถสั่งให้หายไปได้
ต้องมีความชัดเจนว่าส่วนใดเป็นหน้าที่ของคุณ การจัดวาง การใช้ถ้อยคำ ความขัดแย้งระหว่างไฟล์ และขนาดของไฟล์ เป็นปัญหาของผู้เขียนที่ต้องแก้ไขด้วยตนเอง ส่วนที่เหลือเป็นพฤติกรรมของโมเดล ซึ่งการปรับเปลี่ยนคำพูดให้ดีขึ้นจะไม่สามารถขจัดพฤติกรรมเหล่านั้นออกไปได้
การตอบรับไม่ใช่การปฏิบัติตาม เอเจนต์จะตอบรับกฎ ทวนกฎให้คุณฟังอย่างถูกต้อง และละเมิดกฎนั้นในอีกสองการเรียกใช้เครื่องมือถัดมา การตอบรับไม่มีต้นทุนและไม่สามารถทำนายผลลัพธ์ได้ อย่าตีความว่านั่นคือการแก้ไข และอย่าถือว่านั่นคือการทดสอบ
นิสัยบางอย่างฝังรากลึก เช่น การเพิ่มความคิดเห็น การเพิ่มการจัดการข้อผิดพลาดเชิงป้องกัน การเขียนสรุปปิดท้าย หรือการรันคำสั่งถัดไปที่เห็นได้ชัดเจน สิ่งเหล่านี้จะกลับมาปรากฏอีกครั้งภายใต้กฎที่ห้ามไว้ โดยจะลดความถี่ลงแต่ไม่หายไปจนเป็นศูนย์ คุณสามารถวัดอัตราการเกิดปัญหาด้วยตนเองได้โดยการรันงานเดิมสิบครั้งในเซสชันใหม่แล้วนับจำนวนครั้งที่ละเมิดกฎ ในกรณีที่จำนวนครั้งต้องเป็นศูนย์ กฎนั้นจะต้องถูกนำออกจากพรอมต์ การแจ้งว่างานเสร็จสิ้นทั้งที่งานบางส่วนยังไม่เสร็จเป็นนิสัยในรูปแบบเดียวกัน และการแก้ไขต้องทำในเชิงโครงสร้างมากกว่าการใช้คำพูด: ทักษะการไม่ขี้เกียจจะเปลี่ยนจากการใช้ประโยคเป็นการใช้ Depth Tree และกำหนดไฟล์ gate ที่เอเจนต์ต้องจัดการให้เรียบร้อยก่อนจึงจะอ้างว่างานเสร็จได้
เซสชันของคุณเองจะกลายเป็นตัวอย่าง หากเอเจนต์ละเมิดกฎในเทิร์นที่ 12 แล้วคุณปล่อยผ่าน การละเมิดนั้นจะอยู่ในบริบทในฐานะตัวอย่าง และมันมีความสดใหม่มากกว่าตัวกฎเอง จงแก้ไขการละเมิดทันทีที่คุณพบ การละเมิดที่ไม่ได้รับการแก้ไขจะกลายเป็นการสอนให้กับเซสชันที่เหลือ
ไฟล์คำสั่งไม่ใช่ขอบเขตความปลอดภัย มันเป็นเพียงสิ่งที่กำหนดพฤติกรรมแต่ไม่ได้บังคับใช้ สิ่งใดก็ตามที่หากเกิดความผิดพลาดแล้วมีราคาที่ต้องจ่ายสูง เช่น ข้อมูลรับรอง (credentials) หรือคำสั่งที่ทำลายข้อมูล ควรอยู่ในส่วนของการจัดการสิทธิ์หรือ hook การเก็บความลับให้พ้นมือเอเจนต์ ใช้หลักการเดียวกันกับข้อมูล: อย่าขอให้เอเจนต์ไม่อ่านไฟล์ แต่จงจัดการไม่ให้ไฟล์นั้นสามารถอ่านได้
สรุปสั้นๆ คือ พิสูจน์ว่าไฟล์ถูกโหลดแล้ว ทำให้กฎสามารถตรวจสอบได้ วางกฎไว้ใกล้กับสิ่งที่กฎนั้นควบคุม และเมื่ออัตราความผิดพลาดยังคงเป็นเรื่องสำคัญ ให้ย้ายกฎนั้นออกจากข้อความบรรยาย กฎที่เอเจนต์ไม่สามารถเพิกเฉยได้คือกฎที่ไม่เคยถูกร้องขอจากเอเจนต์ตั้งแต่แรก
FAQ
ทำไม Claude Code ถึงเพิกเฉยต่อไฟล์ CLAUDE.md ของฉัน?
ตรวจสอบให้แน่ใจว่าระบบโหลดไฟล์นั้นแล้วก่อนจะสรุปว่าถูกเพิกเฉย ให้รันคำสั่ง /context แล้วดูที่รายการ Memory files หากไม่มีชื่อไฟล์ปรากฏในรายการแสดงว่าไฟล์นั้นไม่ได้ถูกโหลดตั้งแต่เริ่มทำงาน ไฟล์คำสั่งจะถูกส่งเป็นข้อความของผู้ใช้หลังจาก system prompt และถูกปฏิบัติเสมือนเป็นบริบท (context) มากกว่าจะเป็นการตั้งค่าที่บังคับใช้ ดังนั้นจึงไม่มีการรับประกันการปฏิบัติตามอย่างเคร่งครัด กรณีส่วนใหญ่ที่พบมักเกิดจากหนึ่งในสี่สาเหตุนี้: ไฟล์อยู่ในไดเรกทอรีย่อยที่เอเจนต์ไม่เคยอ่าน, ไฟล์สองไฟล์มีเนื้อหาขัดแย้งกันและโมเดลเลือกใช้ไฟล์ใดไฟล์หนึ่งโดยสุ่ม, กฎมีความคลุมเครือเกินกว่าจะตรวจสอบการกระทำได้ หรือโค้ดโดยรอบแสดงผลลัพธ์ที่ตรงกันข้ามกับสิ่งที่กฎระบุไว้
การแก้ไขไฟล์คำสั่งระหว่างเซสชันส่งผลอะไรหรือไม่?
ไม่มีผลต่อเนื้อหาที่อยู่ในบทสนทนาปัจจุบัน ไฟล์ที่อยู่เหนือไดเรกทอรีทำงานของคุณจะถูกโหลดทั้งหมดตั้งแต่เริ่มทำงาน ดังนั้นข้อความที่โมเดลถืออยู่คือข้อความ ณ เวลาที่เริ่มเซสชัน หากต้องการให้ระบบรับการแก้ไข ให้เริ่มเซสชันใหม่ หรือขอให้เอเจนต์อ่านไฟล์นั้นด้วยเครื่องมือจัดการไฟล์ตามปกติ ซึ่งจะเป็นการนำเวอร์ชันปัจจุบันเข้าสู่บทสนทนาในฐานะข้อความใหม่ หลังจากกระบวนการ compaction ไฟล์ที่อยู่ใน root ของโปรเจกต์จะถูกอ่านจากดิสก์ใหม่อีกครั้ง ดังนั้นเวอร์ชันใหม่จะถูกนำเข้ามาในจุดนั้นด้วย
ไฟล์ใดจะมีผลหาก CLAUDE.md ที่ root และที่อยู่ในไดเรกทอรีย่อยมีเนื้อหาขัดแย้งกัน?
ไม่มีไฟล์ใดที่ให้ผลลัพธ์แน่นอน ไฟล์ที่ถูกค้นพบจะถูกนำมาต่อกัน (concatenate) ลงในบริบทแทนที่จะเขียนทับกัน โดยเรียงลำดับจาก root ของระบบไฟล์ลงมาจนถึงไดเรกทอรีทำงานของคุณ ดังนั้นไฟล์ที่อยู่ใกล้ที่สุดจะถูกอ่านเป็นลำดับสุดท้าย ไม่มีกลไกกำหนดลำดับความสำคัญเพื่อแก้ไขข้อขัดแย้ง และเอกสารของ Claude Code ระบุว่ากฎที่ขัดแย้งกันอาจถูกตัดสินโดยสุ่ม ให้เขียนไฟล์ในไดเรกทอรีย่อยในลักษณะที่เป็นส่วนเสริมโดยระบุ path ที่ต้องการควบคุมให้ชัดเจน และลบส่วนที่ขัดแย้งออกแทนที่จะพยายามเขียนทับ
คำสั่งของฉันจะยังคงอยู่หรือไม่หลังจากใช้ /compact?
ขึ้นอยู่กับวิธีการโหลดคำสั่งนั้นๆ ไฟล์ CLAUDE.md ที่ root ของโปรเจกต์, กฎที่ไม่ได้กำหนดขอบเขต (unscoped rules) และ auto memory จะถูกนำกลับเข้ามาจากดิสก์หลังจากทำ compaction กฎที่มี frontmatter แบบ paths: และไฟล์ CLAUDE.md ที่อยู่ในไดเรกทอรีย่อยจะสูญหายไปจนกว่าไฟล์ที่ตรงกันจะถูกอ่านอีกครั้ง สิ่งใดก็ตามที่คุณพิมพ์ลงในแชทโดยตรงจะคงอยู่ก็ต่อเมื่อระบบสรุปเนื้อหา (summariser) เก็บข้อมูลนั้นไว้ หากกฎใดจำเป็นต้องมีผลตลอดทั้งเซสชัน ให้ใส่ไว้ในไฟล์ที่ root ของโปรเจกต์โดยไม่มี frontmatter แบบ paths:
เมื่อใดที่ควรเปลี่ยนกฎให้เป็น hook แทนการเขียนเป็นข้อความ?
เมื่อการตรวจสอบนั้นเป็นแบบกำหนดผลลัพธ์ได้ (deterministic) และต้นทุนของความผิดพลาดสูงกว่าต้นทุนในการเขียนสคริปต์ขนาดเล็ก ข้อจำกัดด้าน path ของไฟล์, คำสั่งที่จำเป็นต้องรันก่อนการ commit และการห้ามเรียกใช้เครื่องมือบางอย่าง ล้วนเข้าข่ายนี้ Hook แบบ PreToolUse ที่จบการทำงานด้วยสถานะ 2 จะบล็อกการเรียกใช้เครื่องมือนั้นทันที และส่งข้อความ stderr กลับไปยังโมเดลเพื่อแจ้งเหตุผล ดังนั้นกฎนี้จะมีผลไม่ว่ากฎนั้นจะยังอยู่ในบริบทหรือไม่ก็ตาม สิ่งใดก็ตามที่ formatter หรือ linter สามารถตัดสินได้ ควรให้เครื่องมือเหล่านั้นเป็นผู้จัดการ และควรลบออกจากไฟล์คำสั่งโดยสิ้นเชิง