วิธีลดการใช้โทเค็นในเอเจนต์เขียนโค้ดด้วย AI: 4 เครื่องมือที่ช่วยได้

หากเคยชนขีดจำกัดการใช้โทเค็นในแผน AI สำหรับช่วยเขียนโค้ดหลังส่งคำขอเพียงไม่กี่ครั้ง อาจสงสัยว่าโทเค็นหายไปไหนทั้งหมด 

แค่ขอให้เอเจนต์แก้บั๊ก รีแฟกเตอร์ฟีเจอร์ หรือสำรวจรีโพสิทอรี อยู่ๆ โควตาการใช้งานก็หายไปก้อนใหญ่

นี่ไม่จำเป็นต้องเป็นปัญหาของผู้ให้บริการหรือแพ็กเกจสมัครสมาชิกของคุณเสมอไป 

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

ข่าวดีคือสามารถลดการใช้โทเค็นที่ไม่จำเป็นเหล่านี้ได้มากพอสมควร

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

ในคู่มือนี้จะดู 4 เครื่องมือสำหรับลดการใช้โทเค็นในเอเจนต์เขียนโค้ด ได้แก่ Caveman, Ponytail, RTK และ Context Mode 

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

เหตุใดเวิร์กโฟลว์แบบเอเจนต์จึงใช้โทเค็นมาก?

บอทแชตทั่วไปอาจรับพรอมป์ตหนึ่งครั้งและตอบหนึ่งครั้ง เอเจนต์มักทำมากกว่านั้นมาก

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

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

ลูปของเอเจนต์แบบย่อหน้าตาเป็นดังนี้:

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

สิ่งนี้ทำให้เกิดแหล่งสูญเปล่าของโทเค็นที่พบบ่อย:

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

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

และนี่เองคือสิ่งที่เครื่องมืออย่าง Caveman, Ponytail, RTK และ Context Mode ถูกออกแบบมาเพื่อลด โดยแต่ละตัวมุ่งจัดการแหล่งสูญเปล่าของโทเค็นที่ต่างกัน

1. Caveman: ทำให้เอเจนต์พูดน้อยลง

Caveman เป็นวิธีง่ายๆ ในการทำให้เอเจนต์เขียนโค้ดตอบให้กระชับขึ้น 

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

มีประโยชน์มากเป็นพิเศษในเซสชันโค้ดยาวๆ ที่คำตอบเยิ่นเย้อไม่ได้แค่เพิ่มโทเค็นเอาต์พุต 

แต่ยังกลายเป็นส่วนหนึ่งของประวัติการสนทนาและถูกพาไปในรอบถัดๆ ไปด้วย

Caveman ทำงานอย่างไร

Caveman มีสองส่วนแยกกัน

ส่วน ทักษะของ Caveman จะปรับวิธีที่เอเจนต์เขียนคำตอบ 

ตัดคำฟุ่มเฟือย คำทักทาย การออกตัว และการบรรยายที่ไม่จำเป็น โดยคงรายละเอียดสำคัญไว้ เช่น โค้ดบล็อก คำสั่ง ชื่อ API และข้อความผิดพลาดแบบเป๊ะๆ 

และจะผ่อนคลายสไตล์ที่กระชับลงเมื่อความชัดเจนสำคัญกว่า เช่น ประเด็นด้านความปลอดภัยหรือการกระทำที่ย้อนกลับไม่ได้ 

ยังมีตัวเลือก พร็อกซีโลคัลเสริมที่จัดการอีกด้านของปัญหา: สิ่งที่เอเจนต์อ่าน 

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

ทักษะและพร็อกซีทำงานแยกกัน จึงเริ่มจากทักษะที่เบาได้ก่อน แล้วค่อยเพิ่มพร็อกซีภายหลังหากต้องการลดบริบทเชิงรุกมากขึ้น 

แนวคิดง่ายๆ ดูได้จากไดอะแกรมด้านล่าง:

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

เริ่มต้นใช้งาน Caveman

วิธีติดตั้งทักษะที่ง่ายที่สุดคือ:

npx skills add JuliusBrussee/caveman

จากนั้นเปิดใช้งานในเอเจนต์เขียนโค้ดด้วย:

