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

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

คำสั่งที่ไม่ต้องเสียเวลาเรียนรู้เอง

ก่อนอื่นขอคลายความกังวลไปก่อน หลายคนไม่กล้าเปิด Terminal เพราะคิดว่าต้องมานั่งท่องจำคำสั่งเป็นร้อย ๆ คำสั่ง ทั้งที่จริงแล้วปล่อยให้ Agent จัดการแทนได้ตั้งแต่วันแรก:

• grep ค้นหาข้อความหรือโค้ดในกองไฟล์จำนวนมาก → ให้ Claude ทำ
• sed และ awk แก้ไขหรือแทนที่ข้อความทีละหลายสิบไฟล์ → ให้ Claude ทำ
• find ค้นหาไฟล์ทั่วทั้งเครื่อง → ให้ Claude ทำ
• chmod จัดการสิทธิ์การเข้าถึงไฟล์ → ให้ Claude ทำ
• regex และการเขียน bash script ซับซ้อน → ให้ Claude ทำ

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

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

1. Claude Code มองเห็นเฉพาะโฟลเดอร์ที่เราเปิดใช้งาน

เรื่องที่พลาดกันบ่อยที่สุดคือ cwd หรือโฟลเดอร์ที่กำลังใช้งานอยู่

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

3 คำสั่งพื้นฐานที่ต้องรู้จักมีแค่นี้:

pwd              # เช็กว่าตอนนี้เราอยู่โฟลเดอร์ไหน
ls               # ดูว่าในโฟลเดอร์นี้มีไฟล์อะไรบ้าง
cd ชื่อโฟลเดอร์    # ย้ายเข้าไปยังโฟลเดอร์ที่ต้องการ

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

ทริกที่เร็วที่สุดสำหรับมือใหม่คือ พิมพ์ cd แล้วเคาะเว้นวรรคหนึ่งครั้ง จากนั้นลากโฟลเดอร์จากหน้าต่างจัดการไฟล์อย่าง Finder บน Mac หรือ File Explorer บน Windows มาวางในหน้าต่าง Terminal ระบบจะใส่ Path ของโฟลเดอร์นั้นให้อัตโนมัติ แล้วกด Enter ได้ทันที ไม่ต้องเสียเวลาพิมพ์เองเลย

2. Path กับปุ่ม Tab ช่วยป้องกันการพิมพ์ผิด

Path คือที่อยู่ของไฟล์และโฟลเดอร์ในเครื่อง ซึ่งมีสัญลักษณ์สำคัญ 4 ตัวที่พบบ่อยและควรจำให้ได้:

• ~ คือ Home Directory หรือโฟลเดอร์หลักของผู้ใช้
• . คือโฟลเดอร์ที่กำลังใช้งานอยู่
• .. คือโฟลเดอร์ชั้นนอกหรือการถอยขึ้นไป 1 ระดับ
• / คือตัวคั่นระหว่างชั้นโฟลเดอร์

การระบุ Path แบ่งออกเป็น 2 แบบหลัก ๆ:

1. Path แบบเต็ม หรือ Absolute Path: เริ่มต้นด้วย ~ หรือ / หรือ C:\ บน Windows จะชี้ไปยังตำแหน่งเดิมเสมอไม่ว่าเราจะอยู่ในโฟลเดอร์ไหน
2. Path แบบสั้น หรือ Relative Path: เช่น images/logo.png จะระบุตำแหน่งโดยเริ่มจากโฟลเดอร์ที่กำลังใช้งานอยู่ ถ้าเราเปลี่ยนโฟลเดอร์ ตำแหน่งปลายทางก็จะเปลี่ยนตามทันที จุดนี้พลาดง่ายมากเพราะต่างกันเพียงเครื่องหมายข้างหน้าตัวเดียว

