Claude Code เครื่องมือช่วยเขียนโค้ดจาก Anthropic แตกต่างจาก AI ทั่วไปตรงที่ไม่ได้แค่ตอบโค้ดให้เราก๊อปปี้ไปวางเอง แต่เข้ามาทำงานกับโปรเจกต์ของเราในเครื่องโดยตรง ตั้งแต่เปิดอ่านไฟล์ ลงมือแก้โค้ด รันคำสั่งใน terminal ไปจนถึงตรวจผลลัพธ์ซ้ำจนกว่างานจะผ่านจริง

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

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

1. ติดตั้ง Claude Code และสั่งงานครั้งแรก

การทำงานของ Claude Code: วนลูปจนงานเสร็จ ไม่ใช่แค่ถามแล้วจบ

Claude Code ไม่ได้ทำงานแบบถามคำตอบคำ แต่ทำงานเป็นวงรอบ 3 ขั้นตอน คือ หาข้อมูล -> ลงมือทำ -> ตรวจสอบผล และวนซ้ำไปเรื่อยๆ จนกว่างานจะเสร็จสมบูรณ์ ทุกจังหวะเกิดขึ้นต่อเนื่องกัน และเราสามารถขัดจังหวะเพื่อสั่งงานใหม่ได้ตลอดเวลา

งานแก้เทสต์ที่ยกตัวอย่างไปข้างต้นก็คือลูปนี้ครบทุกขั้นตอน:

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

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

เราสามารถเลือกสลับโมเดลที่ใช้คิดได้ตามความเหมาะสม โดยโมเดลตระกูล Claude รุ่น Sonnet รับงานเขียนโค้ดส่วนใหญ่ได้ดี ส่วนรุ่น Opus จะคิดวิเคราะห์ได้ลึกกว่า เหมาะกับงานวางสถาปัตยกรรมหรือการตัดสินใจเรื่องโครงสร้างที่ซับซ้อน เราสลับรุ่นไปมาได้ตลอดเวลาด้วยคำสั่ง /model

ทันทีที่เราเปิด Claude Code ในโฟลเดอร์โปรเจกต์ ตัวโปรแกรมจะเข้าถึงไฟล์ทั้งหมดในโปรเจกต์ได้ทันที และสามารถรันคำสั่งผ่าน terminal ได้เทียบเท่ากับคำสั่งที่เราพิมพ์เอง นอกจากนี้ยังอ่านสถานะจาก Git ออกด้วยว่าเรากำลังทำงานอยู่บน branch ไหน และมีไฟล์อะไรที่แก้ไขค้างไว้บ้าง

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

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

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

ติดตั้งด้วยคำสั่งบรรทัดเดียว

สิ่งที่ต้องเตรียมก่อนเริ่มต้นใช้งานมี 3 อย่าง คือ หน้าต่าง terminal, โฟลเดอร์โปรเจกต์โค้ดสักโปรเจกต์ และบัญชีที่รองรับ Claude Code ได้แก่ สมาชิกแพ็กเกจ Claude (Pro, Max, Team หรือ Enterprise) หรือบัญชี Claude Console ที่เติมเครดิตไว้ล่วงหน้า

สำหรับใครที่ไม่เคยใช้ terminal มาก่อน ทาง Anthropic มีคู่มือ terminal สำหรับมือใหม่ สอนตั้งแต่การเปิดหน้าต่างโปรแกรมไปจนถึงวิธีวางคำสั่ง

สำหรับ macOS, Linux หรือระบบจำลอง Linux บน Windows อย่าง WSL ให้ใช้คำสั่งนี้:

curl -fsSL https://claude.ai/install.sh | bash

สำหรับ Windows หากใช้ PowerShell ให้รันคำสั่งนี้:

irm https://claude.ai/install.ps1 | iex

หากใช้หน้าต่าง Command Prompt หรือ CMD ให้ใช้คำสั่งนี้แทน:

curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

จุดที่สับสนง่ายบน Windows คือไม่แน่ใจว่ากำลังเปิด PowerShell หรือ CMD อยู่ วิธีสังเกตง่ายๆ ให้ดูที่ต้นบรรทัด ถ้าขึ้นต้นด้วย PS C:\ แสดงว่าเป็น PowerShell แต่ถ้าขึ้นแค่ C:\ แปลว่าเป็น CMD

หากวางคำสั่งผิดโปรแกรม หน้าจอจะแจ้ง error ชัดเจน: ถ้าเจอข้อความ The token '&&' is not a valid statement separator แปลว่าคุณวางคำสั่ง CMD ลงใน PowerShell แต่ถ้าเจอข้อความ 'irm' is not recognized as an internal or external command แปลว่าคุณวางคำสั่ง PowerShell ลงใน CMD

สำหรับผู้ใช้ Windows ที่ไม่ได้ติดตั้งผ่าน WSL แนะนำให้ลง Git for Windows ไว้ด้วย ไม่อย่างนั้น Claude Code จะไปรันคำสั่งต่างๆ ผ่าน PowerShell แทน

คำสั่งติดตั้งจะไม่แสดงแถบความคืบหน้าระหว่างดาวน์โหลด ให้รอจนคำสั่งทำงานเสร็จ จากนั้นปิดแล้วเปิดหน้าต่าง terminal ใหม่ แล้วพิมพ์คำสั่งเพื่อตรวจสอบ:

claude --version

ถ้าติดตั้งเรียบร้อย จะเห็นเลขเวอร์ชันตามด้วยข้อความ (Claude Code) แต่ถ้าเปิด terminal ใหม่แล้วยังขึ้นว่าไม่รู้จักคำสั่ง claude แสดงว่ายังไม่ได้เพิ่มโฟลเดอร์ที่ติดตั้งลงใน PATH ของระบบ ดูแนวทางแก้ไขได้จากหน้าแก้ปัญหาการติดตั้ง และสำหรับผู้ใช้ Windows ดูขั้นตอนอย่างละเอียดพร้อมการตั้งค่า PATH ได้ที่บทความวิธีติดตั้ง Claude Code บน Windows 11

เมื่อติดตั้งด้วยวิธีนี้ Claude Code จะอัปเดตเวอร์ชันใหม่ให้อัตโนมัติในเบื้องหลัง เราไม่ต้องคอยพิมพ์อัปเดตเอง

ล็อกอินและสั่งงานครั้งแรก

เริ่มต้นด้วยการเข้าไปยังโฟลเดอร์โปรเจกต์แล้วเปิด Claude Code:

cd /path/to/your/project
claude

(เปลี่ยน /path/to/your/project ให้เป็นโฟลเดอร์จริงของโปรเจกต์คุณ)

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

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

what does this project do?
where is the main entry point?
explain the folder structure

เมื่อเริ่มเข้าใจโครงสร้างของโปรเจกต์แล้ว ลองสั่งให้ Claude ลงมือแก้โค้ดจริงชิ้นเล็กๆ ดู:

add a hello world function to the main file

Claude จะค้นหาไฟล์หลักเอง แล้วแสดงโค้ดที่จะแก้ให้เราดู ถ้ามันถามก่อนลงมือแก้ ก็ตอบ Yes ได้เลย

นอกจากนี้ เรายังสั่งงาน Git ด้วยประโยคธรรมดาได้เช่นกัน ตัวอย่างคำสั่งบรรทัดที่สองด้านล่าง จะให้ Claude ช่วยสร้าง commit พร้อมคิด commit message ให้เสร็จสรรพ:

what files have I changed?
commit my changes with a descriptive message
create a new branch called feature/quickstart

หลักการสำคัญคือ ยิ่งคำสั่งของเราชัดเจน ผลงานที่ได้ก็ยิ่งตรงจุด แทนที่จะสั่งสั้นๆ แค่ fix the bug ให้บอกอาการและบริบทที่เกิดขึ้นให้ครบถ้วน เช่น fix the login bug where users see a blank screen after entering wrong credentials

นอกจากการเปิดแบบพิมพ์คุยโต้ตอบแล้ว เรายังสามารถเรียกใช้คำสั่ง claude ในรูปแบบอื่นๆ ได้ด้วย:

หากต้องการออกจาก Claude Code ให้พิมพ์ /exit หรือกด Ctrl+D สองครั้ง