/caveman

เปลี่ยนกลับเป็นคำตอบปกติได้ด้วย:

/caveman off

Caveman ยังมีตัวเลือกติดตั้งแบบเนทีฟสำหรับเครื่องมืออย่าง Claude Code, Codex, Gemini CLI, Cursor และ OpenCode

หากต้องการลดบริบทที่ส่งเข้าโมเดลด้วย ให้ติดตั้ง CLI:

npm install -g @caveman-ai/cli
caveman setup --install

แล้วเปิดเอเจนต์ที่รองรับผ่านมัน ตัวอย่างเช่น:

caveman claude

คำสั่งนี้จะสตาร์ตพร็อกซีโลคัลของ Caveman และส่งเอเจนต์ผ่านชั้นบีบอัดบริบท 

สำหรับผู้ใช้ส่วนใหญ่ แนะนำให้เริ่มจากทักษะก่อน 

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

2. Ponytail: หยุดเอเจนต์จากการวิศวกรรมเกินจำเป็น

Ponytail ถูกออกแบบมาเพื่อจัดการการสิ้นเปลืองโทเค็นอีกแบบหนึ่ง: เอเจนต์เขียนโค้ดมากกว่างานที่ต้องการจริง.

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

Ponytail พยายามหยุดสิ่งนี้ด้วยการผลักเอเจนต์ไปสู่ทางออกที่เล็กที่สุดแต่สมเหตุสมผลก่อน

Ponytail ทำงานอย่างไร

ก่อนเขียนโค้ด Ponytail จะให้เอเจนต์ไล่บันไดการตัดสินใจง่ายๆ

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

เช่น แทนที่จะติดตั้งไลบรารี date-picker และสร้างคอมโพเนนต์หุ้ม Ponytail อาจตัดสินใจว่าเบราว์เซอร์มีอยู่แล้ว:

<input type="date">

เป้าหมายไม่ใช่การทำให้ทุกอย่างสั้นลงแบบไม่ลืมหูลืมตา 

Ponytail ตั้งใจเว้นสิ่งสำคัญอย่างการตรวจสอบความถูกต้อง ความปลอดภัย การเข้าถึงได้ และการป้องกันข้อมูลสูญหาย ไว้นอกกระบวนการตัดทอน 

มันถูกออกแบบให้ขี้เกียจเรื่องการลงมือทำ แต่ไม่ประมาทเรื่องความถูกต้อง.

ในเบนช์มาร์กของเอเจนต์เองของ Ponytail พบว่าโค้ดลดลงราว 54% และโทเค็นลดลง 22% ใน 12 งานเขียนโค้ด เมื่อเทียบกับเอเจนต์เดิมที่ไม่มีทักษะนี้ 

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

เริ่มต้นใช้งาน Ponytail

สำหรับ Claude Code ให้เพิ่มมาร์เก็ตเพลส:

/plugin marketplace add DietrichGebert/ponytail

แล้วติดตั้ง Ponytail:

/plugin install ponytail@ponytail

ส่งเป็นสองคำสั่งแยกกัน

เมื่อติดตั้งแล้ว สามารถกำหนดความดุดันในการทำให้เรียบง่ายได้:

/ponytail lite
/ponytail full
/ponytail ultra
/ponytail off

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

ยังสามารถรีวิวการเปลี่ยนแปลงที่มีอยู่เพื่อหาความซับซ้อนที่ไม่จำเป็นได้:

/ponytail-review

หรือสแกนโค้ดเบสขนาดใหญ่:

/ponytail-audit

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

3. RTK: ตัดเอาต์พุตเครื่องมือที่มีแต่เสียงรบกวน

RTK ย่อมาจาก Rust Token Killer มุ่งจัดการแหล่งสูญเปล่าของโทเค็นอีกแบบ: ทุกอย่างที่เอเจนต์เขียนโค้ดได้รับกลับมาจากเทอร์มินัล

คำสั่งอย่าง git status การรันทดสอบ ล็อก การค้นหา และเอาต์พุตจากตัวจัดการแพ็กเกจ อาจคืนบรรทัดหลายร้อยหรือหลายพันบรรทัด 

