SSD Nodes Learn Hosting plans →
คู่มือ Matt Connorโดย Matt Connor · อัปเดตเมื่อ 2026-10-26

ทำไม 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 แทนที่จะต้องแบกรับข้อมูลนั้นไว้ในหน้าต่างบริบทในทุกๆ รอบ

วิธีวินิจฉัยปัญหาภายในสิบนาที

ให้รันคำสั่งเหล่านี้ตามลำดับ การข้ามไปขั้นตอนสุดท้ายเป็นสาเหตุที่ทำให้ผู้ใช้หลายคนต้องลงเอยด้วยการเขียนกฎจำนวนมากที่ไม่ได้ผล

  1. ยืนยันว่าโหลดไฟล์แล้ว รัน /context แล้วตรวจสอบรายการ Memory files หรือหากเป็นไฟล์ที่ซ้อนอยู่ ให้มองหาบรรทัด Loaded ในเทอร์มินัล หากไม่พบไฟล์ดังกล่าว ให้แก้ไขตำแหน่งที่ตั้งให้ถูกต้องแล้วหยุดดำเนินการ ขั้นตอนอื่นในรายการนี้ยังไม่มีผลจนกว่าจะทำขั้นตอนนี้สำเร็จ
  2. จำลองปัญหาในเซสชันใหม่ เริ่มเซสชันใหม่และทดสอบด้วยงานที่เล็กที่สุดที่ควรจะกระตุ้นให้กฎทำงาน หากผ่านในขั้นตอนนี้แต่ล้มเหลวในเซสชันที่ยาวนาน แสดงว่าปัญหาเกิดจากระยะห่างหรือการบีบอัด (compaction) หากล้มเหลวตั้งแต่ขั้นตอนนี้ แสดงว่าตัวกฎเองคือปัญหา
  3. กำจัดปัจจัยรบกวน ลองใช้การเปลี่ยนแปลงเดียวกันในไดเรกทอรีที่โค้ดเดิมปฏิบัติตามกฎนั้นอยู่แล้ว หากผลลัพธ์กลับมาถูกต้อง แสดงว่าโค้ดโดยรอบเป็นตัวขัดแย้งกับคำสั่งของคุณ
  4. ค้นหาความขัดแย้ง การมีสองไฟล์ที่ให้คำแนะนำต่างกันสำหรับพฤติกรรมเดียวกันถือเป็นความผิดพลาดที่ระบุไว้ชัดเจน โมเดลอาจเลือกไฟล์ใดไฟล์หนึ่งโดยสุ่มและจะไม่แจ้งให้คุณทราบ
  5. ทำให้ตรวจสอบได้และทดสอบซ้ำ เขียนกฎใหม่โดยระบุ 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 จะทำการค้นหาที่ครอบคลุมยิ่งขึ้นในไฟล์คำสั่ง กฎ และทักษะของคุณ พร้อมทั้งรายงานความขัดแย้งและเสนอการแก้ไขโดยที่ยังไม่มีการเปลี่ยนแปลงใดๆ จนกว่าคุณจะร้องขอ

การแก้ไขตามลำดับความสำคัญ

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

  1. ทำให้กฎมีความชัดเจน ระบุ path, command หรือเงื่อนไขให้ชัดเจน เพิ่มหลักฐานคัดค้านที่ agent จะพบใน repository ตามที่แสดงไว้ก่อนหน้านี้ วิธีนี้ไม่มีค่าใช้จ่ายและช่วยแก้ไขปัญหาได้เป็นจำนวนมากอย่างน่าประหลาดใจ
  2. ย้ายกฎไปไว้ใกล้กับสิ่งที่ควบคุม เช่น การใช้ CLAUDE.md แบบซ้อนกัน, กฎที่กำหนดขอบเขตตาม path ใน .claude/rules/ หรือการเขียน comment ไว้ที่ส่วนบนสุดของไฟล์ กฎจะถูกอ่านพร้อมกับโค้ดที่กฎนั้นบังคับใช้ทันที ยอมรับข้อแลกเปลี่ยนที่ว่า: สิ่งใดก็ตามที่โหลดด้วยวิธีนี้จะถูกลบออกเมื่อมีการ compaction และจะกลับมาใหม่ในการอ่านที่ตรงเงื่อนไขครั้งถัดไป
  3. ย้ายการบังคับใช้ไปไว้ใน hook ข้อความที่เป็นคำบรรยายทำได้เพียงแค่ขอ แต่ hook คือตัวตัดสิน hook จะทำงานเป็นโค้ดในเหตุการณ์ lifecycle ที่กำหนดไว้ และจะมีผลบังคับใช้โดยไม่คำนึงถึงสิ่งที่โมเดลสรุป
  4. มอบกฎให้เครื่องมือที่เป็น 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 สามารถตัดสินได้ ควรให้เครื่องมือเหล่านั้นเป็นผู้จัดการ และควรลบออกจากไฟล์คำสั่งโดยสิ้นเชิง

บทความนี้มีประโยชน์หรือไม่