หากติดปัญหาตรงไหน เราสามารถพิมพ์ถาม Claude Code เกี่ยวกับตัวมันเองได้ตรงๆ เช่น how do I set up hooks? หรือพิมพ์ /powerup เพื่อเปิดโหมดเรียนรู้แบบโต้ตอบพร้อมภาพประกอบเคลื่อนไหว ส่วน /doctor จะช่วยตรวจการติดตั้งและการตั้งค่าต่างๆ พร้อมแนะวิธีแก้ปัญหา นอกจากนี้ยังมีคอร์สเรียนฟรี Claude Code 101 ของ Claude Academy ให้ศึกษาเพิ่มเติมอีกด้วย

2. ใช้งานจริงในชีวิตประจำวัน ตั้งแต่คีย์ลัดไปจนถึง Plan Mode

คีย์ลัดควบคุมการทำงานของ Claude

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

สำหรับผู้ใช้ macOS คีย์ลัดที่ใช้ปุ่ม Option จำเป็นต้องตั้งค่าใน terminal ให้ใช้ปุ่ม Option เป็น Meta key เสียก่อน ส่วนการพิมพ์ขึ้นบรรทัดใหม่โดยไม่ส่งข้อความ ให้กดเครื่องหมาย \ ตามด้วย Enter หรือจะกด Ctrl+J ก็ได้เช่นกัน

นอกจากนี้ อักขระตัวแรกที่เราพิมพ์ลงในช่องข้อความยังมีความหมายพิเศษ:

• / ใช้เรียกคำสั่งระบบหรือ Slash Commands
• ! ใช้สั่งรันคำสั่งผ่านระบบควบคุมอย่าง shell ตรงๆ บนเครื่องเรา เช่น ! npm test แล้วผลลัพธ์จะส่งต่อให้ Claude วิเคราะห์จุดที่พังได้ทันทีโดยไม่ต้องสั่งซ้ำ
• @ ใช้อ้างอิงและค้นหาไฟล์ในโปรเจกต์ เช่น Explain the logic in @src/utils/auth.js
• ? ใช้เปิดดูรายการคีย์ลัดทั้งหมด (กดเมื่อช่องพิมพ์ข้อความว่างอยู่)

Slash Commands พื้นฐานที่ควรรู้จัก

เมื่อพิมพ์เครื่องหมาย / จะมีเมนูคำสั่งทั้งหมดปรากฏขึ้นมา โดยเราสามารถพิมพ์ตัวอักษรต่อไปเพื่อค้นหาคำสั่งที่ต้องการได้อย่างรวดเร็ว รายการคำสั่งนี้จะเพิ่มขึ้นตาม Skills หรือ Plugins ที่เราติดตั้งเสริมในภายหลัง

สิ่งที่ควรแยกให้ออกคือ รายการที่ขึ้นต้นด้วย / มีคำสั่ง 2 ประเภทปนกันอยู่ ได้แก่ คำสั่งระบบพื้นฐาน เช่น /clear ที่ทำงานตรงไปตรงมาเหมือนการกดปุ่มสั่งงาน และ Skill สำเร็จรูป เช่น /code-review ซึ่งเป็นการส่งชุดคำสั่งเฉพาะทางให้ Claude นำไปคิดวิเคราะห์และลงมือทำงานต่อเอง

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

สำรวจโค้ด แก้บั๊ก และเขียนเทสต์

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

give me an overview of this codebase
find the files that handle user authentication
trace the login process from front-end to database

สำหรับการแก้บั๊ก แนะนำให้แบ่งเป็น 3 จังหวะ: บอกอาการให้ชัดเจน -> ขอแนวทางแก้ไข -> สั่งลงมือแก้ตามแนวทางที่เลือก:

I'm seeing an error when I run npm test
suggest a few ways to fix the @ts-ignore in user.ts
update user.ts to add the null check you suggested

เวลาเล่าอาการของบั๊ก ควรระบุคำสั่งที่ทำให้เกิด error ซ้ำ พร้อมแนบ stack trace และบอกด้วยว่าอาการนี้เกิดขึ้นทุกครั้งหรือเป็นแค่บางครั้ง

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

find functions in NotificationsService.swift that are not covered by tests
add tests for the notification service
run the new tests and fix any failures

เมื่องานเสร็จสิ้น เราสามารถสั่ง create a pr เพื่อให้ Claude เปิด Pull Request บน GitHub ให้ได้ทันที นอกจากนี้เรายังส่งรูปภาพได้ด้วย โดยการลากรูปมาวางในหน้าต่างหรือกด Ctrl+V แล้วสั่งงาน เช่น Generate CSS to match this design mockup

บันทึก Session และกลับมาคุยต่อได้ตลอดเวลา

Claude Code จะบันทึก session ไว้ในเครื่องของเราตลอดเวลา โดยแยกตามแต่ละโฟลเดอร์โปรเจกต์ และจัดเก็บเป็นไฟล์ข้อความธรรมดาไว้ที่ ~/.claude/projects/ ทำให้แม้เราจะปิด terminal ไปแล้ว ก็สามารถเปิดกลับมาคุยต่อได้เสมอ:

claude --continue
claude --resume

บรรทัดแรก (--continue หรือ -c) จะเปิดบทสนทนาต่อจาก session ล่าสุดในโปรเจกต์นั้น ส่วนบรรทัดที่สอง (--resume หรือ -r) จะแสดงรายการ session ทั้งหมดให้เราเลือกเปิด หรือถ้าเปิดหน้าแชตอยู่แล้ว ก็พิมพ์คำสั่ง /resume ได้เช่นกัน

เนื่องจาก session ที่ไม่ได้ตั้งชื่อจะหาย้อนหลังได้ยาก แนะนำให้ตั้งชื่อ session กำกับไว้เสมอ เช่น /rename oauth-migration แล้ววันหลังค่อยพิมพ์เรียกกลับมาด้วย /resume oauth-migration หากเราอยากลองแก้โค้ดอีกแนวทางหนึ่งโดยไม่ทับของเดิม ให้ใช้คำสั่ง /branch เพื่อโคลนประวัติการคุยจนถึงปัจจุบันแยกออกไปเป็น session ใหม่ โดย session เดิมจะยังคงอยู่และสลับกลับมาได้เสมอ

คำสั่งที่ช่วยคืนพื้นที่ Context มี 2 คำสั่งที่ทำงานต่างกันชัดเจน คือ /clear และ /compact:

• /clear คือการล้างกระดานเพื่อเริ่มคุยใหม่ด้วย context ที่ว่างเปล่า (session เก่าจะบันทึกเก็บไว้ เรียกกลับมาดูได้เสมอ)
• /compact คือการสั่งให้ระบบช่วยสรุปย่อบทสนทนาเดิมให้สั้นลงเพื่อประหยัดพื้นที่ แล้วคุยงานเดิมต่อได้ทันที โดยระบุได้ว่าอยากให้เน้นเก็บข้อมูลส่วนไหนไว้ เช่น /compact focus on the API changes

สรุปวิธีเลือกใช้ง่ายๆ: ถ้าจะเปลี่ยนไปทำเรื่องใหม่ ให้ใช้ /clear แต่ถ้ายังทำงานเดิมอยู่แล้วพื้นที่ความจำใกล้เต็ม ให้ใช้ /compact

Checkpoint ย้อนโค้ดกลับไปยังจุดก่อนที่ Claude จะเริ่มแก้

ทุกครั้งก่อนที่ Claude Code จะลงมือทำตามคำสั่งของเรา ระบบจะสร้างสำเนาไฟล์ที่เกี่ยวข้องเก็บไว้ 1 ชุด จุดสำรองข้อมูลนี้เรียกว่า Checkpoint หากผลลัพธ์การแก้โค้ดของ Claude ออกมาไม่ตรงใจหรือผิดทาง เราสามารถกด Esc สองครั้ง (ตอนที่ช่องพิมพ์ข้อความว่างอยู่) หรือพิมพ์คำสั่ง /rewind เพื่อเปิดเมนูย้อนกลับได้ทันที:

• Restore code and conversation: ย้อนทั้งโค้ดและประวัติการสนทนากลับไปยังจุดนั้น
• Restore conversation: ย้อนเฉพาะประวัติการสนทนา แต่คงโค้ดล่าสุดไว้เหมือนเดิม
• Restore code: ย้อนเฉพาะโค้ดกลับไป แต่คงประวัติการสนทนาล่าสุดไว้เหมือนเดิม
• Summarize from here หรือ Summarize up to here: สั่งสรุปย่อบทสนทนาเฉพาะช่วงที่เลือก คล้ายคำสั่ง /compact แต่เลือกกำหนดช่วงเองได้