ปุ่มที่คุ้มค่าที่สุดบนคีย์บอร์ดคือ Tab เพียงพิมพ์ตัวอักษรนำหน้า 2-3 ตัวแล้วกด Tab ระบบจะช่วยเติมชื่อไฟล์หรือโฟลเดอร์ที่เหลือให้เอง ถ้ากดแล้วระบบไม่เติมให้ แปลว่าไม่มีชื่อนั้นอยู่ในตำแหน่งปัจจุบัน Tab จึงทำหน้าที่สองอย่างพร้อมกัน ทั้งพิมพ์แทนเรา และเตือนทันทีถ้ากำลังพิมพ์ชื่อไฟล์ผิด ซึ่งใน Claude Code เอง ปุ่ม Tab ก็ช่วยเติมคำสั่งได้เช่นกัน

ถ้าชื่อไฟล์หรือโฟลเดอร์มีช่องว่างหรือเป็นภาษาไทย ต้องใส่เครื่องหมายคำพูดครอบไว้เสมอ เช่น:

cd "งานลูกค้า 2026"

ไม่อย่างนั้น Terminal จะมองว่าช่องว่างคือการแบ่งคำสั่งออกเป็นคนละตัว

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

3. ปุ่มหยุดและปุ่มออก เข้า Terminal แล้วออกได้เสมอ

ถ้าสิ่งที่กังวลคือเข้าไปแล้วออกจากโปรแกรมไม่เป็น ทางออกมีอยู่แค่ไม่กี่ปุ่มเท่านั้น:

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

Ctrl+D หรือพิมพ์ /exit คือคำสั่งออกจาก Claude Code โดยตรง โดยปุ่ม Ctrl+D ต้องกดซ้ำ 2 ครั้งติดกันเพื่อยืนยัน และถ้ามีข้อความค้างอยู่ในช่องพิมพ์ การกด Ctrl+D จะลบตัวอักษรด้านหน้าแทน

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

เรื่องสำคัญที่มักเข้าใจผิดคือ หลายครั้งที่ Terminal ดูเหมือน "ค้าง" ความจริงมันไม่ได้ค้าง แต่โปรแกรมกำลังรันต่อเนื่องอยู่ ตัวอย่างที่พบบ่อยที่สุดคือ เซิร์ฟเวอร์จำลองสำหรับดูเว็บระหว่างพัฒนาอย่าง Development Server ซึ่งออกแบบมาให้รันค้างไว้ตลอดเวลา ถ้าเราไปกด Ctrl+C จะสั่งปิดเว็บนั้นทันที วิธีที่ถูกต้องคือปล่อยแท็บเดิมให้รันไป แล้วเปิดแท็บ Terminal ใหม่ขึ้นมาเพื่อทำงานอื่นต่อ

4. Git คือปุ่ม Undo ของ Vibe Coding

Git คือระบบบันทึกประวัติการแก้ไขไฟล์ สำหรับมือใหม่หรือชาว Vibe Coding ที่เน้นสั่ง AI เขียนโค้ด ไม่จำเป็นต้องเรียนรู้โครงสร้างทั้งหมด ไม่ต้องรู้จัก Branch หรือ Merge และไม่ต้องสมัครบัญชี GitHub ให้ยุ่งยาก แค่จำ 5 คำสั่งพื้นฐาน นี้ก็เพียงพอ:

git init                                # เริ่มต้นบันทึกประวัติในโฟลเดอร์นี้ (ทำแค่ครั้งเดียว)
git status                              # เช็กดูว่ามีไฟล์ไหนถูกแก้ไข เพิ่ม หรือลบไปบ้าง
git diff                                # ดูรายละเอียดว่าโค้ดถูกแก้ตรงไหน บรรทัดไหน
git add -A && git commit -m "ข้อความ"    # บันทึกจุดเซฟพร้อมใส่คำอธิบายสั้น ๆ
git restore .                           # ย้อนกลับไปยังจุดเซฟล่าสุดทันที

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