ข้อมูลเหล่านั้นส่วนใหญ่มีประโยชน์สำหรับมนุษย์ที่มองหน้าจอเทอร์มินัล แต่อเอเจนต์มักต้องการเพียงส่วนสำคัญ

RTK จะอยู่ระหว่างคำสั่งกับเอเจนต์และบีบอัดเอาต์พุตก่อนที่โมเดลจะเห็น 

RTK ทำงานอย่างไร

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

เช่น:

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

กับเอเจนต์เขียนโค้ดที่รองรับ RTK สามารถฮุคเข้ากับการเรียกเชลล์โดยอัตโนมัติ คำสั่งเช่น:

git status

สามารถถูกเขียนใหม่เบื้องหลังเป็น:

rtk git status

แล้วเอเจนต์จะได้รับเอาต์พุตที่เล็กลง โดยไม่ต้องร้องขอ RTK ทุกครั้งอย่างชัดเจน 

RTK รายงานว่าโทเค็นจากเอาต์พุตคำสั่งลดลง 60–90% สำหรับคำสั่งพัฒนาที่พบบ่อย ซึ่งไม่ได้หมายความว่าบิล LLM รวมจะลดลง 60–90% ตัวเลขนี้อ้างถึงเอาต์พุตเทอร์มินัลที่ RTK บีบอัดเท่านั้น 

เริ่มต้นใช้งาน RTK

บน macOS หรือ Linux สามารถติดตั้งผ่าน Homebrew:

brew install rtk-ai/tap/rtk

หรือใช้สคริปต์ติดตั้ง:

curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/master/install.sh | sh

แล้วตรวจสอบว่าได้ติดตั้ง RTK ตัวที่ถูกต้อง:

rtk --versionrtk gain

คำสั่ง rtk gain จะแสดงแดชบอร์ดการประหยัดโทเค็น การตรวจนี้มีประโยชน์เพราะมีอีกโปรเจ็กต์ที่ไม่เกี่ยวข้องใช้ชื่อ rtk เช่นกัน 

สำหรับ Claude Code ให้อินิท RTK แบบโกลบอลด้วย:

rtk init -g

สำหรับ Codex:

rtk init -g --codex

และสำหรับ Gemini CLI:

rtk init -g --gemini

RTK ยังรองรับ Cursor, OpenCode, Copilot, Cline, Windsurf และเอเจนต์เขียนโค้ดอื่นๆ อีกหลายตัว 

เมื่อคอนฟิกแล้ว สามารถใช้คำสั่งเทอร์มินัลปกติต่อไปได้ 

RTK จัดการบีบอัดเบื้องหลัง ทำให้มีประโยชน์มากกับเอเจนต์ที่ใช้เวลาไปกับการรันทดสอบ ค้นหาโค้ด ตรวจการเปลี่ยนแปลงใน Git และอ่านล็อกเป็นส่วนใหญ่

4. Context Mode: กันเอาต์พุตเครื่องมือขนาดใหญ่ออกจากบริบท

Context Mode มุ่งกับสิ่งที่เกิดขึ้นหลังจากเอเจนต์เริ่มใช้เครื่องมือ.

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

ยิ่งไปกว่านั้น ข้อมูลเหล่านั้นยังถูกพาไปในรอบถัดๆ ไปได้อีก

Context Mode พยายามหลีกเลี่ยงด้วยการเก็บข้อมูลดิบที่เทอะทะไว้นอกบริบท LLM ที่ใช้งานอยู่ และนำกลับมาเฉพาะส่วนที่เอเจนต์ต้องใช้จริง

Context Mode ทำงานอย่างไร

Context Mode ทำงานเป็นเซิร์ฟเวอร์ MCP และมีเครื่องมือ sandbox สำหรับงานที่ปกติจะสร้างเอาต์พุตขนาดใหญ่

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

ในตัวอย่างหนึ่งของโปรเจ็กต์ เอาต์พุตดิบ 315 KB ถูกย่อลงเหลือบริบท 5.4 KB ซึ่งรายงานว่าเป็นการลดลง 98% 

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

เริ่มต้นใช้งาน Context Mode