ระบบ Checkpoint ช่วยให้เรากล้าสั่งให้ Claude ลองแก้โค้ดในแนวทางที่ซับซ้อนหรือเสี่ยงขึ้นได้ เพราะถ้าไม่ได้ผลก็แค่กดย้อนกลับแล้วเริ่มใหม่ได้ทันที

แต่ Checkpoint ไม่ได้ครอบคลุมการกระทำทุกอย่าง: ไฟล์ที่ถูกลบหรือย้ายด้วยคำสั่ง shell เช่น rm, mv, cp จะย้อนคืนไม่ได้, การแก้ไขไฟล์นอก Claude Code ก็จะไม่บันทึกไว้ และการทำงานที่ส่งผลต่อระบบภายนอก เช่น การอัปเดตฐานข้อมูลหรือการ deploy ก็ย้อนกลับไม่ได้เช่นกัน Checkpoint จึงนำมาใช้แทน Git ไม่ได้ ประวัติการแก้โค้ดที่ถาวรยังคงต้องอาศัยการ commit ใน Git เป็นหลัก

ข้อควรระวัง: หากกด Esc สองครั้งขณะที่มีข้อความพิมพ์ค้างอยู่ในช่องพิมพ์ จะเป็นการล้างข้อความนั้นทิ้งแทนการเปิดเมนู Checkpoint (หากเผลอกด ให้กดปุ่มลูกศรขึ้นเพื่อดึงข้อความกลับมาได้)

ควบคุมความปลอดภัยด้วย Permission Modes และ Plan Mode

Claude จะลงมือทำอะไรได้เองแค่ไหนโดยไม่ต้องรอถามเรา ขึ้นอยู่กับการตั้งค่า Permission Mode ในโหมดที่ต้องขออนุญาต เมื่อ Claude ต้องการรันคำสั่งหรือแก้ไขไฟล์ จะมีกล่องข้อความยืนยันขึ้นมาให้เราเลือก:

เราสามารถกดปุ่ม Shift+Tab เพื่อสลับโหมดได้ตลอดเวลา โดยดูโหมดปัจจุบันได้จากแถบสถานะด้านล่าง:

• Manual (ในไฟล์ config ใช้ค่า default): Claude จะต้องถามขออนุญาตก่อนแก้ไฟล์และก่อนรันคำสั่งทุกครั้ง แถบสถานะจะแสดงข้อความ ⏸ manual mode on เหมาะสำหรับช่วงแรกที่เพิ่งเริ่มใช้งานและยังไม่คุ้นเคยกับโปรเจกต์
• Accept edits (acceptEdits): อนุญาตให้ Claude สร้างและแก้ไขไฟล์ในโฟลเดอร์โปรเจกต์ได้ทันที รวมถึงรันคำสั่งจัดการไฟล์พื้นฐานอย่าง mkdir, mv, cp ได้โดยไม่ต้องถาม เหมาะสำหรับช่วงที่เราต้องการทำงานอย่างรวดเร็ว แล้วค่อยมาตรวจโค้ดทีหลังผ่าน git diff
• Plan (plan): อนุญาตให้อ่านไฟล์และวางแผนงานเท่านั้น โดยจะไม่แตะต้องหรือแก้ไขโค้ดใดๆ แถบสถานะจะแสดงข้อความ ⏸ plan mode on เหมาะกับงานขนาดใหญ่ที่ต้องการให้วิเคราะห์และเห็นแผนงานทั้งหมดก่อนลงมือทำจริง
• Auto: ใช้โมเดล AI อีกตัวคอยตรวจสอบคำสั่งของ Claude อยู่เบื้องหลัง และจะบล็อกคำสั่งที่เสี่ยงสูงให้อัตโนมัติแทนการเด้งถามเรา เช่น curl | bash หรือคำสั่งบังคับส่งโค้ดทับอย่าง force push ใน Git หากโมเดลตัวตรวจบล็อกคำสั่งติดกัน 3 ครั้ง หรือมียอดบล็อกสะสมครบ 20 ครั้ง โหมด Auto จะหยุดพักแล้วกลับมาถามขออนุญาตเราตามปกติ

โหมด Auto จะมีให้เลือกหรือไม่ และ session ใหม่จะเริ่มต้นด้วยโหมดไหน ขึ้นอยู่กับเวอร์ชันและประเภทบัญชีที่ใช้งาน แต่เราสามารถกด Shift+Tab เพื่อสลับโหมดได้เสมอ

การเลือกโหมดขึ้นอยู่กับความต้องการ: Manual ช่วยให้เราคุมงานได้ละเอียดที่สุดแต่ต้องคอยกดอนุมัติบ่อยครั้ง, Accept edits ช่วยให้งานเดินเร็วขึ้นโดยเราต้องมาตรวจโค้ดด้วยตัวเองภายหลัง ส่วน Auto ช่วยให้เราไม่ต้องตอบคำถามบ่อย โดยมีระบบตรวจอัตโนมัติคอยคัดกรองให้

นอกจากนี้ยังมีโหมดเฉพาะทางอีก 2 โหมด: dontAsk จะปฏิเสธทุกคำสั่งที่ต้องขออนุญาตทันที ใช้สำหรับระบบอัตโนมัติที่กำหนดสิทธิ์ไว้ชัดเจนแล้ว ส่วน bypassPermissions เปิดได้ตอนเริ่มรันเท่านั้น เช่น claude --dangerously-skip-permissions ซึ่งโหมดนี้จะปิดทั้งการถามขออนุญาตและการตรวจสอบความปลอดภัยเกือบทั้งหมด

การใช้งาน Plan Mode เปิดได้ 3 ช่องทาง คือ กด Shift+Tab จนแถบสถานะขึ้นว่า ⏸ plan mode on, สั่งเปิด session ด้วยคำสั่ง claude --permission-mode plan หรือสั่งเฉพาะงานด้วยคำสั่ง /plan:

/plan fix the auth bug

เมื่อวางแผนงานเสร็จแล้ว Claude จะถามเราว่าจะไปต่ออย่างไร: สั่งให้ลงมือทำจริงทันที, ให้ลงมือทำโดยขออนุญาตทีละขั้นตอน (Yes, manually approve edits) หรือให้วางแผนเพิ่มเติมต่อไปก่อน (No, keep planning) หากต้องการแก้ไขรายละเอียดในแผนงานก่อนเริ่มทำ ให้กด Ctrl+G เพื่อเปิดแผนขึ้นมาแก้ไขใน Text Editor ได้ทันที

3. ให้ Claude จดจำบริบทโปรเจกต์ด้วย CLAUDE.md และ Settings

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

CLAUDE.md ไฟล์กติกาหลักที่ Claude อ่านทุกครั้ง

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

ตัวอย่างหน้าตาของไฟล์ CLAUDE.md:

# Code style
- Use ES modules (import/export) syntax, not CommonJS (require)
- Destructure imports when possible

# Workflow
- Be sure to typecheck when you're done making a series of code changes
- Prefer running single tests, and not the whole test suite, for performance

หลักการเขียนที่ดีคือ ทุกข้อควรเป็นสิ่งที่ตรวจสอบได้ชัดเจนว่าทำหรือไม่ทำ เช่น การเขียนว่า Use 2-space indentation จะชัดเจนกว่าคำว่า Format code properly เพราะแบบแรกวัดผลได้แน่นอน ควรใส่เฉพาะข้อมูลที่ Claude อ่านรู้เองจากโค้ดไม่ได้ เช่น คำสั่งรันเทสต์เฉพาะของทีม, สไตล์โค้ดที่แตกต่างจากมาตรฐานทั่วไป หรือข้อควรระวังพิเศษในโปรเจกต์ ส่วนอะไรที่ Claude เปิดอ่านจากโค้ดแล้วเข้าใจได้เอง ไม่จำเป็นต้องใส่

