เทอร์มินัล Claude Code: 7 อัปเกรดเวิร์กโฟลว์สำหรับผู้ใช้ขั้นสูง

Claude Code แบบพื้นฐานก็มีประโยชน์ตั้งแต่แกะกล่อง ติดตั้ง เรียกใช้งาน แล้วมันก็สร้างสิ่งที่ต้องการได้ นั่นคือวิถีการโค้ดแบบ vibe ของคนส่วนใหญ่ และมันก็ใช้งานได้ดี

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

บทความนี้จะอุดช่องว่างระหว่างสองแบบตั้งค่า Claude Code ด้วยการอัปเกรด 7 ข้อ แต่ละข้อใช้ตั้งค่าไม่เกินสิบนาที และเห็นผลภายในสัปดาห์

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

1. เลิกอนุมัติคำสั่งเดิมซ้ำไปซ้ำมา

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

แน่นอนว่ามีโหมด "ข้ามสิทธิ์อย่างเสี่ยงภัย" หรือ "ออโตโมde" เราได้อธิบายข้อแลกเปลี่ยนไว้อย่างละเอียดใน บทเรียนเรื่อง Auto Mode และ Channels ของ Claude Code.

กำหนดสิทธิ์ในไฟล์ settings.json

ทางแก้คือไฟล์ .claude/settings.json ที่รูทโปรเจกต์ โดยมีบล็อก permissions ที่อนุมัติรูปแบบคำสั่งที่ไว้ใจได้ล่วงหน้าและบล็อกรูปแบบที่ไม่ไว้ใจ:

{
  "permissions": {
	"allow": [
  	"Bash(pytest *)",
  	"Bash(uv run *)",
  	"Bash(ruff check *)",
  	"Read(~/.zshrc)"
	],
	"deny": [
  	"Bash(curl *)",
  	"Read(./.env)",
  	"Read(./.env.*)",
  	"Read(./secrets/**)"
	]
  }
}

กฎจะประเมินตามลำดับคงที่: ปฏิเสธก่อน จากนั้นถาม แล้วค่อยอนุญาต การจับคู่แรกจะชนะเสมอ ดังนั้นกฎปฏิเสธจึงชนะกฎอนุญาตที่ตามมาทุกครั้ง

ทำความเข้าใจขอบเขตและไวลด์การ์ด

สามเรื่องที่มักสะดุดตอนเขียนครั้งแรก

1. อย่างแรกคือ ขอบเขต (scope) ไฟล์ .claude/settings.json ของโปรเจกต์จะ override ไฟล์ ~/.claude/settings.json แบบโกลบอล ดังนั้นหากอนุญาต Bash(rm *) ไว้ระดับโกลบอล แต่โปรเจกต์ปฏิเสธ โปรเจกต์จะชนะ นี่คือดีฟอลต์ที่ถูกต้อง แต่ทำให้หลายคนแปลกใจเพราะคาดว่าการอนุญาตแบบโกลบอลจะยึดอยู่ตลอด