สำหรับ Claude Code การตั้งค่าที่ง่ายที่สุดคือผ่านมาร์เก็ตเพลสของปลั๊กอิน:

/plugin marketplace add mksglu/context-mode
/plugin install context-mode@context-mode

รีสตาร์ต Claude Code แล้วตรวจสอบการตั้งค่าด้วย:

/context-mode:ctx-doctor

ตัว doctor จะตรวจสอบว่าปลั๊กอิน ฮุค รันไทม์ และองค์ประกอบค้นหาโลคัลทำงานถูกต้อง 

ยังสามารถติดตั้ง Context Mode แบบโกลบอลได้:

npm install -g context-mode

และลงทะเบียนเป็นเซิร์ฟเวอร์ MCP ในไคลเอนต์ที่รองรับ เช่น Cursor, Gemini CLI, GitHub Copilot CLI, JetBrains และอื่นๆ 

เมื่อรันแล้ว สามารถตรวจดูปริมาณบริบทที่ช่วยประหยัดได้ด้วยเครื่องมือสถิติของมัน

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

เปรียบเทียบเครื่องมือทั้งสี่ที่ช่วยประหยัดโทเค็น

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

วิธีคิดที่ง่ายที่สุดเกี่ยวกับความแตกต่างคือ: 

• Caveman ลดสิ่งที่เอเจนต์พูด
• Ponytail ลดสิ่งที่มันสร้าง
• RTK ลดสิ่งที่เทอร์มินัลส่งกลับมา
• Context Mode ลดสิ่งที่ผลลัพธ์จากเครื่องมือคงอยู่ในบริบท

ใช้เครื่องมือเหล่านี้ร่วมกันได้ไหม?

ได้ แต่ไม่แนะนำให้ซ้อนทุกอย่างตั้งแต่ต้น

แนวทางที่ดีกว่าคือเริ่มจาก Ponytailก่อน 

ติดตั้งกับเอเจนต์เขียนโค้ดได้ง่าย และสำหรับเวิร์กโฟลว์จำนวนมาก การลดโค้ดที่ไม่จำเป็นก็มากพอแล้ว ใช้งานคู่กับเครื่องมืออย่าง Zcode, Claude Code และ Codex และพอใจกับการลดที่ได้

หากต้องการต่อยอด ลองPonytail + Caveman Ponytail ลดโค้ดที่ไม่จำเป็น ส่วน Caveman ลดการอธิบายที่ไม่จำเป็น จึงเสริมกันได้ดี

หากเวิร์กโฟลว์ยังคงสร้างเอาต์พุตหนักโทเค็นจากการทดสอบ ล็อก Git หรือคำสั่งเทอร์มินัล ลองPonytail + Caveman + RTK.

หาก RTK ไม่เข้ากับเวิร์กโฟลว์ โดยเฉพาะเมื่อใช้เครื่องมือ MCP จำนวนมาก เครื่องมือเบราว์เซอร์ API หรือเอาต์พุตเครื่องมือขนาดใหญ่อื่นๆ ให้ลองPonytail + Caveman + Context Modeแทน

ไม่มีชุดที่สมบูรณ์แบบสำหรับทุกคน 

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

วิธีอื่นๆ ในการลดการใช้โทเค็นและค่าใช้จ่าย

ไม่จำเป็นต้องมีเครื่องมือเพิ่มเสมอไป 

Claude Code มีฟีเจอร์หลายอย่างอยู่แล้วที่ช่วยให้บริบทเล็กลงและลดค่าใช้จ่ายที่ไม่จำเป็น

ปิดหน่วยความจำเมื่อไม่จำเป็น

Claude Code สามารถเก็บและโหลดหน่วยความจำจากเซสชันก่อนหน้าโดยอัตโนมัติ สำหรับงานสั้นๆ หรือแยกส่วน สิ่งนี้อาจเพิ่มบริบทที่ไม่จำเป็น

รัน:

/memory

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

ย่อเซสชันที่ยาว

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

/compact

ยังบอกได้ด้วยว่าอะไรสำคัญ:

/compact keep the implementation plan and latest test results