เกณฑ์ตัดสินง่ายๆ คือ "ถ้าลบบรรทัดนี้ออกไป Claude จะมีโอกาสทำพลาดไหม?" ถ้าคิดว่าไม่ ก็ลบทิ้งได้เลย ความยาวของไฟล์ไม่ควรเกิน 200 บรรทัด เพราะยิ่งไฟล์ยาวขึ้นเรื่อยๆ ก็จะยิ่งกินพื้นที่ context โดยไม่จำเป็น และอาจทำให้ Claude ละเลยข้อกำหนดบางข้อไปได้

สัญญาณที่บอกว่าถึงเวลาเพิ่มกฎข้อใหม่ลงในไฟล์ คือตอนที่ Claude เริ่มทำพลาดเรื่องเดิมเป็นครั้งที่สอง หรือตอนที่เราต้องพิมพ์เตือนเรื่องเดิมซ้ำกับที่เคยบอกไปเมื่อวาน ส่วนตัวไฟล์วางไว้ได้ 3 ตำแหน่ง:

• ./CLAUDE.md อยู่ที่ root หรือโฟลเดอร์ชั้นนอกสุดของโปรเจกต์ เพื่อ commit เข้า Git ให้ทุกคนในทีมใช้ร่วมกัน
• ~/.claude/CLAUDE.md เป็นกฎส่วนตัวของเราที่ต้องการให้มีผลกับทุกโปรเจกต์ในเครื่อง
• CLAUDE.local.md อยู่ที่ root ของโปรเจกต์ ใช้เป็นโน้ตส่วนตัวเฉพาะโปรเจกต์นี้ โดยอย่าลืมใส่ชื่อไฟล์นี้ไว้ในไฟล์ละเว้นอย่าง .gitignore เพื่อไม่ให้ติดขึ้น Git

หากต้องการตรวจดูว่าไฟล์โหลดเข้าสู่ระบบจริงหรือไม่ ให้พิมพ์ /context แล้วดูที่หัวข้อ Memory files

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

ข้อดีสำคัญคือ กฎที่เขียนไว้ใน CLAUDE.md ที่ root ของโปรเจกต์จะไม่สูญหายไปหลังรันคำสั่ง /compact เพราะ Claude Code จะเปิดอ่านไฟล์นี้ใหม่จากดิสก์

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

Auto Memory ระบบจดจำข้อมูลอัตโนมัติของ Claude

นอกจากไฟล์ที่เราเขียนขึ้นเองแล้ว Claude ยังจดจำข้อมูลการทำงาน สไตล์ที่เราชอบ และข้อผิดพลาดที่เราเคยแก้ได้เองโดยอัตโนมัติ ฟีเจอร์นี้เรียกว่า Auto Memory และเปิดใช้งานไว้ตั้งแต่แรกอยู่แล้ว เมื่อ Claude บันทึกหรือดึงความจำมาใช้งาน จะมีข้อความแจ้งเตือนขึ้น เช่น Saved 2 memories

Auto Memory กับ CLAUDE.md จัดเก็บแยกกันคนละส่วน: ถ้าเราพิมพ์สั่งในแชตว่า always use pnpm, not npm ข้อความนี้จะบันทึกลงใน Auto Memory ซึ่งจะอยู่ในเครื่องของเราคนเดียวเท่านั้น แต่ถ้าต้องการให้กฎนี้แชร์ไปให้คนอื่นในทีมเห็นด้วย ให้สั่ง Claude ว่า add this to CLAUDE.md

เราสามารถพิมพ์คำสั่ง /memory เพื่อดูรายการไฟล์ CLAUDE.md ทั้งหมด สั่งเปิด-ปิดฟังก์ชัน Auto Memory หรือเปิดโฟลเดอร์ความจำเพื่อแก้ไขเนื้อหาด้วยตัวเองได้ โดยไฟล์ที่บันทึกจะเป็นไฟล์ Markdown ทั่วไปที่แก้ไขหรือลบออกได้ตลอดเวลา

ตั้งค่าการทำงานผ่าน Settings 3 ระดับ

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

• ~/.claude/settings.json เป็นการตั้งค่าส่วนตัวของเรา มีผลกับทุกโปรเจกต์ในเครื่อง
• .claude/settings.json เป็นการตั้งค่าของโปรเจกต์ เพื่อ commit เข้า Git ให้ทุกคนในทีมใช้งานเหมือนกัน
• .claude/settings.local.json เป็นการตั้งค่าส่วนตัวของเราเฉพาะในโปรเจกต์นี้ และไม่ถูก commit ขึ้น Git

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

1. การระบุตัวเลือกคำสั่งหรือ flag --settings ตอนสั่งรันโปรแกรม
2. .claude/settings.local.json
3. .claude/settings.json
4. ~/.claude/settings.json

ตัวอย่างเช่น หากในทีมกำหนด "model": "claude-sonnet-5" ไว้ในไฟล์โปรเจกต์ แต่เราต้องการใช้โมเดลอื่น เราก็ใส่โมเดลที่ต้องการลงใน .claude/settings.local.json ของเครื่องเราได้ ซึ่งจะมีผลเฉพาะ session ของเราคนเดียว

หากไม่อยากแก้ไขไฟล์ด้วยตัวเอง สามารถพิมพ์คำสั่ง /config เพื่อเปิดเมนูตั้งค่า หรือจะสั่งเปลี่ยนค่าตรงๆ เช่น /config theme=dark ก็ได้ ส่วน /status ใช้ตรวจดูว่าตอนนี้ระบบโหลดไฟล์ตั้งค่าไหนมาใช้บ้าง ทั้งนี้ไฟล์ Settings ต้องเป็นรูปแบบ JSON ที่ถูกต้อง ห้ามมีคอมเมนต์ และห้ามใส่เครื่องหมายจุลภาคเกินที่ท้ายบรรทัด

กำหนด Permissions กฎเหล็กที่ Claude ห้ามฝ่าฝืน

Permissions คือกฎควบคุมความปลอดภัยที่ตัวระบบ Claude Code บังคับใช้เองโดยตรง ไม่ได้ปล่อยให้โมเดล AI ตัดสินใจ โดยมีรูปแบบกฎ 3 ระดับ คือ allow ที่อนุญาตให้ทำได้ทันทีโดยไม่ต้องถาม, ask ที่ต้องเด้งถามขออนุญาตทุกครั้ง และ deny ที่บล็อกทันที หากกฎขัดแย้งกัน กฎ deny จะชนะกฎ allow เสมอ

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "defaultMode": "plan",
    "allow": ["Bash(npm run test *)"],
    "deny": ["Bash(rm *)"]
  }
}

หากเราบันทึกไฟล์นี้ไว้ที่ .claude/settings.json ทุก session ในโปรเจกต์นี้จะเริ่มต้นด้วย Plan Mode ทันที, สามารถสั่งรันคำสั่ง npm run test ได้โดยไม่ต้องถาม และจะบล็อกทุกคำสั่งที่ขึ้นต้นด้วย rm โดยบรรทัด "$schema" จะช่วยให้ VS Code แสดงคำแนะนำให้อัตโนมัติขณะพิมพ์

เครื่องหมายดอกจัน * ใช้แทนข้อความอะไรก็ได้ แต่การเว้นวรรคจะมีผลกับเงื่อนไข เช่น Bash(ls *) จะตรงกับคำสั่ง ls แต่จะไม่ครอบคลุมคำสั่ง lsof อีกจุดที่พลาดง่ายคือ การใส่ "defaultMode": "auto" ลงในไฟล์ของโปรเจกต์จะไม่มีผล เพราะการตั้งค่านี้จำเป็นต้องอยู่ในไฟล์ระดับผู้ใช้ที่ ~/.claude/settings.json เท่านั้น

เราไม่จำเป็นต้องนั่งพิมพ์กฎทุกข้อเองตั้งแต่แรก เพราะเวลาที่กล่องขออนุญาตเด้งขึ้นมา หากเราเลือก "Yes, and don't ask again" ระบบจะเพิ่มกฎ allow ลงใน .claude/settings.local.json ให้โดยอัตโนมัติ ทั้งนี้กฎ allow จากไฟล์ระดับต่างๆ จะรวมเข้าด้วยกันโดยไม่หักล้างกัน