2. อย่างที่สองคือ ไวลด์การ์ดกับคำสั่งเครือข่าย Bash(curl http://github.com/ *) ดูเคร่งครัด แต่ไม่ครอบคลุม https:// ตัวเลือกก่อน URL การรีไดเรกต์ หรือการขยายตัวแปรเชลล์ รูปแบบที่เอกสารแนะนำคือปฏิเสธ Bash(curl *) ไปเลย แล้วใช้เครื่องมือ WebFetch พร้อม WebFetch(domain:github.com) สำหรับโดเมนที่ต้องการอนุญาตจริงๆ

3. อย่างที่สามคือ ช่องว่าง Bash(ls *) จับคู่กับ ls -la แต่ไม่ใช่ lsof ส่วน Bash(ls*) จับคู่ได้ทั้งสองอย่าง ช่องว่างก่อนดอกจันมีผลจริง ควรใส่ใจว่าพิมพ์แบบไหน

คีย์ไบน์ดิงบางตัวอยู่ในหมวดเดียวกับสิทธิ์การเข้าถึง คือ "เลิกฝืนสู้กับเทอร์มินัล" ควรเรียนรู้ตั้งแต่วันแรก:

• Shift+Tab สลับโหมดสิทธิ์ (ดีฟอลต์, ยอมรับอัตโนมัติ, วางแผน)

• Esc+Esc เปิดตัวเลือกย้อนกลับ (รายละเอียดในหัวข้อที่ 3)

• Ctrl+R ค้นหาย้อนหลังในประวัติพรอมป์ต์ เหมือนใน bash และ zsh

• Ctrl+U ลบจากตำแหน่งเคอร์เซอร์ถึงต้นบรรทัด

• Shift+Enter เพิ่มบรรทัดใหม่ในพรอมป์ต์

คีย์ไบน์ดิงส่วนใหญ่ใช้ได้ทันทีในเทอร์มินัล หากใช้ไม่ได้ ให้รันสแลชคอมมานด์ /terminal-setup หนึ่งครั้งเพื่อติดตั้งทุกอย่าง

2. ทำให้ Claude Code จำโปรเจกต์ของคุณได้

ทุกเซสชันเริ่มด้วยหน้าต่างบริบทใหม่สดเสมอ

ตามดีฟอลต์ Claude จะไม่จำว่าคุณใช้ uv แทน pip มันจะไม่จำว่าเทสต์อยู่ใน tests/ ไม่ใช่ test/ และข้อตกลงการใช้ API ที่อธิบายไปเป็นสิบเทิร์นเมื่อวานก็หายไปด้วย ทางแก้คือต้องมีไฟล์ CLAUDE.md ที่รูทโปรเจกต์ เปิด Claude Code จากไดเรกทอรีนั้น (หรือไดเรกทอรีย่อยใดๆ) ไฟล์จะถูกโหลดเข้าบริบทอัตโนมัติก่อนพรอมป์ต์แรก

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

มีแหล่งบริบท 3 จุดที่ Claude มองหา เรียงซ้อนกัน:

Project CLAUDE.md ที่ ./CLAUDE.md รวมมากับรีโปเดียวกันสำหรับผู้ร่วมงานทุกคน ดังนั้นให้ใส่ข้อเท็จจริงเฉพาะโปรเจกต์ไว้ที่นี่:

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

User CLAUDE.md ที่ ~/.claude/CLAUDE.md ใช้ได้กับทุกโปรเจกต์ในเครื่องของคุณ ใส่ความชอบส่วนตัว เช่น สไตล์การโค้ด รูปแบบการเขียน docstring ภาษาที่ถนัด อย่าใส่ข้อเท็จจริงของโปรเจกต์ เพราะจะไหลไปปนกับรีโปอื่นที่เปิด

หน่วยความจำอัตโนมัติ (Auto-memory) คือชั้นที่สามที่ Claude เขียนเอง เมื่อคุณแก้ไขมันระหว่างเซสชัน (เช่น "ที่นี่ใช้ snake_case ไม่ใช่ camelCase") มันจะบันทึกลงที่ ~/.claude/projects/<project>/memory/MEMORY.md บรรทัดแรก 200 บรรทัดหรือ 25KB แรกของไฟล์นี้จะถูกโหลดตอนเริ่มทุกการสนทนาในโปรเจกต์เดียวกัน ดูข้อมูลที่โหลดได้ด้วย /memory และใช้เปิด/ปิด auto-memory ได้ด้วย

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

3. เลิกรีสตาร์ตเซสชันเมื่อเริ่มผิดทาง

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

อย่างแรกคือต้องรู้จักอาการ การผุกร่อนของบริบทมีสัญญาณชัดๆ ไม่กี่อย่าง:

• Claude ขอพาธไฟล์ที่เพิ่งแก้ไปเมื่อห้าเทิร์นก่อนอีกรอบ
• เสนอไอเดียซ้ำที่ถูกปฏิเสธไปแล้ว
• หลงว่าอยู่บนกิ่ง (branch) ไหน
• คุณต้องแก้ให้มันเรื่องเดิมมากกว่าสองครั้งในเซสชันเดียว

เมื่อเห็นแบบนั้นแล้ว มีสี่ทางเลือก ซึ่งใช้แทนกันไม่ได้:

ย่อเซสชันของคุณ

 /compact ไม่ได้แย่อย่างที่บางคนว่า

ไฟล์ CLAUDE.md ของโปรเจกต์จะรอด Claude จะอ่านไฟล์จากดิสก์ใหม่หลังย่อ แล้วฉีดกลับเข้ามา ดังนั้นกฎเกณฑ์ของโปรเจกต์จะไม่หายไป นอกจากนี้ยังส่งคำสั่งโฟกัสเพื่อกำกับสรุปได้ เช่น /compact keep the auth refactor decisions, drop the failed test runs ต่างกันมากระหว่างสรุปที่เป็นประโยชน์กับสรุปทั่วไป

ใช้ตัวเลือก "เลิกทำ" ของ Claude Code

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

"กู้โค้ดและการสนทนา" คือสิ่งที่คนส่วนใหญ่ต้องการ สามสิบนาทีที่หลงทางหายวับไปโดยไม่ต้องเปิด git เป็นสิ่งที่ใกล้เคียงกับการเลิกทำทั้งเซสชันมากที่สุดใน Claude Code

เมื่อเลิกรีสตาร์ตแล้ว ปัญหาต่อไปคือหาคืนเซสชัน

ตั้งชื่อและเปิดเซสชันซ้ำ

claude -n <name> (หรือ --name) เริ่มเซสชันแบบตั้งชื่อ และชื่อจะปรากฏใน /resume และชื่อหน้าต่างเทอร์มินัล เมื่อทำสามอย่างในรีโปเดียวกัน (กิ่งทดลอง รีแฟกเตอร์ ดีบัก) ชื่อคือวิธีแยกแยะ ใช้ /rename เพื่อเปลี่ยนชื่อกลางเซสชันหากสโคปเปลี่ยน

ทริค: ใช้ /color เพื่อแยกความต่างของเซสชันเพิ่ม เมื่อรันหลายเซสชันในหน้าต่างเดียว

การเปิดเซสชันซ้ำมีสองแฟล็ก claude --continue (หรือ -c) โหลดการสนทนาล่าสุดในไดเรกทอรีปัจจุบัน ใช้เมื่อเพิ่งทำอยู่ที่นี่และอยากต่อเนื่อง

claude --resume เปิดตัวเลือกระบบโต้ตอบ และ claude --resume <name-or-id> กระโดดตรงไปยังเซสชันที่ระบุ จัดการเซสชันเหมือนกิ่ง git: งานคนละสายควรมีของตัวเอง

4. วางแผนงานยาก ประหยัดกับงานง่าย

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

การใช้โหมดวางแผนของ Claude Code

โหมดวางแผนสั่งให้ Claude คิดกลยุทธ์ก่อนแตะไฟล์ มันจะเขียนแผน คุณอ่าน อนุมัติหรือทักท้วง แล้วค่อยลงมือทำ

ทริคง่ายๆ ที่ใช้ทำให้แผนแน่นคือพรอมป์ต์นี้ที่ใช้บ่อย:

Red-team this plan from multiple angles using as many Opus 4.7 agents as you need.

นี่จะเปิดซับเอเจนต์หลายตัวเพื่อรีวิวแผนจากหลายมุมและเสนอวิธีแก้ไข เหมาะเมื่อจัดการกับไฟล์แผนที่ยาวเกิน 500 บรรทัด

ต้นทุนคือการวางแผนบวกการทดสอบแบบ red-team จะเพิ่มสองเทิร์นก่อนมีโค้ดใดๆ ดังนั้นสำหรับงานที่ไม่ใช่ฟีเจอร์ใหญ่หรือบั๊กสำคัญ จะเกินความจำเป็น

มีห้าวิธีเข้าสู่โหมดวางแผน:

ฟอร์มแบบอินไลน์ (/plan refactor the auth module to use JWT) เป็นสิ่งที่หลายคนพลาด ตั้งโหมดและงานในครั้งเดียวแทนที่จะสองครั้ง สำหรับเวิร์กโฟลว์รีวิวก่อนทำอย่างละเอียด ดู บทเรียนโหมดวางแผนของ Claude Code ที่อธิบายทีละขั้น

ตั้งระดับความพยายามให้เหมาะสม

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

/effort <level> และแฟล็ก --effort <level> ของ CLI รองรับทั้งห้าค่า low, medium, high และ xhigh จะคงอยู่ข้ามเซสชัน ส่วน max ใช้ได้เฉพาะเซสชันปัจจุบันเพราะปลดข้อจำกัดการใช้โทเค็น จึงต้องตั้งอย่างตั้งใจทุกครั้ง ดีฟอลต์ที่เหมาะสำหรับงานประจำวันคือ low หรือ medium เก็บ high หรือ xhigh ไว้สำหรับปัญหายากจริงๆ และ max สำหรับช่วงที่ยอมเผาโทเค็นดีกว่าทำพลาด

ข้อสังเกตอีกด้าน: โมเดลที่ตั้ง low พร้อมบริบทที่ดี มักชนะโมเดลเดียวกันที่ตั้ง max แต่บริบทแย่ การปรับพรอมป์ต์ให้สะอาดมักให้ผลดีกว่าการเร่ง effort

เลือกโมเดลให้เหมาะ

การเลือกโมเดลคือจุดที่ประหยัดต้นทุนได้จริง /model สลับกลางเซสชัน และ Option+P (macOS) / Alt+P (Win/Linux) จะสลับโดยไม่ล้างข้อความที่พิมพ์ไว้ อะไลแอสที่ควรรู้:

• sonnet คือดีฟอลต์สำหรับงานประจำวัน

• opus สำหรับปัญหายากที่สุด (อะไลแอส best ก็ชี้ไปที่ opus)

• haiku สำหรับงานที่ต้องการความเร็ว

• sonnet[1m] และ opus[1m] คือรุ่นบริบท 1M

• opusplan ใช้ Opus ในโหมดวางแผนและ Sonnet ในการลงมือทำ

• default ล้างการ override และกลับไปโมเดลที่แนะนำ

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

Opus เหมาะเมื่อสะดุดกับปัญหายากและต้องการโมเดลที่ฉลาดที่สุด ส่วน Sonnet จัดการได้แทบทั้งหมด ช่องว่างต้นทุนระหว่างสองตัวใหญ่พอที่นิสัย "ใช้ Opus ไว้ก่อนเพื่อความชัวร์" จะกลายเป็นความฟุ่มเฟือยที่สุดหากปล่อยอัตโนมัติ

5. ทำงานซ้ำๆ ให้เป็นอัตโนมัติ

เมื่อกำจัดแหล่งความฝืดแล้ว ชั้นถัดไปคือสิ่งที่ยังทำด้วยมือ

งานตามกำหนดเวลา

ทำให้อัตโนมัติง่ายกว่าหาทางไม่ทำ สองฟีเจอร์ครอบคลุมส่วนใหญ่: /loop สำหรับการตรวจซ้ำๆ ที่ไม่งั้นต้องเฝ้าเอง และฮุกส์สำหรับการรับประกันที่ CLAUDE.md ให้ไม่ได้

/loop จะรันพรอมป์ต์หรือสแลชคอมมานด์ซ้ำตามกำหนด มีไวยากรณ์สองแบบ:

• /loop 5m <prompt> รันพรอมป์ต์ทุก 5 นาที

• /loop <prompt> เพียงอย่างเดียวจะให้โมเดลเป็นผู้กำหนดจังหวะว่าจะรันเมื่อไรอีกครั้ง

หน่วยช่วงเวลาได้แก่ s, m, h และ d ขั้นต่ำหนึ่งนาที ต้องใช้ Claude Code v2.1.72 หรือใหม่กว่า

ตัวอย่าง เช่น ตั้งตัวเฝ้าเทสต์: /loop 2m run the test suite and report failures แทนที่จะต้องจำรันเทสต์หลังแก้ไขทุกครั้ง (ซึ่งมักลืมครึ่งหนึ่ง) Claude จะจับเทสต์แตกในรอบ 2 นาทีถัดไป

รูปแบบเดียวกันใช้ได้กับการโพลสถานะดีพลอยสเตจจิง (/loop 10m check if the staging deploy is green) หรือการ tail ล็อกระหว่างเหตุการณ์ที่ไม่เสถียร (/loop 1m tail the last 50 lines of app.log and flag errors)

ลูปมีอายุ 7 วัน

งานจะรันครั้งสุดท้ายในวันที่เจ็ดแล้วลบตนเอง ลูปจะผูกกับเซสชัน ดังนั้น --continue หรือ --resume จะพามันกลับมาหากปิดแล้วเปิดใหม่ ต้องการหยุดก่อน กด Esc หากต้องการตารางเวลาที่อยู่รอดหลังปิดเซสชัน (ตรวจรายคืน สรุปรายสัปดาห์) ให้ใช้ Routines ผ่าน /schedule แทน

ฮุกส์

ฮุกส์คืออีกครึ่งหนึ่ง มันรันคำสั่งเชลล์ในจุดต่างๆ ของเวิร์กโฟลว์ของ Claude กำหนดใน .claude/settings.json 

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

มีหกเหตุการณ์ที่ครอบคลุมส่วนใหญ่:

ตัวอย่างฮุกส์ ขั้นต่ำของ PostToolUse ที่รันลินเตอร์หลังแก้ไขไฟล์ทุกครั้ง:

{
  "hooks": {
	"PostToolUse": [
  	{
    	"matcher": "Edit|Write",
    	"hooks": [
      	{ "type": "command", "command": "/path/to/lint-check.sh" }
    	]
  	}
	]
  }
}

จุดที่ควรจำ: มีเพียงโค้ดออก 2 เท่านั้นที่บล็อก Claude ได้ โค้ดออก 1 ถือเป็นข้อผิดพลาดที่ไม่บล็อก และ Claude จะทำต่อไป แม้ 1 จะเป็นรหัสล้มเหลวของ Unix ทั่วไป หากฮุกส์ตั้งใจบังคับใช้กฎ ให้คืนค่า 2

ไม่จำเป็นต้องเขียนฮุกส์เองก็ได้

สั่ง Claude ด้วย "write a hook that runs ruff after every file edit" มันจะร่าง JSON ให้ /hooks แสดงการตั้งค่าฮุกส์ทั้งหมดที่ใช้งานอยู่ จึงไม่ต้อง grep ไฟล์ตั้งค่าเมื่อมีบางอย่างรันโดยไม่คาดคิด สำหรับแค็ตตาล็อกเหตุการณ์เต็มและสคีมา JSON ของ stdin/stdout ดู บทเรียนฮุกส์ของ Claude Code.

6. จับตาต้นทุนทั้งหมดนี้

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

/usage แสดงแพ็กเกจที่ใช้ ยอดรวมของเซสชัน แยกต้นทุนรายโมเดล และแถบความคืบหน้าสำหรับหน้าต่างจำกัดอัตราแบบ 5 ชั่วโมงและรายสัปดาห์

/context แสดงภาพหน้าต่างบริบทปัจจุบันเป็นกริดสี พร้อมคำเตือนความจุและข้อเสนอแนะว่าเครื่องมือหรือไฟล์ใดกินพื้นที่ ใช้เมื่อเซสชันเริ่มหนัก และชั่งใจระหว่าง /compact กับ /clear.

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

คุณสามารถรัน /statusline แล้วบรรยายเป็นภาษาธรรมดาว่าอยากให้แสดงอะไร Claude จะสร้างสคริปต์และอัปเดตการตั้งค่า อีกทางคือเขียนสคริปต์เชลล์เองแล้วชี้จาก ~/.claude/settings.json:

{
  "statusLine": {
	"type": "command",
	"command": "~/.claude/statusline.sh"
  }
}

สำหรับการติดตามระยะยาวข้ามเซสชัน npx ccusage เป็นเครื่องมือคอมมูนิตี้ที่รวมการใช้โทเค็นตามกาลเวลา เป็นของบุคคลที่สาม ไม่ได้สร้างโดย Anthropic แต่เติมเต็มช่องว่างระหว่าง /usage แบบผูกเซสชันกับบิลรายเดือนของคุณ

7. อีกสามอย่างที่ควรรู้

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

ใช้กดค้างพูดด้วย /voice

/voice เปิดโหมดกดค้างเพื่อพูด กดค้าง Space พูด ปล่อย แล้วข้อความถอดเสียงจะลงในช่องพรอมป์ต์ ต้องใช้ v2.1.69 หรือใหม่กว่า และรองรับยี่สิบภาษา

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

ดึงเซสชันบนคลาวด์ด้วย /teleport

/teleport (อะไลแอส /tp) ดึงเซสชันคลาวด์เข้ามาในเทอร์มินัลโลคัล สมมติเริ่มงานยาวบนเว็บแอปหรือ iOS แล้วกลับมาที่แล็ปท็อป รัน claude --teleport เพื่อเปิดตัวเลือกและดึงเซสชันนั้นเข้ามาในเทอร์มินัล โดยเช็คเอาต์กิ่งที่ถูกต้องไว้ให้แล้ว

มีข้อกำหนดบางอย่างที่ต้องตรงกัน:

• สถานะ git สะอาด
• รีโปที่ถูกต้อง
• บัญชี claude.ai เดียวกับที่รันเซสชันคลาวด์
• กิ่งถูกพุชขึ้นรีโมตแล้ว

อย่าสับสนระหว่าง --teleport กับ --resume อันหลังเปิดเฉพาะเซสชันโลคัลจากประวัติเครื่องนี้ สำหรับรายละเอียดเพิ่มเติม ดู บทเรียนควบคุมระยะไกลของ Claude Code ของเรา

ถามคำถามข้างทางด้วย /btw

/btw เหมาะสำหรับคำถามสั้นๆ ที่อยากถามโดยไม่ทำลายจังหวะ

นึกภาพว่า Claude กำลังทำงานอยู่แล้ว คุณเริ่มแก้ไขยาวหรือเรียกใช้เครื่องมือไปแล้ว และจู่ๆ ก็อยากรู้เรกซ์สำหรับจับ IP หรือแฟล็กไหนทำ X 

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

สรุป

วิธีล้มเหลวเร็วที่สุดกับทุกอย่างในบทความนี้คือพยายามทำทั้งหมดในวันเดียว เลือกสักสองสามข้อ ฝึกให้ติดมือ แล้วค่อยเพิ่มอย่างอื่นเมื่อชุดแรกเป็นอัตโนมัติ

เริ่มด้วยสามข้อ แต่ละข้อครอบคลุมช่วงต่างกันของวัน เพื่อไม่ให้แย่งกัน:

• ไฟล์ CLAUDE.md ของโปรเจกต์ที่กระชับ บวกกฎสิทธิ์ไวลด์การ์ดสองสามข้อใน .claude/settings.json สำหรับคำสั่ง bash ที่ต้องกดยอมรับซ้ำ นี่คือกิจวัตรตอนเช้า และจะรู้สึกได้เมื่อการขัดจังหวะหายไป

• การตัดสินใจระหว่าง /compact กับ /clear และตัวเลือกย้อนกลับ Esc+Esc นี่คือกิจวัตรกลางเซสชัน สัญญาณคือช่วงที่ Claude ขอพาธไฟล์เดิมที่รู้เมื่อชั่วโมงก่อน

• ตั้ง /loop หนึ่งตัวสำหรับการตรวจซ้ำที่กินเวลาอยู่แล้ว นี่คือกิจวัตรเบื้องหลัง และเมื่อมันทำงาน มันจะคืนกำไรเอง

หากยังสับสนระหว่าง Sonnet, Opus และ Haiku ลองดู คอร์ส Introduction to Claude Models ของเรา ซึ่งอธิบายว่าแต่ละโมเดลเหมาะตอนไหน ช่วยให้คำสั่ง /effort และ /model ใช้ง่ายขึ้นมาก