สิ่งนี้มีประโยชน์มากเมื่อจบงานส่วนหนึ่งแล้ว แต่อยากทำต่อในเซสชันเดิม 

เริ่มใหม่เมื่อเปลี่ยนงาน

บางครั้งการย่อก็ไม่คุ้ม หากกำลังย้ายไปงานที่ต่างไปคนละเรื่อง ให้รัน:

/clear

เริ่มด้วยบริบทการสนทนาที่ว่างเปล่าแทนการแบกงานที่ไม่เกี่ยวข้องต่อไป โดย Anthropic ยังระบุด้วยว่าการเริ่มใหม่บางครั้งดีกว่าการย่อซ้ำๆ ในเซสชันยาวๆ

ปิดเซิร์ฟเวอร์ MCP ที่ไม่ใช้

เครื่องมือ MCP ก็ใช้บริบทเช่นกัน ขณะนี้ Claude Code จะหน่วงการโหลดสคีมาของเครื่องมือ MCP แบบเต็มโดยค่าเริ่มต้น แต่เซิร์ฟเวอร์ที่ไม่ได้ใช้ก็ยังเพิ่มโอเวอร์เฮดได้

ใช้: /mcp เพื่อทบทวนเซิร์ฟเวอร์ที่เชื่อมต่อและปิดตัวที่ยังไม่จำเป็นตอนนี้ 

ยังสามารถรัน /context เพื่อดูว่าส่วนต่างๆ ของเซสชันใช้พื้นที่เท่าไร

ทำให้ CLAUDE.md เล็ก

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

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

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

ใช้โมเดลที่ถูกกว่าสำหรับงานง่าย

ไม่จำเป็นต้องใช้โมเดลที่แพงที่สุดสำหรับทุกการแก้ไข 

เอกสารของ Claude Code แนะนำSonnetสำหรับงานเขียนโค้ดส่วนใหญ่ และเก็บ Opus ไว้สำหรับงานสถาปัตยกรรมหรือเหตุผลซับซ้อน

สลับได้ด้วย:

/model

สำหรับงานซับเอเจนต์ง่ายๆ ยังตั้งค่าให้ใช้ Haiku ได้ด้วย 

ข้อคิดส่งท้าย

หนึ่งในข้อดีของเครื่องมือเหล่านี้คือแทบไม่ต้องลงแรงหลังตั้งค่าเสร็จ 

ขึ้นกับเครื่องมือ อาจไม่ต้องจำสแลชคอมมานด์หรือเปิดใช้งานเองทุกงาน 

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

หลังการคอนฟิก การปรับให้เหมาะสมจำนวนมากจะเกิดขึ้นเองเป็นส่วนหนึ่งของเวิร์กโฟลว์การเขียนโค้ดตามปกติ

มักเห็นผลลัพธ์ได้จากสรุปการรันของเอเจนต์ โค้ดที่สร้าง เอาต์พุตเทอร์มินัล หรือสถิติบริบท 

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

ที่ดีที่สุดคือยังสามารถผสานเครื่องมือเหล่านี้เข้าด้วยกันได้ 

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

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

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

ส่วนตัวใช้Ponytailในเวิร์กโฟลว์การเขียนโค้ดส่วนใหญ่ เพราะติดตั้งง่ายและเอเจนต์เข้าใจวิธีทำงานร่วมกันได้รวดเร็ว 

ใช้งานส่วนใหญ่กับZcode by Z.ai ซึ่งช่วยให้อิมพลีเมนเทชันโฟกัส โดยไม่ต้องเปลี่ยนวิธีการให้พรอมป์ตตามปกติ

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

ลองใช้ Caveman, Ponytail, RTK และ Context Mode แยกกันและแบบผสม วัดว่ามีอะไรเปลี่ยนในเวิร์กโฟลว์ของคุณเอง และคงการตั้งค่าที่ให้สมดุลดีที่สุดระหว่างการใช้โทเค็น คุณภาพโค้ด และประสิทธิภาพของเอเจนต์

หากอยากเรียนรู้เพิ่มเติมเกี่ยวกับการทำงานของเอเจนต์ AI แนะนำให้ดูเส้นทางทักษะ AI Agent Fundamentals