• คำสั่ง /permissions ใช้ตรวจสอบรายการกฎความปลอดภัยทั้งหมด พร้อมบอกว่ากฎแต่ละข้อมาจากไฟล์ไหน
• คำสั่ง /fewer-permission-prompts จะสแกนประวัติการใช้งาน เพื่อค้นหาคำสั่งสำหรับอ่านไฟล์อย่างเดียวที่เราเรียกใช้บ่อย แล้วนำมาเพิ่มลงในรายการที่อนุญาตให้อัตโนมัติ
• คำสั่งอ่านข้อมูลทั่วไปอย่าง ls, cat, grep, find จะรันได้ในทุกโหมดโดยไม่เด้งถามอยู่แล้ว

4. ยกระดับการทำงานด้วย Skills, Subagents, Hooks, MCP และ Plugins

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

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

Skills คู่มือเฉพาะทางที่ Claude หยิบมาใช้เมื่อถึงเวลา

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

ตัวอย่างการสร้าง Skill แรกสำหรับสรุปการแก้ไขโค้ดและตรวจจับจุดเสี่ยง เริ่มจากการสร้างโฟลเดอร์:

mkdir -p ~/.claude/skills/summarize-changes

จากนั้นสร้างไฟล์ ~/.claude/skills/summarize-changes/SKILL.md พร้อมใส่เนื้อหาดังนี้:

---
description: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed, wants a commit message, or asks to review their diff.
---

## Current changes

!`git diff HEAD`

## Instructions

Summarize the changes above in two or three bullet points, then list any risks you notice such as missing error handling, hardcoded values, or tests that need updating. If the diff is empty, say there are no uncommitted changes.

คำอธิบายในส่วน description คือสิ่งที่ Claude ใช้วิเคราะห์ว่าจะหยิบ Skill นี้มาใช้ในสถานการณ์ไหน ส่วนบรรทัด !`git diff HEAD` เป็นการสั่งให้ Claude Code รันคำสั่ง Git นี้ก่อน แล้วนำผลลัพธ์ที่ได้มาแทนที่บรรทัดดังกล่าว ทำให้ Claude ได้ทั้งคำสั่งและข้อมูล diff ล่าสุดไปประมวลผลพร้อมกันในคราวเดียว

เราทดสอบได้ 2 วิธี: ถามเป็นภาษาธรรมชาติ เช่น What did I change? เพื่อให้ Claude เลือกหยิบ Skill มาใช้เอง หรือจะพิมพ์ /summarize-changes เพื่อเรียกใช้ตรงๆ ก็ได้ Skill ที่เก็บไว้ใน ~/.claude/skills/ จะเรียกใช้ได้กับทุกโปรเจกต์ในเครื่อง ส่วน Skill ที่เก็บไว้ใน .claude/skills/ ของโฟลเดอร์โปรเจกต์ สามารถ commit ขึ้น Git เพื่อแชร์ให้คนในทีมใช้ร่วมกันได้

หากเป็น Skill ที่มีผลกระทบต่อระบบ เช่น การสั่ง deploy หรือการ commit โค้ด แนะนำให้ใส่ disable-model-invocation: true ไว้ที่ส่วนหัวของไฟล์หรือ frontmatter ระหว่างเส้น --- เพื่อป้องกันไม่ให้ Claude หยิบไปรันเองโดยที่เราไม่ได้สั่ง และมีเพียงเราเท่านั้นที่พิมพ์เรียกใช้ได้ นอกจากนี้ Skill ยังรองรับการรับค่าตัวแปรเพิ่มเติมผ่าน $ARGUMENTS ได้อีกด้วย เช่น การสร้าง Skill fix-issue ที่สั่งงานด้วย /fix-issue 1234 เพื่อให้ระบบไปดึง issue หมายเลข 1234 มาแก้ไข

ในตัว Claude Code มี Skill สำเร็จรูปติดตั้งมาให้แล้วหลายตัว เช่น /code-review สำหรับช่วยหาบั๊กในโค้ดที่เพิ่งแก้, /simplify ที่เรียกใช้ agent 4 ตัวเข้ามาช่วยจัดระเบียบและปรับปรุงโค้ดพร้อมกัน และ /verify สำหรับเปิดทดสอบแอปพลิเคชันจริงเพื่อดูว่าโค้ดทำงานได้จริง ไม่ใช่แค่รันเทสต์ผ่าน หากเราแก้ไขเนื้อหาไฟล์ Skill จะมีผลใน session ทันที แต่ถ้าเป็นการสร้างโฟลเดอร์ Skill ขึ้นมาใหม่ระหว่างที่เปิดโปรแกรมอยู่ ให้พิมพ์ /reload-skills เพื่อโหลดข้อมูลใหม่

Subagents แยกงานค้นคว้าที่ใช้พื้นที่เยอะออกจากแชตหลัก

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

เราสามารถสั่งให้ Claude เรียกใช้ Subagent ได้โดยตรง:

use a subagent to investigate how our auth system handles token refresh

หรือจะพิมพ์สัญลักษณ์ @ แล้วเลือกชื่อ Subagent จากเมนูก็ได้ วิธีนี้การันตีได้แน่นอนว่าระบบจะส่งงานไปให้ Subagent ตัวนั้นทำ

หากต้องการสร้าง Subagent ขึ้นมาใช้งานเอง ให้สร้างไฟล์ Markdown ไว้ในโฟลเดอร์ .claude/agents/ เช่น .claude/agents/security-reviewer.md:

---
name: security-reviewer
description: Reviews code for security vulnerabilities
tools: Read, Grep, Glob, Bash
model: opus
---
You are a senior security engineer. Review code for:
- Injection vulnerabilities (SQL, XSS, command injection)
- Authentication and authorization flaws
- Secrets or credentials in code
- Insecure data handling

Provide specific line references and suggested fixes.

บรรทัด tools ใช้จำกัดว่า Subagent ตัวนี้สามารถเรียกใช้เครื่องมือใดได้บ้าง ส่วนบรรทัด model ใช้เลือกโมเดล AI แยกต่างหากจากแชตหลัก หากเป็นงานง่ายๆ ทั่วไป สามารถเลือกใช้ haiku โมเดลรุ่นประหยัดเพื่อช่วยลดค่าใช้จ่ายได้ หากไม่อยากเขียนไฟล์เอง เราแค่บอก Claude ได้เลยว่าอยากได้ Subagent แบบไหนและให้บันทึกไว้ที่ใด ระบบจะเขียนให้เสร็จสรรพ (หากเพิ่งสร้างโฟลเดอร์ agents ขึ้นมาใหม่แล้ว Claude ยังมองไม่เห็น ให้ปิดแล้วเปิด Claude Code ใหม่)

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

Hooks สั่งรันคำสั่งอัตโนมัติในจังหวะที่กำหนด

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

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

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [{ "type": "command", "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write" }]
      }
    ]
  }
}

ในโค้ดข้างต้น PostToolUse หมายถึงจังหวะหลังเครื่องมือทำงานเสร็จสิ้น, matcher ใช้กรองให้ทำงานเฉพาะเมื่อมีการใช้เครื่องมือ Edit หรือ Write ส่วนคำสั่ง command จะใช้ jq ดึงชื่อไฟล์ที่เพิ่งแก้ไขส่งต่อไปให้ Prettier จัดรูปแบบไฟล์ทันที (เครื่องต้องลง jq ไว้ก่อน) เมื่อตั้งค่าเสร็จ ให้พิมพ์คำสั่ง /hooks เพื่อตรวจดูว่า Hook เข้าสู่ระบบแล้ว หรือจะสั่งให้ Claude ช่วยเขียนโค้ด Hook ให้ก็ได้เช่นกัน

นอกจากนี้ยังมีจังหวะ PreToolUse ซึ่งทำงานก่อนที่เครื่องมือจะเริ่มทำงาน โดยจังหวะนี้สามารถสั่งบล็อกการทำงานได้ หากสคริปต์ของ Hook ส่งค่าสถานะจบเป็น exit 2 Claude Code จะหยุดคำสั่งนั้นทันที พร้อมส่งข้อความ error ของสคริปต์กลับไปบอก Claude เพื่ออธิบายเหตุผล ใช้ป้องกันไม่ให้ Claude แก้ไขไฟล์สำคัญ เช่น ไฟล์ .env ส่วนจังหวะ Notification ใช้ส่งข้อความแจ้งเตือนขึ้นหน้าจอเวลาที่ Claude ต้องการให้เราตอบ

MCP เชื่อมต่อ Claude เข้ากับเครื่องมือและบริการภายนอก

