Agent Loop: หัวใจของ Claude Code
เมื่อผมเริ่มใช้ Claude Code ผมปฏิบัติกับมันเหมือนแชท
ผมขออะไรบางอย่าง มันก็ตอบกลับมา และจบแค่นั้น
มันใช้งานได้ แต่เมื่อเวลาผ่านไป ผมเริ่มสังเกตว่าผมไม่ได้ใช้ศักยภาพของมันอย่างเต็มที่
ผมใช้พรอมต์เดิมซ้ำ ๆ ผมรันคำสั่งเดิมซ้ำ ๆ ผมไม่ชัดเจนว่าจะใช้ประโยชน์จากมันอย่างเต็มที่ได้อย่างไร
ผมเลยหยุดแล้วถามตัวเองว่า:
ข้างใน Claude Code มันทำงานยังไงกันแน่?
ผมเริ่มอ่านเอกสาร ทดลอง และลองผิดลองถูก
และสิ่งที่ผมค้นพบคือ:
มันไม่ใช่เรื่องมหัศจรรย์ มันสร้างขึ้นจากชิ้นส่วนที่เป็นรูปธรรม แต่ละชิ้นมีบทบาทชัดเจน และเมื่อคุณเข้าใจมัน ทุกอย่างก็เริ่มเป็นระบบ
→ ถ้าคุณใช้คำสั่งเดิมซ้ำ ๆ คุณก็แปลงมันเป็น Skill
→ ถ้ามันเสียเธรดในงานยาว ๆ คุณก็มอบหมายให้ SubAgent
→ ถ้ามีขั้นตอน manual ที่คุณทำซ้ำ ๆ คุณก็ Automate ด้วย Hooks
การเข้าใจพื้นฐานคือสิ่งที่ทำให้คุณรู้ว่าควรใช้อะไร เมื่อไหร่ และทำไม
วันนี้ผมมีมากกว่า 100 Skills, กระบวนการอัตโนมัติที่เคยใช้เวลาผมหลายชั่วโมง, และ agents สำหรับตรวจสอบโค้ด และศึกษาหัวข้อที่ผมสนใจ
ผมเขียนบทความนี้เพื่อแบ่งปันทุกสิ่งที่ผมได้เรียนรู้กับคุณ
มาเริ่มกันเลย
Agent Loop: หัวใจของ Claude Code
Claude Code คือ agent
ระบบที่คุณให้เป้าหมาย และมันจะทำงานจนกว่าจะบรรลุเป้าหมายนั้น
มันแตกต่างจากแชท ในแชท คุณถาม "ฉันจะเพิ่มการยืนยันตัวตนให้แอปของฉันได้ยังไง" และมันอธิบายขั้นตอน
แต่คุณต้องไปที่โปรเจกต์ แก้ไขโค้ด และทดสอบว่ามันใช้งานได้
คุณเป็นคนทำงาน
ด้วย Claude Code คุณบอกมัน "เพิ่มการยืนยันตัวตนให้แอปของฉัน" และมันจัดการเอง
มันอ่านโค้ด เลือกไลบรารี เขียนการเปลี่ยนแปลง และแจ้งคุณเมื่อเสร็จ
มันมีเป้าหมาย: เพิ่มการยืนยันตัวตน
และมันจะทำงานจนกว่าจะบรรลุเป้าหมาย
แต่มันรู้ได้ยังไงว่าต้องทำอะไรหลังจากแต่ละขั้นตอน? มันรู้ได้ยังไงว่าบางอย่างใช้ได้ผล? มันต้องการบางอย่างเพื่อประสานการตัดสินใจเหล่านั้น
นั่นคือ loop
วงจรที่วนซ้ำ
Claude Code ดำเนินการ สังเกตผลลัพธ์ ตัดสินใจว่าจะทำอะไรต่อไป และเริ่มใหม่ มันไม่หยุดจนกว่าเป้าหมายจะสำเร็จ
ถ้าบางอย่างล้มเหลว มันกลับไปแก้ไขและดำเนินการต่อ
loop มี 3 เฟส:
รวบรวมบริบท → ทำความเข้าใจว่าต้องทำอะไร อ่านไฟล์ วิเคราะห์โค้ด สำรวจโครงสร้างโปรเจกต์
ดำเนินการ → ทำการเปลี่ยนแปลง แก้ไขไฟล์ รันคำสั่ง ติดตั้ง dependencies
ตรวจสอบผลลัพธ์ → ตรวจสอบว่าสิ่งที่ทำไปนั้นใช้งานได้ ทดสอบ ตรวจสอบข้อผิดพลาด แก้ไขถ้าบางอย่างล้มเหลว
loop ปรับเปลี่ยนตามสิ่งที่คุณขอ
คำถามง่าย ๆ อาจต้องการแค่รวบรวมบริบท การแก้ไขบั๊กอาจต้องผ่านทั้งสามเฟสหลายครั้ง
Claude Code ตัดสินใจว่าแต่ละขั้นตอนต้องการอะไรโดยอิงจากสิ่งที่เรียนรู้จากขั้นตอนก่อนหน้า และคุณก็เป็นส่วนหนึ่งของ loop นั้นด้วย
คุณสามารถขัดจังหวะเมื่อไหร่ก็ได้เพื่อเปลี่ยนทิศทาง เพิ่มบริบท หรือให้ลองวิธีอื่น
นี่คือหัวใจของ Claude Code
ทุกอย่างที่ตามมามีอยู่เพื่อทำให้ loop นี้ทรงพลังยิ่งขึ้น
Tools: Claude Code ทำอะไรในโลกจริงได้บ้าง
LLM โดยการออกแบบแล้วประมวลผลเฉพาะข้อความ
มันรับข้อความและสร้างข้อความ มันไม่มีสิทธิ์เข้าถึงระบบไฟล์ของคุณ มันไม่สามารถรันคำสั่ง มันไม่รู้ว่ามีอะไรในโปรเจกต์ของคุณ
มันถูกแยกออก
แล้ว Claude Code เปิดไฟล์หรือแก้ไขมันได้ยังไง?
มันใช้ tools
Tools คือฟังก์ชันที่ Claude Code สามารถเรียกใช้เพื่อโต้ตอบกับโลกจริง
ลองนึกถึงแอปบนมือถือ โทรศัพท์เครื่องเดียวทำอะไรไม่ได้: เป็นแอปที่ให้ความสามารถเฉพาะ: ถ่ายรูป ส่งข้อความ นำทาง
Tools ก็เหมือนกันสำหรับ Claude Code
ทุกครั้งที่มันใช้ tool มันจะส่งคำขอไปยังระบบพร้อมกับสิ่งที่ต้องการ ระบบดำเนินการและส่งคืนผลลัพธ์
Claude Code ใช้ผลลัพธ์นั้นเพื่อตัดสินใจว่าจะทำอะไรต่อไป
1คำขอของคุณ2 ↓3Claude Code ตัดสินใจว่าจะใช้ tool ใด4 ↓5┌─────────────────────────────────┐6│ Read · Edit · Write · Bash │7│ Grep · Glob · WebFetch · WebSearch │8└─────────────────────────────────┘9 ↓10ระบบดำเนินการ tool11 ↓12ผลลัพธ์กลับมายัง Claude Code13 ↓14เสร็จแล้ว? → ไม่ → ใช้ tool อื่น15 ใช่ → ตอบกลับ
Claude Code มาพร้อมกับ tools พื้นฐานสำหรับการทำงานทั่วไป:
Read / Edit / Write → อ่าน แก้ไข และสร้างไฟล์ เป็น tool ที่ใช้มากที่สุด ทุกครั้งที่ Claude Code "เข้าใจโค้ดของคุณ" หรือ "ทำการเปลี่ยนแปลง" มันกำลังใช้สามตัวนี้
Bash → เข้าถึง terminal ได้เต็มรูปแบบ ถ้าคุณทำได้จาก command line Claude Code ก็ทำได้: ติดตั้ง dependencies รัน tests สร้าง commits
Grep และ Glob → ค้นหาภายในโปรเจกต์ Glob ค้นหาไฟล์ตามชื่อหรือ pattern Grep ค้นหาเนื้อหาที่ระบุภายในไฟล์
WebFetch และ WebSearch → เข้าถึงอินเทอร์เน็ต ดูเอกสาร อ่าน API ตรวจสอบข้อผิดพลาดที่ไม่เคยเจอมาก่อน
ย้อนกลับไปตัวอย่างบั๊กในปุ่มล็อกอิน
เมื่อ Claude Code ทำงานกับบั๊กนั้น มันใช้หลาย tools ร่วมกัน:
→ มันใช้ Glob เพื่อค้นหาไฟล์ component
→ มันใช้ Read เพื่ออ่านโค้ดและทำความเข้าใจสิ่งที่เกิดขึ้น
→ มันใช้ Edit เพื่อแก้ไขข้อผิดพลาด
→ มันใช้ Bash เพื่อรัน tests และตรวจสอบว่ามันใช้งานได้
ทั้งหมดนี้โดยที่คุณไม่ต้องเข้าไปยุ่ง นั่นคือความแตกต่างระหว่าง chat และ agent
Context และ Memory: สิ่งที่ Claude Code จดจำ
Claude Code ทำงาน ดำเนินการ รับผลลัพธ์ และตัดสินใจว่าจะทำอะไรต่อไป
แต่มันรู้ได้ยังไงว่ามันทำอะไรไปแล้วบ้าง?
ทั้งหมดเป็นเพราะ context
Context คือข้อมูลที่ Claude Code มีในขณะนั้น ทุกครั้งที่มันดำเนินการ ผลลัพธ์จะสะสมอยู่ในนั้น
ไม่ใช่แค่พรอมต์เริ่มต้นของคุณ แต่รวมถึงทุกอย่างที่มันเจอ: ไฟล์ที่เปิด สิ่งที่ค้นพบในโค้ด การกระทำที่ดำเนินการ และผลลัพธ์ของมัน
นั่นคือสาเหตุที่มันสามารถเชื่อมโยงขั้นตอน แก้ไขตัวเอง และทำงานให้เสร็จได้ด้วยตัวเอง
context นั้นมี 2 ปัญหา
1. มีความจุจำกัด ถ้าเซสชันยาวมาก context จะเต็มและ Claude Code จะเริ่มลืมสิ่งที่เกิดขึ้นก่อนหน้านี้ เดี๋ยวคุณจะเห็นว่า SubAgents แก้ปัญหานี้อย่างไร
2. มันว่างเปล่าทุกครั้งที่คุณเปิดการสนทนาใหม่ Claude Code ไม่รู้ว่าคุณอยู่ในโปรเจกต์ไหน ทีมของคุณทำงานยังไง หรือมีข้อสรุปอะไรไปแล้วบ้าง ถ้าคุณไม่บอก มันก็จะเดาหรือถามคุณ
Memory แก้ปัญหาที่สอง
มันคือระบบไฟล์ markdown ที่คุณบันทึกทุกสิ่งที่ Claude Code จำเป็นต้องรู้: stack ของคุณ ข้อกำหนดของทีม โครงสร้างของโปรเจกต์
Claude Code อ่านมันเมื่อเริ่มต้นแต่ละเซสชัน และฉีดข้อมูลนั้นเข้าไปใน context ก่อนที่คุณจะเขียนบรรทัดแรก
ถ้าไม่มี Memory: คุณบอกมัน "เพิ่ม endpoint เพื่อสร้างผู้ใช้" และ Claude Code ถามคุณ: "คุณใช้ framework อะไร? มี database ที่ตั้งค่าไว้หรือไม่? routes มีโครงสร้างอย่างไร?"
ถ้ามี Memory: คุณบอกมันสิ่งเดียวกัน และมันรู้อยู่แล้วว่าคุณใช้ Express กับ Prisma, routes อยู่ใน /src/routes, และ errors ถูกจัดการด้วย centralized middleware มันเริ่มทำงานโดยไม่ต้องถาม
Claude Code มี 2 ระบบความจำ:
→ CLAUDE.md - ไฟล์ Markdown ที่คุณเขียนด้วยทุกสิ่งที่ Claude Code จำเป็นต้องรู้ มันสามารถอยู่ในระดับต่าง ๆ:
→ ~/.claude/CLAUDE.md - ใช้กับทุกโปรเจกต์ของคุณ ความชอบส่วนตัวของคุณไปอยู่ที่นี่: คุณอยากให้มันเขียนโค้ดยังไง ข้อกำหนดที่คุณใช้เสมอ คำสั่งต้องเฉพาะเจาะจง: "ใช้ 2 ช่องว่างในการเยื้อง" ชัดเจนกว่า "จัดรูปแบบโค้ดให้ดี"
→ /your-project/CLAUDE.md - เฉพาะ repository สถาปัตยกรรม ข้อกำหนดของทีม และคำสั่งสำคัญไปอยู่ที่นี่ เมื่อคุณเริ่มโปรเจกต์ใหม่ รัน /init และ Claude Code จะสร้างมันให้อัตโนมัติ เก็บให้ต่ำกว่า 200 บรรทัด: ถ้ามันใหญ่เกินไป Claude Code จะเริ่มไม่สนใจคำสั่ง และถ้าคุณ commit มันลง repo ทั้งทีมจะใช้ context เดียวกัน
→ .claude/rules/ - กฎแบบโมดูลาร์ที่ทำงานตามประเภทของไฟล์ มีประโยชน์เมื่อโปรเจกต์โตขึ้นและคุณไม่อยากใส่ทุกอย่างในไฟล์เดียว
Auto Memory - ความจำที่ Claude Code สร้างขึ้นเอง เมื่อคุณทำงาน มันจะจดบันทึกด้วยตัวเอง: patterns ที่ตรวจพบ การแก้ไขที่คุณทำ การตัดสินใจที่คุณทำร่วมกัน มันถูกบันทึกใน
~/.claude/projects/<project>/memory/ และถูกโหลดเมื่อเริ่มต้นแต่ละเซสชัน
ตรวจสอบมันบ่อย ๆ: Claude Code อาจบันทึกแนวทางปฏิบัติที่ไม่ดีโดยที่คุณไม่รู้ตัว
เคล็ดลับ: คุณสามารถดูและแก้ไขทุกสิ่งที่ Claude Code จดจำได้โดยการรัน /memory
Hooks และ Skills: ควบคุมการทำงาน
1. Hooks
Claude Code ทำงานด้วยตัวเอง
มันดำเนินการ ตัดสินใจ ก้าวไปข้างหน้า
แต่ความเป็นอิสระนั้นมีด้านที่ไม่ได้พูดถึงมากนัก: Claude Code ทำในสิ่งที่มันเห็นว่าถูกต้องในแต่ละขั้นตอน
ถ้าบางอย่างผิดพลาด หรือมันทำสิ่งที่คุณไม่ต้องการ มันก็ทำไปแล้ว
คุณควบคุมมันยังไง? ด้วย hooks
Hook คือคำสั่งที่ทำงานอัตโนมัติ ณ จุดเฉพาะในวงจร ก่อนที่ Claude Code จะใช้ tool, หลังจากที่มันใช้ tool, เมื่อเซสชันสิ้นสุด
คุณกำหนดว่าจะเกิดอะไรขึ้นในแต่ละช่วงเวลา
ประเด็นสำคัญคือ hooks เป็น deterministic
มันไม่ได้ขึ้นอยู่กับว่า Claude Code "จำ" ต้องทำอะไรบางอย่าง มันถูกดำเนินการเสมอ โดยไม่มีข้อยกเว้น
hooks หลักสี่ตัวคือ:
PreToolUse - ทำงานก่อนที่ Claude Code จะใช้ tool เป็น hook เดียวที่สามารถบล็อกการดำเนินการได้ ตัวอย่าง: ปิดกั้นคำสั่งใด ๆ ที่พยายามแก้ไขไฟล์ .env
PostToolUse - ทำงานหลังจากที่ Claude Code ใช้ tool ตัวอย่าง: รัน Prettier อัตโนมัติทุกครั้งที่ Claude Code แก้ไขไฟล์
Notification - ทำงานเมื่อ Claude Code ต้องการความสนใจจากคุณ ตัวอย่าง: รับการแจ้งเตือนบน Mac เมื่อ Claude Code ทำงานยาวเสร็จ
Stop - ทำงานเมื่อ Claude Code ตอบกลับเสร็จ ตัวอย่าง: push ไปยัง staging อัตโนมัติเมื่อ agent ทำงานเสร็จ
มันถูกตั้งค่าใน .claude/settings.json:
1{2 "hooks": {3 "PostToolUse": [4 {5 "matcher": "Edit|Write",6 "hooks": [7 {8 "type": "command",9 "command": "npx prettier --write $file_path"10 }11 ]12 }13 ]14 }15}
hook นี้รัน Prettier อัตโนมัติทุกครั้งที่ Claude Code แก้ไขหรือสร้างไฟล์
โดยที่คุณไม่ต้องขอ โดยที่ Claude Code ไม่ต้องจำว่าต้องทำ
ไม่มี Hook: Claude Code แก้ไขไฟล์ โค้ดยังไม่จัดรูปแบบ และคุณเพิ่งรู้ตอน commit ถัดไป
มี Hook: Claude Code แก้ไขไฟล์ PostToolUse ทำงานอัตโนมัติ Prettier จัดรูปแบบไฟล์ และโค้ดก็สะอาดอยู่เสมอ
Hooks ช่วยให้คุณเพิ่มพฤติกรรมที่รับประกันได้ในวงจรของ agent ไม่ใช่คำแนะนำ ไม่ใช่คำสั่งที่โมเดลสามารถละเลยได้ แต่เป็นกฎที่ถูกดำเนินการเสมอ
2. Skills
มีอีกปัญหาหนึ่ง: ความสม่ำเสมอ
คุณขอให้มันทำงานเดียวกันสองครั้งและได้ผลลัพธ์ต่างกัน ทุกครั้งที่คุณเปิดการสนทนาใหม่ Claude Code เริ่มต้นโดยไม่รู้ว่าคุณทำยังไงครั้งที่แล้ว
คุณแก้ปัญหายังไง? ด้วย Skills
Skill คือไฟล์ markdown ที่คุณอธิบายกระบวนการที่แน่นอนสำหรับงานหนึ่งให้ Claude Code: ต้องตรวจสอบอะไร ตามลำดับไหน ใช้รูปแบบอะไร ควรละเว้นอะไร
ทุกครั้งที่งานนั้นปรากฏขึ้น Claude Code จะทำตามคำสั่งเหล่านั้น
ไม่มี Skill: คุณขอให้มันบันทึก API และมันสร้างบางอย่างขึ้นมา แต่แต่ละครั้งมีรูปแบบต่างกัน บางครั้งมีตัวอย่าง บางครั้งไม่มี
มี Skill: คุณขอให้มันบันทึก API และมันทำตามกระบวนการที่คุณกำหนดไว้ทุกประการ ขั้นตอนเดียวกัน รูปแบบเดียวกัน เกณฑ์เดียวกัน ทุกครั้งเหมือนเดิม
การสร้าง Skill คุณกำหนดโฟลเดอร์ที่มีโครงสร้างนี้:
1my-skill/2├── SKILL.md # คำสั่งหลัก (จำเป็น)3├── template.md # แม่แบบที่ Claude กรอก4├── examples/5│ └── sample.md # ตัวอย่างผลลัพธ์ที่คาดหวัง6└── scripts/7 └── validate.sh # สคริปต์ที่ Claude สามารถรันได้
ไฟล์ที่จำเป็นเท่านั้นคือ SKILL.md ส่วนที่เหลือเป็นตัวเลือกและคุณเพิ่มตามที่งานต้องการ
SKILL.md มี 2 ส่วน:
ส่วนหน้า (frontmatter) - บล็อก YAML พร้อมชื่อและคำอธิบาย ชื่อคือคำสั่งเพื่อเรียกใช้ด้วยตนเอง คำอธิบายคือสิ่งที่ Claude Code อ่านเพื่อตัดสินใจว่าจะเปิดใช้งานอัตโนมัติเมื่อไหร่
เนื้อหา (body) - คำสั่งในรูปแบบ markdown ขั้นตอนการทำงาน เกณฑ์ รูปแบบผลลัพธ์
1---2name: api-docs3description: บันทึก API endpoints ใช้เมื่อผู้ใช้4 ขอให้บันทึก API หรือพูดถึง "swagger" หรือ "endpoints"5---67## กระบวนการ81. ระบุ endpoints ทั้งหมด92. สำหรับแต่ละ endpoint: method, path, parameters, expected response103. รวมตัวอย่างคำขอและคำตอบ114. ปิดท้ายด้วยตารางสรุป
เมื่อสร้างเสร็จ คุณสามารถเรียกใช้ได้สองวิธี
โดยการเขียน /api-docs โดยตรงในแชท หรือเพียงแค่ขอ Claude Code ด้วยภาษาธรรมชาติ
ถ้าคำอธิบายตรงกับสิ่งที่คุณถาม มันจะเปิดใช้งานเอง
คุณสามารถสร้างมันสำหรับงานใด ๆ ที่คุณทำซ้ำและมีกระบวนการที่ชัดเจน: API documentation, changelogs, meeting summaries, code migrations
SubAgents: มอบหมายเมื่อปัญหาใหญ่ขึ้น
เราเห็นแล้วว่า context มีความจุจำกัด
ยิ่งเซสชันยาวเท่าไรมันก็ยิ่งเต็ม และเมื่อมันเต็ม Claude Code จะเริ่มสูญเสียข้อมูลเกี่ยวกับสิ่งที่เกิดขึ้นก่อนหน้านี้
ลองนึกภาพว่าคุณขอให้มันตรวจสอบโปรเจกต์ทั้งหมดของคุณเพื่อหาปัญหาด้านความปลอดภัย มันอ่านไฟล์หลายสิบไฟล์ วิเคราะห์โค้ด สร้างรายงานโดยละเอียด
ทั้งหมดนั้นเติม context อย่างรวดเร็ว
และในขณะที่มันทำอย่างนั้น การสนทนาหลักของคุณก็ถูกบล็อก
คุณแก้ปัญหายังไง? ด้วย SubAgents
SubAgent คืออินสแตนซ์แยกต่างหากของ Claude Code ที่รันด้วย context ของตัวเอง
agent หลักมอบหมายงานให้ SubAgent ดำเนินการอย่างอิสระ และเมื่อมันเสร็จ มันจะส่งสรุปพร้อมผลลัพธ์
context ของ agent หลักไม่เต็มไปด้วยกระบวนการทั้งหมด มีแค่ข้อสรุปเท่านั้น
1Agent หลัก2 ↓3"ตรวจสอบโปรเจกต์เพื่อหาปัญหาด้านความปลอดภัย"4 ↓5┌─────────────────────────────┐6│ SubAgent: security-reviewer │7│ │8│ อ่านไฟล์โปรเจกต์ │9│ วิเคราะห์โค้ด │10│ ตรวจหาช่องโหว่ │11│ สร้างรายงาน │12└─────────────────────────────┘13 ↓14ส่งคืนสรุปให้ agent หลัก15 ↓16Agent หลักดำเนินการต่อด้วย loop
และไม่เพียงเท่านั้น
SubAgents สามารถรันแบบขนานได้
แทนที่จะวิเคราะห์สามส่วนของโค้ดตามลำดับ Claude Code สามารถมอบหมายทั้งสามส่วนพร้อมกัน
สิ่งที่เคยใช้เวลาหลายนาทีสามารถใช้เวลาเป็นวินาที
1Agent หลัก2 ↓3แบ่งงานเป็นงานอิสระ4 ↓5┌──────────────┐ ┌──────────────┐ ┌──────────────┐6│ SubAgent 1 │ │ SubAgent 2 │ │ SubAgent 3 │7│ │ │ │ │ │8│ ตรวจสอบ auth │ │ ตรวจสอบ DB │ │ ตรวจสอบ ext │9│ │ │ │ │ APIs │10└──────────────┘ └──────────────┘ └──────────────┘11 ↓ ↓ ↓12 Agent หลักได้รับสามสรุป13 ↓14 ดำเนินการต่อด้วย loop
Claude Code มี SubAgents พื้นฐาน 3 ตัวที่มันใช้โดยอัตโนมัติ:
→ Explore - agent ที่รวดเร็ว อ่านอย่างเดียว เชี่ยวชาญในการค้นหาและวิเคราะห์โปรเจกต์ ผลลัพธ์อยู่ใน context ของ SubAgent ไม่ใช่ของคุณ
→ Plan - เปิดใช้งานในโหมดวางแผน ก่อนที่จะนำเสนอแผนให้คุณ Claude Code มอบหมายการตรวจสอบโปรเจกต์ให้ agent นี้
→ General-purpose - สำหรับงานที่ซับซ้อนซึ่งต้องทั้งการสำรวจและการแก้ไข
คุณยังสามารถสร้างของคุณเองได้
SubAgents ถูกกำหนดในไฟล์ markdown พร้อม YAML frontmatter และบันทึกใน .claude/agents/
1---2name: security-reviewer3description: ตรวจสอบโค้ดเพื่อหาช่องโหว่ด้านความปลอดภัย4 ใช้เมื่อผู้ใช้ขอให้ตรวจสอบความปลอดภัย5tools: Read, Grep, Glob6---78คุณเป็นผู้เชี่ยวชาญด้านความปลอดภัย วิเคราะห์โค้ดเพื่อหา:9- SQL Injections10- การเปิดเผยข้อมูลที่ละเอียดอ่อน11- ช่องโหว่ด้านการยืนยันตัวตน1213สรุปผลการค้นพบตามระดับความรุนแรง
สังเกตว่าใน frontmatter เราจำกัด tools เป็น Read, Grep และ Glob
agent นี้สามารถวิเคราะห์ได้แต่ไม่สามารถแก้ไขอะไรได้เลย
เมื่อคุณต้องการควบคุมอย่างละเอียดว่า agent แต่ละตัวทำอะไรได้บ้าง การจำกัด tools นั้นเป็นกุญแจสำคัญ
เมื่อสร้างเสร็จ Claude Code จะตรวจพบมันโดยอัตโนมัติจากคำอธิบายและเรียกใช้เมื่องานตรงกัน หรือคุณสามารถเรียกใช้โดยตรง: "ใช้ agent security-reviewer เพื่อตรวจสอบ PR นี้"
เมื่อไหร่ควรใช้ SubAgents และเมื่อไหร่ไม่ควร?
มันสมเหตุสมผลเมื่องานยาวและจะสร้างผลลัพธ์จำนวนมาก เมื่อคุณสามารถแบ่งงานออกเป็นส่วนอิสระที่รันแบบขนานได้ หรือเมื่อคุณต้องการ agent เฉพาะทางที่มี tools จำกัด
มันไม่คุ้มสำหรับงานสั้น ๆ ที่ไม่เต็ม context การประสานงาน SubAgents เพิ่มความซับซ้อนที่ไม่จำเป็นถ้า agent หลักสามารถแก้ปัญหาได้ในสองนาที
MCP: เชื่อมต่อ Agent กับโลกภายนอก
Tools ทำให้ Claude Code สามารถทำงานบนเครื่องของคุณ
แต่มันมีขีดจำกัด: ทุกอย่างที่เกิดขึ้นจะเกิดขึ้นในนั้นเท่านั้น
มันไม่สามารถเปิด PR บน GitHub, query ฐานข้อมูลโปรดักชัน, หรือสร้าง ticket ใน Jira ในการทำสิ่งเหล่านั้น ก่อนหน้านี้คุณต้องออกจาก agent และทำด้วยตัวเอง
คุณแก้ปัญหายังไง? ด้วย MCP
MCP (Model Context Protocol) คือโปรโตคอลเปิดที่กำหนดว่า Claude Code เชื่อมต่อกับบริการภายนอกอย่างไร
มันทำงานด้วยสถาปัตยกรรม client-server: Claude Code คือ client และแต่ละบริการภายนอกมี MCP server ของตัวเองที่เปิดเผยสิ่งที่มันทำได้
เมื่อคุณเชื่อมต่อ MCP server Claude Code จะได้รับรายการ tools ที่มีพร้อมชื่อและคำอธิบาย
จากนั้นมันจะใช้มันเหมือน tools พื้นฐานทุกประการ ข้อแตกต่างเพียงอย่างเดียวคือการดำเนินการเกิดขึ้นในบริการภายนอก ไม่ใช่บนเครื่องของคุณ
1Claude Code2 ↓3ตัดสินใจใช้ tool จาก GitHub MCP server4 ↓5┌─────────────────────────────┐6│ GitHub MCP Server │7│ │8│ เปิด PR │9│ กำหนดผู้ตรวจทาน │10│ ส่งคืนการยืนยัน │11└─────────────────────────────┘12 ↓13Claude Code รับผลลัพธ์และดำเนินการต่อ
ไม่มี MCP: คุณบอกมัน "ฉันแก้ไขเสร็จแล้ว เปิด PR" และ Claude Code ทำไม่ได้ คุณต้องไปที่ GitHub กรอกฟอร์ม กำหนดผู้ตรวจทาน และ merge เอง
มี MCP: คุณบอกมันสิ่งเดียวกันและ Claude Code เปิด PR เขียนคำอธิบาย กำหนดผู้ตรวจทาน และแจ้งคุณเมื่อพร้อม ทั้งหมดโดยที่คุณไม่ออกจาก agent
MCP servers บางตัวที่คุณสามารถเชื่อมต่อได้ตอนนี้:
→ GitHub - PRs, reviews, issues
→ Postgres / Supabase - Query และแก้ไขฐานข้อมูล
→ Slack - ข้อความและช่อง
→ Jira - Tickets และโปรเจกต์
Tools พื้นฐานสำหรับสภาพแวดล้อมในเครื่องของคุณ MCP สำหรับโลกภายนอก
ทุกอย่างทำงานร่วมกันอย่างไร
Claude Code คือ agent: ระบบที่รับเป้าหมายและทำงานใน loop อัตโนมัติจนกว่าจะบรรลุเป้าหมาย
ทุกชิ้นส่วนที่คุณเห็นในบทความนี้มีอยู่เพื่อทำให้ loop นั้นทรงพลังยิ่งขึ้น แต่วิธีที่ดีที่สุดในการทำความเข้าใจคือการเห็นพวกมันโต้ตอบกัน
กรณีที่ 1: ตรวจสอบและ merge PR
คุณขอ Claude Code: "ตรวจสอบ PR #42 และถ้าทุกอย่างเรียบร้อยให้ merge มัน"
→ มันใช้ GitHub MCP เพื่ออ่านไฟล์ที่ถูกแก้ไขและเข้าใจการเปลี่ยนแปลง
→ มันมอบหมายการวิเคราะห์ความปลอดภัยให้ SubAgent เฉพาะทาง เพื่อไม่ให้เต็ม context หลัก
→ Hook ทำงานรัน tests ในเครื่องและตรวจสอบว่าทุกอย่างผ่าน
→ ถ้า tests ผ่าน มันใช้ GitHub MCP เพื่อทำการ merge โดยที่คุณไม่ต้องแตะอินเทอร์เฟซ
คุณเขียนหนึ่งบรรทัด Claude Code ประสานงานสี่ระบบ
กรณีที่ 2: บันทึก API และแจ้งทีม
คุณขอ Claude Code: "บันทึก endpoints ใหม่และแจ้งให้ทีมทราบ"
→ มันเปิดใช้งาน documentation Skill ที่กำหนดรูปแบบที่แน่นอน: ต้องรวมอะไร มีโครงสร้างอย่างไร ต้องมีตัวอย่างอะไรบ้าง
→ มันใช้ Tools เพื่ออ่านโค้ดและดึง endpoints
→ Hook จัดรูปแบบผลลัพธ์ก่อนบันทึก
→ มันใช้ Slack MCP เพื่อส่งสรุปไปยังช่องของทีม
ทุกครั้งที่คุณทำ ผลลัพธ์จะเหมือนเดิม ไม่มีการเปลี่ยนแปลง โดยที่คุณไม่ต้องอธิบายอะไร
ทุกอย่างหมุนรอบ loop
Memory เพื่อเริ่มต้นแต่ละเซสชันอย่างมีข้อมูล Tools เพื่อดำเนินการ Hooks เพื่อควบคุม Skills เพื่อสร้างมาตรฐาน SubAgents เพื่อขยายขนาด MCP เพื่อเชื่อมต่อกับโลกภายนอก
เมื่อคุณเข้าใจสิ่งนั้น คุณก็เข้าใจ Claude Code
และไม่ใช่แค่ Claude Code: Cursor, Copilot และ agent ใด ๆ ที่คุณใช้ต่อจากนี้ไปก็ทำงานบนพื้นฐานเดียวกัน
ชื่อเปลี่ยน อินเทอร์เฟซเปลี่ยน แต่ loop เหมือนเดิม
AI กำลังก้าวหน้าอย่างรวดเร็ว
ทุกสัปดาห์มีอะไรใหม่ ๆ แต่พื้นฐานไม่ได้เปลี่ยนบ่อยนัก การมีพื้นฐานที่ชัดเจนคือสิ่งที่ช่วยให้คุณปรับตัวได้เร็วขึ้นและได้รับประโยชน์มากขึ้นจากสิ่งที่จะเกิดขึ้นต่อไป
อย่าใช้ Claude Code เพียงเพื่อการ prompting จงใส่ใจกับสิ่งที่เกิดขึ้นเบื้องหลัง นั่นคือที่ที่โอกาสอยู่
จุดเริ่มต้นบางอย่างที่คุณสามารถทำได้ตั้งแต่วันนี้:
→ ตรวจสอบ Auto Memory ของคุณและปรับปรุงสิ่งที่ Claude Code บันทึกไว้
→ สร้าง CLAUDE.md สำหรับโปรเจกต์ของคุณถ้ายังไม่มี
→ เชื่อมต่อ GitHub MCP
→ สร้าง SubAgent สำหรับงานที่เต็ม context
→ ตั้งค่า Hook ที่รัน tests หลังจากการเปลี่ยนแปลงแต่ละครั้ง
เท่านั้นล่ะ เจอกันพรุ่งนี้
Marcus