ทำไมเรื่องนี้ถึงสำคัญมากเมื่อใช้ AI Agent? เพราะ Claude Code ไม่ได้แก้โค้ดทีละจุดเหมือนคนเรา คำสั่งเดียวของเราอาจทำให้มันแก้ไขโค้ดพร้อมกัน 7 ไฟล์ สร้างไฟล์ใหม่ 3 ไฟล์ และลบไฟล์เดิมทิ้งไปอีก 2 ไฟล์ในเวลาไม่กี่วินาที การกด Ctrl+Z ในโปรแกรมแก้โค้ดเอาไม่อยู่แน่นอนเพราะมันย้อนได้แค่ทีละไฟล์ที่เปิดอยู่ แต่คำสั่ง git restore . จะกู้คืนทุกไฟล์ทั้งโฟลเดอร์กลับมายังจุดเซฟล่าสุดได้ในคำสั่งเดียว

กฎทองที่นำไปใช้ได้ทันทีคือ ให้ Commit ก่อนสั่ง Claude ทำงานใหญ่ทุกครั้ง โดยคำว่างานใหญ่หมายถึงฟีเจอร์หรือการแก้ไขใด ๆ ที่เราต้องอธิบายความต้องการยาวเกินหนึ่งบรรทัด

ข่าวดีคือ เราสามารถสั่งให้ Claude จัดการ Git ผ่านภาษาพูดได้ด้วย เช่น สั่งให้มันเช็กว่ามีไฟล์ไหนเปลี่ยนไปบ้าง หรือสั่งให้มัน Commit พร้อมสรุปการทำงานให้ แต่คำสั่ง git restore . เราควรพิมพ์เองให้คล่อง เพราะในจังหวะที่โค้ดพังจนระบบรวน เราคงไม่อยากมานั่งเสียเวลาอธิบายอะไรกับ AI อีก

5. Terminal ไม่มีถังขยะ อ่านให้จบก่อนกด Yes

เวลาเราลบไฟล์ผ่านหน้าจอปกติ ไฟล์จะย้ายไปอยู่ในถังขยะทำให้ยังกดกู้คืนได้เสมอ แต่บน Terminal ไม่มีระบบถังขยะ คำสั่ง rm คือการลบทิ้งถาวรทันที หายแล้วหายเลย

คำสั่งที่ต้องระวังเป็นพิเศษคือ rm -rf ซึ่งหมายถึง "ลบทั้งโฟลเดอร์และไฟล์ย่อยข้างในทั้งหมดทันทีโดยไม่ต้องถามยืนยัน" คำสั่งนี้ไม่ได้ผิดอะไรและเป็นคำสั่งปกติที่ใช้งานกันทั่วไป แต่อันตรายจะเกิดขึ้นทันทีถ้านำไปใช้คู่กับ Path ที่ผิด เหมือนที่เตือนไว้ในข้อ 1 และข้อ 2

อีกรูปแบบหนึ่งที่พบบ่อยคือคำสั่งติดตั้งโปรแกรมที่คัดลอกมาจากอินเทอร์เน็ตในรูปแบบ curl ... | bash ซึ่งหมายถึง "ดาวน์โหลดสคริปต์จาก URL นั้นมาสั่งรันบนเครื่องทันที" เอกสารทางการของ Claude Code เองก็ใช้วิธีนี้ในการติดตั้ง ซึ่งปลอดภัยตราบใดที่เรามั่นใจว่าเป็น URL จากเว็บไซต์ทางการจริง ๆ ก่อนกด Enter จึงควรสังเกตโดเมนของลิงก์ในคำสั่งให้ดีเสมอ

สำหรับการทำงานร่วมกับ Claude Code ในช่วงแรกที่เริ่มใช้งาน ระบบจะถามขออนุมัติจากเราก่อนแก้ไขไฟล์หรือรันคำสั่งเสมอ หลังจากนั้น สำหรับผู้ใช้แพ็กเกจ Pro, Max และ Team ระบบจะเปิดใช้งาน Auto Mode เป็นค่าเริ่มต้น ซึ่งมีตัวกรองความปลอดภัยและให้ Claude แก้ไฟล์หรือรันคำสั่งทั่วไปได้โดยอัตโนมัติ ส่วนแพ็กเกจอื่นจะเริ่มต้นด้วย Manual Mode ที่ต้องกดยืนยันทุกครั้ง โดยสามารถกด Shift+Tab เพื่อสลับโหมดไปมาระหว่างทำงานได้ตลอดเวลา