MCP หรือ Model Context Protocol คือมาตรฐานเปิดที่ช่วยเชื่อมต่อ Claude Code เข้ากับแหล่งข้อมูลและบริการภายนอก เช่น Google Drive, Jira, Slack, Notion หรือ Figma โดยตัวเชื่อมต่อแต่ละตัวจะเรียกว่า MCP Server ซึ่งสามารถรันอยู่บนเครื่องเราเองหรือเชื่อมต่อไปยังคลาวด์เซอร์วิสก็ได้

ลองเริ่มจากติดตั้ง MCP Server ของเอกสาร Claude Code เป็นตัวแรก ตัวนี้ไม่ต้องล็อกอิน ให้เปิดหน้าต่าง terminal ทั่วไป (ไม่ใช่หน้าต่างที่คุยกับ Claude) แล้วรันคำสั่ง:

claude mcp add --transport http claude-code-docs https://code.claude.com/docs/mcp
claude mcp list

คำสั่งบรรทัดแรกเป็นการลงทะเบียน Server โดยแต่ละส่วนมีความหมายดังนี้:

• claude mcp add คือคำสั่งเพิ่ม MCP Server
• --transport http ระบุว่าเป็น Server แบบออนไลน์ผ่าน URL
• claude-code-docs คือชื่อ Server ที่เราตั้งขึ้นมาเอง
• ส่วนท้ายสุดคือ URL ปลายทางของ Server

หากติดตั้งสำเร็จ หน้าจอจะแสดงข้อความ Added HTTP MCP server claude-code-docs with URL: https://code.claude.com/docs/mcp to local config และเมื่อรันคำสั่งบรรทัดที่สองเพื่อตรวจสอบสถานะ จะต้องเห็นสัญลักษณ์ ✔ Connected ปรากฏขึ้น

เมื่อเข้าสู่ Claude Code เราสามารถเอ่ยชื่อ Server ในคำสั่งได้ทันที เช่น use claude-code-docs to explain how hooks work โดยในผลลัพธ์การทำงาน Claude จะแสดงชื่อ Server กำกับไว้ด้วย เพื่อให้รู้ว่าดึงข้อมูลมาจากแหล่งไหน

สำหรับ Server ที่ต้องยืนยันตัวตน เช่น Notion ให้เพิ่มด้วยคำสั่งลักษณะเดียวกัน:

claude mcp add --transport http notion https://mcp.notion.com/mcp

เมื่อเพิ่มแล้ว คำสั่ง claude mcp list จะขึ้นสถานะเตือนว่า ! Needs authentication ให้เปิดเข้าไปในหน้าต่าง Claude Code แล้วพิมพ์ /mcp เลือก Server ดังกล่าว แล้วกด Authenticate ระบบจะเปิดเบราว์เซอร์ขึ้นมาให้ล็อกอินยืนยันตัวตน

เวลาเพิ่ม MCP Server เราสามารถกำหนดขอบเขตการทำงานได้ตามต้องการ: ค่าเริ่มต้นคือ local ใช้งานได้เฉพาะเราในโปรเจกต์นี้, --scope user ใช้งานได้กับทุกโปรเจกต์ในเครื่องเรา ส่วน --scope project จะบันทึกการตั้งค่าลงในไฟล์ .mcp.json เพื่อแชร์ให้ทุกคนในทีมใช้งานร่วมกัน หากภายหลังต้องการเปลี่ยนขอบเขต ให้ลบออกด้วยคำสั่ง claude mcp remove claude-code-docs แล้วค่อยเพิ่มเข้าไปใหม่

ข้อควรจำคือ MCP Server ที่เชื่อมต่อไว้จะกินพื้นที่ Context อยู่บ้าง หากตัวไหนเลิกใช้งานแล้วควรสั่งลบหรือปิดไว้ผ่านคำสั่ง /mcp และหากงานไหนมีเครื่องมือ Command Line ให้ใช้อยู่แล้ว เช่น gh ของ GitHub การบอกให้ Claude ใช้คำสั่งผ่าน Command Line โดยตรง จะประหยัดพื้นที่ Context ได้มากกว่าการต่อ MCP

Plugins แพ็กเกจรวมเครื่องมือสำเร็จรูปพร้อมใช้

Plugin คือแพ็กเกจที่มัดรวมทั้ง Skill, Hook, Subagent และ MCP Server เข้าไว้ด้วยกัน ทำให้ติดตั้งเพียงครั้งเดียวก็ได้เครื่องมือครบชุด เหมาะสำหรับการแชร์ชุดตั้งค่าที่สมบูรณ์ไปใช้งานกับหลายๆ โปรเจกต์ Claude Code จะเพิ่ม Marketplace ทางการของ Anthropic ไว้ให้อัตโนมัติตั้งแต่เปิดใช้งานครั้งแรก

/plugin install commit-commands@claude-plugins-official

เมื่อรันคำสั่งนี้ ระบบจะเปิดหน้ารายละเอียดของ Plugin commit-commands ให้ตรวจดูก่อนว่าจะติดตั้งอะไรลงมาบ้าง และกินพื้นที่ Context เท่าไหร่ จากนั้นจะให้เราเลือกระดับการติดตั้ง:

• user: ติดตั้งให้ทุกโปรเจกต์ในเครื่องนี้ใช้งานได้
• project: ติดตั้งให้ทุกคนใน Git repository ใช้งานร่วมกัน โดยบันทึกลงใน .claude/settings.json
• local: ติดตั้งให้เฉพาะเราคนเดียวในโปรเจกต์นี้ โดยบันทึกลงใน .claude/settings.local.json

เมื่อติดตั้งเสร็จแล้ว หากเราพิมพ์ / เพื่อค้นหา จะเจอคำสั่งอย่าง /commit-commands:commit ซึ่ง Skill ที่มาจาก Plugin จะมีชื่อ Plugin นำหน้าเสมอ เราสามารถพิมพ์ /plugin เพื่อเข้าไปสำรวจเครื่องมือใหม่ๆ ในแท็บ Discover หรือเข้าไปจัดการเปิด-ปิด อัปเดต และถอนการติดตั้งได้ในแท็บ Installed

ข้อแนะนำคือ ควรอ่านรายละเอียดของแต่ละ Plugin ให้ถี่ถ้วนก่อนกดติดตั้งเสมอ เพราะ Plugin มีสิทธิ์สั่งรัน Hook และ MCP Server ในเครื่องของเราได้ และหากคุณเขียนภาษาโปรแกรมที่มีระบบ type แนะนำให้ลองติดตั้ง Code Intelligence Plugin ของภาษานั้นๆ เพิ่มเติม เพราะจะช่วยให้ Claude กระโดดไปหาจุดประกาศฟังก์ชันและจุดเรียกใช้ได้อย่างแม่นยำขึ้น พร้อมทั้งมองเห็นข้อผิดพลาดเรื่องชนิดข้อมูลได้ทันทีหลังแก้โค้ด

5. ใช้งาน Claude Code ได้ทุกที่ ตั้งแต่ Terminal ไปจนถึงมือถือ

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

ฝั่ง VS Code ให้เข้าไปติดตั้งส่วนขยาย Claude Code ตามขั้นตอนในเอกสาร ส่วนฝั่ง JetBrains ให้ติดตั้ง Plugin ที่ชื่อ Claude Code จาก JetBrains Marketplace ซึ่งจะรัน Claude Code ขึ้นมาใน terminal ของ IDE โดยตรง โดยเราสามารถจัดการการเชื่อมต่อ IDE ทั้งหมดได้ผ่านคำสั่ง /ide

ในหน้าต่าง terminal เราสามารถพิมพ์ /desktop เพื่อย้าย session ที่กำลังทำอยู่ไปทำงานต่อบนแอป Desktop (รองรับบน macOS และ Windows x64) ส่วนบนเว็บเข้าใช้ได้ที่ claude.ai/code และหากพิมพ์คำสั่ง /mobile ระบบจะสร้าง QR code ขึ้นมาให้สแกนเพื่อดาวน์โหลดแอป Claude บนมือถือ ซึ่งรองรับทั้ง iOS และ Android

งานที่เราสั่งค้างไว้สามารถโยกย้ายข้ามอุปกรณ์ได้อย่างสะดวก:

• สั่งรัน claude remote-control (หรือพิมพ์ /remote-control ในแชต) เพื่อเปิดฟังก์ชัน Remote Control สำหรับควบคุม session ที่กำลังทำงานอยู่ในคอมพิวเตอร์ของเราผ่านสมาร์ตโฟนหรือเว็บเบราว์เซอร์จากที่ไหนก็ได้
• สั่งรัน claude --teleport เพื่อดึง session ที่เคยคุยค้างไว้บนเว็บหรือมือถือ กลับมาทำงานต่อในหน้าต่าง terminal ของเครื่องเรา
• พิมพ์ /chrome เพื่อเปิดฟังก์ชัน Claude in Chrome ให้ Claude เข้าไปควบคุมเว็บเบราว์เซอร์โดยใช้สิทธิ์ของบัญชีที่เราล็อกอินค้างไว้ได้ทันที

ทั้งนี้ การใช้แอป Desktop, คำสั่ง /desktop, Remote Control และคำสั่ง --teleport จำเป็นต้องใช้บัญชีสมาชิกระดับเสียค่าบริการของ claude.ai

6. เทคนิคขั้นสูง: รันงานแบบขนานและตั้งเวลาทำงานอัตโนมัติ

รันงานแบบขนานด้วย Git Worktree และ Background Sessions

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

claude --worktree feature-auth

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

หากไม่อยากเปิดหลายหน้าต่าง terminal ให้พิมพ์คำสั่ง /background (หรือ /bg) เพื่อสั่งให้ session ปัจจุบันไปทำงานต่อในเบื้องหลัง แล้วเราสามารถตามดูสถานะของทุก session ได้จากหน้าต่างเดียวด้วยคำสั่ง claude agents อีกทางคือใช้คำสั่ง /subtask ตามด้วยรายละเอียดงาน เพื่อส่งงานย่อยให้ Subagent แยกไปทำแล้วกลับมารายงานผลในแชตนี้ ส่วน /tasks ใช้ดูรายการงานทั้งหมดที่กำลังรันอยู่ในเบื้องหลัง

ชื่อคำสั่งเหล่านี้อาจทำให้สับสนได้ง่าย: จำไว้ว่า claude agents ใช้สำหรับดู session ที่รันอยู่เบื้องหลัง ซึ่งเป็นคนละตัวกับคำสั่ง /agents ที่ใช้จัดการไฟล์ Subagent

หากมีงานปรับปรุงโค้ดขนาดใหญ่ที่แบ่งเป็นชิ้นซึ่งทำแยกกันได้ ให้ใช้คำสั่ง /batch ตามด้วยคำสั่งงาน Claude จะช่วยซอยงานออกเป็น 5 ถึง 30 ชิ้นย่อย แล้วกระจายให้ Subagent ตัวละชิ้นแยกกันไปทำบน Git Worktree ของตัวเอง อีกเทคนิคหนึ่งคือการแบ่งบทบาทคนเขียนกับคนตรวจ โดยให้ session แรกทำหน้าที่เขียนโค้ด แล้วเปิด session ใหม่ขึ้นมาตรวจทาน เพราะ session ใหม่ที่ไม่มีประวัติการคุยเดิมจะวิเคราะห์โค้ดได้อย่างเป็นกลางโดยไม่อคติเข้าข้างโค้ดที่เพิ่งเขียนเสร็จ

สิ่งที่ต้องคำนึงถึงคือ ทุก session และทุก Subagent ที่เปิดทำงานคู่ขนานกันจะใช้ Token เพิ่มขึ้นตามสัดส่วน

ฟีเจอร์ Agent Teams เป็นการจำลองทีมงาน AI ที่มีทั้งหัวหน้าและลูกทีมคอยประสานงานกัน ตอนนี้ยังเป็นฟีเจอร์ทดลองที่ปิดการทำงานไว้เป็นค่าเริ่มต้น หากต้องการทดลองใช้สามารถเปิดด้วยตัวแปร environment CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 แต่ต้องระวังว่าเมื่อลูกทีมทำงานใน Plan Mode ระบบจะใช้ปริมาณ Token สูงกว่า session ปกติถึงประมาณ 7 เท่า

โหมด Headless: สั่งรัน Claude จาก Script ด้วยคำสั่ง claude -p

Headless คือการสั่งรัน Claude Code ผ่าน Command Line โดยไม่ต้องเปิดหน้าต่างแชต เพียงใส่ flag -p โปรแกรมจะประมวลผลคำสั่งจนเสร็จ แสดงผลลัพธ์ออกมาทางหน้าจอ แล้วปิดตัวเองลงทันที จึงเหมาะอย่างยิ่งสำหรับการนำไปเขียนเป็นสคริปต์อัตโนมัติ:

claude -p "Explain what this project does"
cat error.log | claude -p "explain this error"
claude -p "List all API endpoints" --output-format json

คำสั่งบรรทัดที่สองเป็นการส่งเนื้อหาในไฟล์ error.log ผ่าน Pipe (|) เข้าไปให้ Claude วิเคราะห์ ส่วนบรรทัดที่สามเป็นการขอผลลัพธ์ในรูปแบบ JSON ซึ่งจะมีข้อมูลค่าใช้จ่ายโดยประมาณในตัวแปร total_cost_usd แนบมาให้ด้วย

เนื่องจากโหมดนี้ไม่มีผู้ใช้คอยกดยืนยันหน้าจอ Claude Code จะปฏิเสธทุกคำสั่งที่ต้องขออนุญาต ยกเว้นคำสั่งที่ระบุกฎ allow ไว้ล่วงหน้า หรือคำสั่งที่กำหนดไว้ผ่าน flag --allowedTools ตัวอย่างลูปด้านล่างแสดงการสั่งประมวลผลโค้ดทีละไฟล์แบบอัตโนมัติ:

for file in $(cat files.txt); do claude -p "Migrate $file from Python 2 to Python 3. Return OK or FAIL." --allowedTools "Edit,Bash(git commit *)" --permission-mode dontAsk; done

สคริปต์นี้จะอ่านรายชื่อไฟล์จาก files.txt ทีละบรรทัด แล้วสั่งให้ Claude แปลงโค้ดจาก Python 2 เป็น Python 3 โดยอนุญาตให้แก้ไขไฟล์และสั่ง commit ได้ ส่วนการกระทำอื่นที่ต้องขออนุญาตจะโดนปฏิเสธเพราะใช้โหมด dontAsk (คำสั่งอ่านอย่างเดียวยังรันได้ตามปกติ) คำแนะนำคือ ให้สั่ง Claude ร่างรายชื่อไฟล์ลงใน files.txt ก่อน แล้วทดสอบรันดูสัก 2-3 ไฟล์ให้มั่นใจว่าทำงานได้ถูกต้อง ก่อนที่จะสั่งรันทั้งหมด

ทำงานอัตโนมัติบน GitHub Actions ด้วยการพิมพ์ @claude

เราสามารถนำ Claude Code ไปผูกกับ GitHub Actions เพื่อให้ทำงานบน GitHub repository ได้ เมื่อตั้งค่าเสร็จสิ้น เราจะพิมพ์ @claude ลงในคอมเมนต์ของ Pull Request หรือ Issue เพื่อให้ Claude เข้าไปอ่านโค้ด ลงมือแก้ไข และส่ง commit ใหม่กลับเข้ามาได้ทันที

วิธีตั้งค่าแบบเร็วคือ เปิด claude ในโฟลเดอร์โปรเจกต์แล้วพิมพ์:

/install-github-app

(ต้องล็อกอิน GitHub CLI ด้วยคำสั่ง gh auth login ไว้ก่อน และรองรับเฉพาะ repository บน github.com เท่านั้น) คำสั่งนี้จะช่วยติดตั้ง Claude GitHub App พร้อมตั้งค่า Secret สำหรับยืนยันตัวตนให้อัตโนมัติ และเปิด Pull Request ที่มีไฟล์ Workflow มาให้เรากด merge ได้ทันที