ในช่วงเริ่มต้น แนะนำให้ใช้โหมดที่ต้องกดยืนยันก่อนเสมอ แม้จะช้าลงเล็กน้อยแต่ช่วยให้เราได้เห็นและเรียนรู้ว่า AI กำลังทำอะไรกับเครื่องเรา ส่วนโหมด Bypass Permissions ที่ข้ามการถามทั้งหมด ควรหลีกเลี่ยงจนกว่าเราจะอ่านคำสั่งได้คล่องจริง ๆ

เวลา Claude ขออนุมัติ ให้เช็กเพียง 2 จุดสำคัญ:

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

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

6. Error ไม่ใช่คำด่า แต่มันคือคำใบ้

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

• command not found: เครื่องไม่รู้จักคำสั่งนี้ สาเหตุหลักคือยังไม่ได้ติดตั้งโปรแกรมนั้น หรือพิมพ์ชื่อคำสั่งผิด
• no such file or directory: ระบบหาไฟล์หรือโฟลเดอร์ไม่เจอ มักเกิดจากการระบุ Path ผิด ให้ลองพิมพ์ pwd เพื่อเช็กตำแหน่งปัจจุบัน และ ls เพื่อดูรายชื่อไฟล์
• permission denied: ไม่มีสิทธิ์เข้าถึงไฟล์หรือโฟลเดอร์นั้น ส่วนใหญ่เกิดจากการอยู่ผิดโฟลเดอร์ เช่น เผลอไปแตะไฟล์ระบบ อย่าเพิ่งรีบใส่ sudo ข้างหน้าเพื่อบังคับรันคำสั่ง เพราะนั่นคือการแก้ปัญหาผิดจุดและอาจทำให้ระบบเสียหายได้
• port already in use: พอร์ตที่โปรแกรมพยายามใช้งานมีโปรแกรมอื่นจองอยู่แล้ว สาเหตุยอดฮิตคือมี Development Server รันค้างไว้ในแท็บ Terminal อื่นแล้วลืมปิด

สำหรับผู้ใช้ Windows ข้อความ Error บางแบบจะบอกได้ทันทีว่าเราเปิดโปรแกรมพิมพ์คำสั่งผิดตัว ระหว่าง PowerShell กับ Command Prompt หรือ CMD:

• ถ้าเจอข้อความ The token '&&' is not a valid statement separator... แปลว่าเรากำลังอยู่ใน PowerShell
• ถ้าเจอข้อความ 'irm' is not recognized as an internal or external command แปลว่าเรากำลังอยู่ใน CMD
• วิธีสังเกตง่าย ๆ คือดูที่ต้นบรรทัด: ถ้าขึ้นต้นด้วย PS C:\ คือ PowerShell ถ้าขึ้นแค่ C:\ คือ CMD

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

7. ทำไมเครื่องคุณ "ไม่มี" Node ทั้งที่เพิ่งติดตั้งไป

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

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

วิธีแก้นั้นง่ายมาก: แค่ปิดหน้าต่าง Terminal แล้วเปิดใหม่ แค่นั้นจริง ๆ ระบบก็จะโหลดค่า PATH ใหม่และมองเห็นโปรแกรมที่เพิ่งลงทันที ก่อนจะไปแก้ไขการตั้งค่าระบบที่ซับซ้อน ให้ลองปิดแล้วเปิดใหม่ก่อนเสมอ

โปรแกรมหลัก 3 ตัวที่ Claude Code เรียกใช้งานบ่อยที่สุด ได้แก่ Node.js, Git และ Python ถ้าติดตั้ง Claude Code ผ่าน npm ซึ่งเป็นโปรแกรมจัดการแพ็กเกจของ Node.js จะต้องใช้ Node.js เวอร์ชัน 22 ขึ้นไป หลังจากติดตั้งเสร็จ ให้ตรวจเช็กความพร้อมด้วย 2 คำสั่งนี้:

claude --version   # แสดงเลขเวอร์ชัน และกำกับด้วย (Claude Code)
claude doctor      # ตรวจสอบความพร้อมและสุขภาพของระบบอย่างละเอียด

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

คำแนะนำพิเศษสำหรับผู้ใช้ Windows

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

การใช้งาน Claude Code บน Windows เลือกทำได้ 2 แนวทาง:

1. รันบน Windows โดยตรงผ่าน Git Bash: แนะนำให้ติดตั้ง Git for Windows ซึ่งจะมีโปรแกรม Git Bash ติดมาด้วย ทำให้เราสามารถพิมพ์คำสั่งตามคู่มือส่วนใหญ่ในอินเทอร์เน็ตได้ทันทีโดยไม่ต้องแปลงคำสั่ง
2. รันผ่าน WSL (Windows Subsystem for Linux): เป็นการจำลองระบบ Linux ขึ้นมาทำงานบน Windows โดยตรง ถ้าเลือกทางนี้ จะต้องติดตั้งและพิมพ์คำสั่ง claude จากในหน้าต่างของ WSL เท่านั้น ไม่ใช่จาก PowerShell หรือ CMD

เลือกแบบไหนดี?

• ถ้าต้องการเริ่มต้นง่าย ๆ โดยไม่ต้องติดตั้งอะไรเพิ่มเยอะ ให้เลือก Git Bash
• ถ้าตั้งใจจะทำโปรเจกต์จริงจังในระยะยาว การใช้ WSL จะคุ้มค่ากว่ามาก เพราะเครื่องมือและคู่มือสายพัฒนาส่วนใหญ่ในโลกอิงกับ Linux เป็นหลัก ดูขั้นตอนการติดตั้งอย่างละเอียดได้ในบทความ วิธีติดตั้ง Claude Code บน Windows 11

ทางเลือกที่ง่ายและเหมาะกับมือใหม่ที่สุด: ใช้ Terminal ใน VS Code

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

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

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

แบบฝึกหัด 5 นาที: ลองทำพังแล้วกู้คืนด้วยตัวเอง

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

เปิดหน้าต่าง Terminal แล้วพิมพ์คำสั่งตามนี้ทีละบรรทัด:

mkdir vibe-test
cd vibe-test
git init
claude

เมื่อเข้าสู่หน้าต่าง Claude Code แล้ว ให้ลองทำตามขั้นตอนต่อไปนี้:

1. สร้างไฟล์: สั่งให้ Claude สร้างไฟล์อะไรก็ได้ เช่น "สร้างไฟล์ index.html หน้าเดียว มีหัวข้อกับปุ่มหนึ่งปุ่ม"
2. สร้างจุดเซฟ: สลับกลับมาที่ Terminal หรือเปิดแท็บใหม่ แล้วพิมพ์คำสั่ง:

git add -A && git commit -m "จุดเซฟแรก"

3. ลองทำให้พัง: กลับไปที่ Claude แล้วตั้งใจสั่งให้มันแก้โค้ดจนพัง เช่น "ลบเนื้อหาใน index.html ทิ้งให้หมด แล้วเขียนอย่างอื่นแทน"
4. ตรวจดูความเปลี่ยนแปลง: พิมพ์ git status ใน Terminal จะเห็นว่าไฟล์เปลี่ยนไปจริง ๆ
5. กู้คืนข้อมูล: พิมพ์คำสั่ง:

git restore .

จากนั้นลองเปิดไฟล์ index.html ขึ้นมาดูอีกครั้ง

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

ที่เหลือค่อยเรียนรู้เมื่อต้องใช้งานจริง

สังเกตไหมว่าทั้ง 7 เรื่องที่ผ่านมา ไม่มีข้อไหนสอนให้เรานั่งเขียนคำสั่งซับซ้อนเลย ทุกข้อมีแค่เรื่องที่เราต้องเข้าใจว่า ตอนนี้เราอยู่ตรงไหน กำลังจะทำอะไร และถ้าระบบพังจะกู้คืนอย่างไร

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

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