หากเราไม่ได้ระบุข้อความ prompt ไว้ในไฟล์ Workflow ตัว Claude จะทำงานเฉพาะเมื่อมีคนพิมพ์เรียก @claude เท่านั้น แต่หากเราระบุ prompt เอาไว้ มันจะรันงานให้อัตโนมัติทุกครั้งที่มี Event เกิดขึ้นใน GitHub หรือรันตามตารางเวลาที่กำหนด ศึกษารายละเอียดเพิ่มเติมได้ที่ claude-code-action ทริกสำคัญคือ การรันบน GitHub Actions แต่ละครั้งจะกินทั้งโควตานาทีของ GitHub และปริมาณ Token จึงควรเขียนคำสั่งให้เจาะจง, กระชับเนื้อหาใน CLAUDE.md ให้สั้น และจำกัดจำนวนรอบการตอบโต้ด้วย --max-turns ผ่านตัวแปร claude_args

คำสั่ง /loop และ Scheduled Tasks ตั้งเวลาทำงานอัตโนมัติ

สำหรับงานที่ต้องคอยตรวจสอบซ้ำเป็นระยะๆ เราสามารถสั่งงานด้วยคำสั่ง /loop:

/loop 5m check if the deployment finished and tell me what happened

คำสั่งนี้จะตรวจเช็กสถานะทุกๆ 5 นาที (หน่วยเวลาที่รองรับคือ s, m, h, d) หากเราไม่ได้ระบุเวลา เช่น /loop check whether CI passed and address any review comments Claude จะประเมินระยะเวลาที่เหมาะสมสำหรับรอบถัดไปให้เอง โดยอยู่ระหว่าง 1 นาที ถึง 1 ชั่วโมง ลูปแบบที่ Claude เลือกเวลาเองนี้ หยุดได้ด้วยการกด Esc ระหว่างที่มันรอรอบถัดไป

สำหรับการตั้งเตือนแบบครั้งเดียว ก็สั่งเป็นประโยคธรรมดาได้เช่นกัน เช่น remind me at 3pm to push the release branch และพิมพ์ถาม what scheduled tasks do I have? เพื่อดูรายการงานที่ตั้งเวลาไว้ทั้งหมด

ข้อจำกัดสำคัญคือ งานเหล่านี้จะผูกอยู่กับ session ปัจจุบัน หมายความว่าจะทำงานเฉพาะตอนที่ Claude Code เปิดอยู่และไม่ได้กำลังทำงานอื่นอยู่เท่านั้น หากเราปิด terminal งานก็จะหยุดลงทันที และงานที่ตั้งให้วนซ้ำจะมีอายุสูงสุด 7 วัน หากต้องการให้งานรันต่อเนื่องในระยะยาว มีทางเลือกดังนี้:

เนื่องจากงานที่ตั้งเวลาไว้จะหันกลับมาถามเราไม่ได้ คำสั่งที่เราเขียนจึงต้องระบุรายละเอียดให้ครบถ้วนว่าผลลัพธ์แบบไหนถือว่าสำเร็จ และเมื่อได้ผลลัพธ์แล้วต้องทำขั้นตอนใดต่อ อีกคำสั่งหนึ่งที่ใกล้เคียงกันคือ /goal ตามด้วยเงื่อนไขเป้าหมาย โดย Claude จะลงมือทำงานต่อเนื่องไปเรื่อยๆ จนกว่าเงื่อนไขนั้นจะเป็นจริง ศึกษาขั้นตอนการใช้งานอย่างละเอียดได้ที่ คู่มือ /goal ของ Claude Code

ควบคุมค่าใช้จ่ายด้วย /usage และ /clear

พิมพ์คำสั่ง /usage (หรือ /cost) เพื่อตรวจดูปริมาณ Token ที่ใช้ไปใน session ปัจจุบันพร้อมค่าใช้จ่ายโดยประมาณ หากใช้งานด้วยบัญชีสมาชิก ระบบจะแสดงแถบโควตาคงเหลือของแพ็กเกจให้เห็นด้วย ตัวเลขนี้คำนวณเบื้องต้นในเครื่อง หากต้องการดูยอดใช้งานจริงที่แม่นยำให้ดูที่หน้า Usage ใน Claude Console

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

• ใช้คำสั่ง /clear เคลียร์ความจำเมื่อจะเปลี่ยนไปทำงานหัวข้อใหม่ (แนะนำให้พิมพ์ /rename ตั้งชื่อไว้ก่อน เพื่อให้สามารถ /resume กลับมาดูได้ภายหลัง)
• ใช้คำสั่ง /model เพื่อสลับไปใช้รุ่น Sonnet สำหรับงานเขียนโค้ดส่วนใหญ่ และเก็บรุ่น Opus ไว้ใช้เฉพาะงานออกแบบโครงสร้างระบบที่ยากจริงๆ
• ใช้คำสั่ง /effort เพื่อปรับลดระดับการคิดวิเคราะห์ลงสำหรับงานง่ายๆ
• ใช้คำสั่ง /mcp เพื่อปิด Server ที่ไม่ได้ใช้งาน
• คุมขนาดไฟล์ CLAUDE.md ไม่ให้เกิน 200 บรรทัด แล้วย้ายคำแนะนำเฉพาะเรื่องไปสร้างเป็น Skill แทน
• ส่งงานที่ต้องอ่านไฟล์จำนวนมากหรือให้ผลลัพธ์ยาวเหยียดไปให้ Subagent จัดการ
• กดปุ่ม Esc หรือใช้คำสั่ง /rewind ทันทีเมื่อเห็นว่า Claude เริ่มแก้โค้ดผิดทิศทาง

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

Best Practices เพื่อให้ได้ผลลัพธ์ที่ดีตั้งแต่รอบแรก

ควรกำหนดแนวทางให้ Claude ตรวจสอบผลงานตัวเองได้เสมอ เช่น เตรียมชุดทดสอบ, คำสั่ง build หรือ linter การใส่เกณฑ์วัดผลไว้ในคำสั่งตั้งแต่ต้นจะช่วยให้ Claude ตรวจเช็กได้ด้วยตัวเองว่างานเสร็จสมบูรณ์จริงหรือไม่:

write a validateEmail function. example test cases: [email protected] is true, invalid is false, [email protected] is false. run the tests after implementing

สำหรับงานขนาดใหญ่ แนะนำให้แบ่งการทำงานเป็น 4 ขั้นตอน: สำรวจ -> วางแผน -> เขียนโค้ด -> commit โดยให้ทำ 2 ขั้นตอนแรกใน Plan Mode ก่อนเสมอ แต่หากเป็นงานเล็กๆ ที่อธิบายสิ่งที่ต้องการแก้จบได้ในประโยคเดียว ก็สามารถข้ามขั้นตอนการวางแผนไปได้เลย

หากเป็นโปรเจกต์ใหม่ที่โจทย์ยังไม่ชัดเจน ให้ Claude สัมภาษณ์เราก่อน:

I want to build [brief description]. Interview me in detail using the AskUserQuestion tool.

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

หากสั่งแก้ปัญหาเดิมไปแล้ว 2 รอบแต่ยังไม่ได้ผล ไม่ควรดันทุรังแก้เป็นรอบที่ 3 ให้ใช้คำสั่ง /clear เพื่อล้าง context แล้วเริ่มพิมพ์คำสั่งใหม่ที่ระบุเงื่อนไขให้ชัดเจนกว่าเดิม ส่วนก่อนส่งมอบงานทุกครั้ง ให้เรียกใช้ Subagent ตัวใหม่หรือสั่ง /code-review เพื่อช่วยตรวจทานความถูกต้องอีกรอบเสมอ

ทุกฟีเจอร์จัดการพื้นที่ก้อนเดียวกัน

หากเรามองย้อนกลับไปดูทั้ง 6 ส่วน จะเห็นว่าฟีเจอร์เกือบทุกตัวกำลังจัดการพื้นที่ Context Window ก้อนเดียวกัน: ไฟล์ CLAUDE.md ใช้ใส่กติกาสำคัญที่ต้องมีในทุกบทสนทนา, Skill จะดึงเข้ามาเฉพาะเมื่อต้องใช้งาน, Subagent ช่วยแยกงานอ่านไฟล์ขนาดใหญ่ไปทำในพื้นที่ของตัวเอง, Hook ทำงานอัตโนมัติได้โดยไม่เปลืองพื้นที่ความจำ ส่วนคำสั่ง /clear และ /compact ก็มีไว้เพื่อคืนพื้นที่ว่างให้เราทำงานต่อได้อย่างมีประสิทธิภาพ

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

ที่มา: เอกสารทางการของ Claude Code