ผมอ่านซอร์สโค้ดของ Claude Code มาให้แล้ว คุณจะได้ไม่ต้องเสียเวลาอ่านเอง

คนส่วนใหญ่เปิด Claude Code พิมพ์ prompt รอคำตอบ แล้วก็พิมพ์ prompt อีก

นั่นก็เหมือนกับการซื้อ Ferrari แต่ขับแค่เกียร์หนึ่ง

ผมอยากรู้ว่าทำไมบางคนถึงใช้ Claude Code ได้ดีกว่าคนอื่นเป็น 10 เท่า เลยทำในสิ่งที่คนมีเหตุผลทุกคนควรทำ: อ่าน source code ทั้งหมด (พอพูดว่าผม ก็หมายถึง Claude Code แน่นอน)

11 ชั้นของสถาปัตยกรรม เป็นพันๆ บรรทัด แพลตฟอร์ม orchestration สำหรับ agent ที่ปลอมตัวมาเป็นแชทใน terminal

นี่คือสิ่งที่ source code เผยให้เห็นเกี่ยวกับวิธีใช้เจ้านี่จริงๆ

1. CLAUDE.md ถูกโหลดทุกครั้ง ทุก. รอบ. ทุก. รอบ

นี่คือสิ่งที่ให้ผลตอบแทนสูงที่สุดที่คุณทำได้ และแทบไม่มีใครทำถูกต้อง

คนส่วนใหญ่ไม่มีอะไรในไฟล์ CLAUDE.md หรือไม่ก็เขียนพระคัมภีร์ทั้งเล่มลงไป

source code แสดงให้เห็นว่า Claude Code อ่านไฟล์ CLAUDE.md ของคุณทุกครั้งที่มีการ query ไม่ใช่แค่ตอนเริ่ม session ทุกครั้งที่คุณส่งข้อความ มันจะอ่านคำสั่งของคุณใหม่

มีลำดับชั้นทั้งหมด:

• ~/.claude/CLAUDE.md — ระดับโลก (สไตล์การเขียนโค้ด ความชอบของคุณ)

• ./CLAUDE.md — ระดับโปรเจกต์ (การตัดสินใจด้านสถาปัตยกรรม ข้อตกลงร่วมกัน)

• .claude/rules/*.md — กฎแบบโมดูลาร์

• CLAUDE.local.md — โน้ตส่วนตัว (ถูก gitignore)

คุณมีพื้นที่ 40,000 ตัวอักษร ซึ่งเยอะมาก คนส่วนใหญ่ใช้แค่ประมาณ 200

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

ถ้าคุณจะทำสิ่งเดียวหลังจากอ่านนี่ ก็คือสิ่งนี้

2. Subagent แชร์ prompt cache (การทำงานแบบขนานแทบจะฟรี)

นี่คือสิ่งที่ทำให้ผมตะลึง

เมื่อ Claude Code fork subagent มันจะสร้างสำเนาที่เหมือนกันทุกประการของ parent context API จะ cache สิ่งนี้ไว้ ดังนั้นการสร้าง 5 agent เพื่อทำงานในส่วนต่างๆ ของ codebase คุณ จึงมีค่าใช้จ่ายแทบไม่ต่างจาก 1 agent ที่ทำงานตามลำดับ

อ่านอีกครั้ง

5 agent ราคาเท่ากับ 1 agent เพราะพวกมันทั้งหมดใช้ prompt cache เดียวกัน

คนส่วนใหญ่ใช้ Claude Code เหมือนคนงานคนเดียว ทำงานทีละอย่าง รอให้เสร็จ แล้วค่อยให้งานต่อไป

source code มี execution model สำหรับ subagent ถึงสามแบบ:

• fork — สืบทอด parent context, ปรับ cache ให้เหมาะสม

• teammate — แผงแยกใน tmux หรือ iTerm, สื่อสารผ่านเมลบ็อกซ์บนไฟล์

• worktree — มี git worktree ของตัวเอง, branch แยกต่อ agent

คุณสามารถบอกให้ Claude Code สร้าง 5 agent: คนหนึ่งตรวจสอบความปลอดภัย คนหนึ่ง refactor โมดูล auth คนหนึ่งเขียน test คนหนึ่งอัปเดตเอกสาร คนหนึ่งแก้บั๊ก ทั้งหมดพร้อมกัน แชร์ cache เดียวกัน

สถาปัตยกรรมถูกสร้างมาเพื่อสิ่งนี้ การใช้แบบเธรดเดียวนี่มันอาชญากรรม

3. ระบบสิทธิ์ถูกออกแบบมาให้กำหนดค่า ไม่ใช่คลิกผ่าน

ทุกครั้งที่ Claude Code ถาม "อนุญาตการกระทำนี้?" และคุณคลิกใช่ นั่นคือความล้มเหลวของการกำหนดค่า ไม่ใช่ฟีเจอร์

source code เผยให้เห็นการตั้งค่าแบบ 5 ระดับ:

1policy > flag > local > project > user

ใน ~/.claude/settings.json คุณสามารถตั้งค่ารูปแบบ glob สำหรับสิ่งที่อนุญาตเสมอ:

1{
2  "permissions": {
3    "allow": [
4      "Bash(npm *)",
5      "Bash(git *)",
6      "Edit(src/**)",
7      "Write(src/**)"
8    ]
9  }
10}

มีโหมดสิทธิ์สามแบบ:

• bypass — ไม่มีการตรวจสอบสิทธิ์เลย (อันตรายแต่เร็ว)

• allowEdits — อนุญาตการแก้ไขไฟล์ใน working directory โดยอัตโนมัติ

• auto (อันนี้ใหม่) — ใช้ LLM classifier ในการกระทำแต่ละครั้ง นี่คือจุดที่ลงตัวที่สุด

โหมด auto มีรายการอนุญาต/ปฏิเสธของตัวเองที่คุณสามารถกำหนดค่าได้ source code แสดงให้เห็นว่ามันทำงาน resolver หลายตัวแบบขนาน: การคลิกของผู้ใช้, hook classifier, bridge และตัวที่ตอบกลับก่อนจะเป็นผู้ชนะ

ทุกครั้งที่คุณหยุดเพื่อคลิก "allow" คือเวลาที่เสียไป กำหนดค่าครั้งเดียว ไม่ต้องคลิกอีกเลย

4. มีกลยุทธ์การบีบอัด 5 แบบ ปริมาณ context เป็นปัญหาจริง

source code มีห้าวิธีที่แตกต่างกันในการบีบอัดการสนทนาของคุณเมื่อมันยาวเกินไป:

1. microcompact — การลบผลลัพธ์เครื่องมือเก่าตามเวลา

1. context collapse — สรุปช่วงของการสนทนา

1. session memory — ดึง context ที่สำคัญไปไว้ในไฟล์

1. full compact — สรุปประวัติทั้งหมด

1. PTL truncation — ลบกลุ่มข้อความที่เก่าที่สุด

สิ่งนี้บอกอะไรที่สำคัญ: context overflow เป็นปัญหาสำคัญที่วิศวกรใช้เวลาจำนวนมากในการแก้ไข

สิ่งที่หมายถึงสำหรับคุณ:

• ใช้ /compact อย่างจริงจัง อย่ารอให้ระบบบีบอัดอัตโนมัติแล้วสูญเสีย context ที่คุณใส่ใจ

• หน้าต่างเริ่มต้นคือ 200K tokens แต่คุณสามารถเลือกใช้ 1M tokens ได้โดยใช้ส่วนต่อท้ายโมเดล [1m] สำหรับการ refactor ครั้งใหญ่ในหลายไฟล์ สิ่งนี้สำคัญ

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

• ผลลัพธ์เครื่องมือขนาดใหญ่จะถูกเก็บไว้ในดิสก์ โดยส่งเฉพาะตัวอย่าง 8KB ไปยังโมเดล ถ้าคุณวางไฟล์ขนาดใหญ่ โมเดลอาจเห็นเพียงเศษเสี้ยว ให้เก็บอินพุตให้ตรงประเด็น

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

5. ระบบ Hook คือ API ส่วนขยายที่แท้จริง (เหตุการณ์ในวงจรชีวิต 25+ รายการ)

นี่คือฟีเจอร์สำหรับผู้ใช้ระดับสูงที่แทบไม่มีใครรู้

source code เผยให้เห็นเหตุการณ์ในวงจรชีวิตมากกว่า 25 รายการที่คุณสามารถ hook เข้าไปได้:

• PreToolUse — ทำงานก่อนที่เครื่องมือใดจะทำงาน

• PostToolUse — ทำงานหลังจากที่เครื่องมือใดทำงาน

• UserPromptSubmit — ทำงานเมื่อคุณส่งข้อความ

• SessionStart / SessionEnd — วงจรชีวิตของเซสชัน

• และอีก 20+ รายการ

พร้อม hook 5 ประเภท:

• command — รันคำสั่ง shell

• prompt — แทรก context ผ่าน LLM

• agent — รันลูปการตรวจสอบ agent แบบเต็มรูปแบบ

• HTTP — เรียก webhook

• function — รัน JS

ตัวอย่างจริงของสิ่งที่คุณทำได้:

• รัน linting อัตโนมัติก่อนเขียนไฟล์ทุกครั้ง

• รัน test หลังการแก้ไขทุกครั้ง

• แทรกเอกสารที่เกี่ยวข้องลงในทุก prompt โดยอัตโนมัติ

• ส่งการแจ้งเตือน Slack เมื่องานเสร็จ

• ตรวจสอบว่ารูปแบบความปลอดภัยถูกปฏิบัติตามก่อนที่โค้ดจะถูกส่ง

hook UserPromptSubmit นั้นบ้ามาก คุณสามารถแทรก additionalContext ลงในทุกข้อความที่คุณส่ง ลองนึกภาพการแนบผลลัพธ์การทดสอบ git diff ล่าสุด หรือสถานะโปรเจกต์ลงในทุก prompt โดยไม่ต้องพิมพ์

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

6. เซสชันคงอยู่และสามารถกลับมาใช้ต่อได้ (หยุดเริ่มต้นใหม่)

ทุกการสนทนาจะถูกบันทึกเป็น JSONL ที่

1~/.claude/projects/{hash}/{sessionId}.jsonl

source code รองรับ:

• --continue — กลับมาใช้เซสชันล่าสุดต่อ

• --resume — เลือกเซสชันที่ผ่านมาโดยเฉพาะ

• --fork-session — แยกจากบทสนทนาที่ผ่านมา (ผมชอบอันนี้เป็นการส่วนตัว)

การดึง session memory จะรักษา context ที่สำคัญไว้ตลอดการบีบอัด: ข้อกำหนดงาน รายการไฟล์ สถานะเวิร์กโฟลว์ ข้อผิดพลาด และสิ่งที่ได้เรียนรู้

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

ใช้ --continue เสมอ ปล่อยให้ context สะสม ปล่อยให้ session memory สร้างการเรียนรู้เมื่อเวลาผ่านไป source code มีโครงสร้างพื้นฐานสำหรับสิ่งนี้ ใช้มัน

7. ระบบเครื่องมือรันเครื่องมือ 60+ ตัวด้วยการจัดกลุ่มอัจฉริยะ

Claude Code มีเครื่องมือในตัวมากกว่า 60 ตัว แต่สิ่งที่น่าสนใจคือวิธีการรันมัน

source code แบ่งการเรียกใช้เครื่องมือออกเป็นสองประเภท:

• concurrent — การดำเนินการแบบอ่านอย่างเดียว (อ่านไฟล์ ค้นหา glob) รันแบบขนาน

• serial — การดำเนินการที่เปลี่ยนแปลง (แก้ไข เขียน คำสั่ง bash) รันทีละรายการ

ซึ่งหมายความว่าเมื่อ Claude Code ต้องอ่าน 10 ไฟล์เพื่อทำความเข้าใจ codebase ของคุณ มันจะอ่านทั้งหมด 10 ไฟล์พร้อมกัน แต่เมื่อต้องแก้ไข 3 ไฟล์ มันจะทำทีละไฟล์เพื่อหลีกเลี่ยงความขัดแย้ง

นอกเหนือจากเครื่องมือในตัว คุณสามารถเชื่อมต่อ MCP servers ที่เพิ่มเครื่องมือมากขึ้น source code ใช้ deferred loading เครื่องมือ MCP จะโหลดเมื่อจำเป็นเท่านั้น ดังนั้นการเชื่อมต่อ MCP server 5 ตัวจะไม่ทำให้ทุกคำขอช้าลง

และมี ToolSearch สำหรับการค้นหาเครื่องมือที่ agent ยังไม่รู้จักแบบ deferred

ข้อสรุปเชิงปฏิบัติ: ถ้าเวิร์กโฟลว์ของคุณเกี่ยวข้องกับระบบภายนอก (ฐานข้อมูล ผู้ให้บริการคลาวด์ CI/CD) ให้เชื่อมต่อ MCP servers สำหรับพวกมัน สถาปัตยกรรมจัดการความซับซ้อน คุณแค่ได้รับความสามารถมากขึ้น

8. สถาปัตยกรรมสตรีมมิ่งหมายความว่าการขัดจังหวะมีต้นทุนต่ำ

ไปป์ไลน์ทั้งหมดใช้ async generators ที่ส่งเหตุการณ์แต่ละรายการ การกด Escape จะยกเลิกสตรีมปัจจุบันอย่างสะอาดโดยไม่สูญเสีย context ก่อนหน้า

สิ่งนี้ดูเล็กน้อยแต่มันเปลี่ยนวิธีที่คุณควรใช้ Claude Code

อย่ารอคำตอบที่คุณรู้ว่ากำลังผิดทาง ขัดจังหวะทันทีและเปลี่ยนเส้นทาง source code ถูกออกแบบมาเพื่อสิ่งนี้ context ก่อนหน้าของคุณถูกเก็บไว้ คำตอบที่ถูกขัดจังหวะจะถูกทิ้งอย่างสะอาด ไม่มีบทลงโทษ

คิดว่ามันเหมือนการ pair programming ถ้าคู่ของคุณเริ่มเดินผิดทาง คุณไม่รอให้พวกเขาทำเสร็จ คุณพูดว่า "จริงๆ แล้ว ไปทางนี้แทน" พลังงานเดียวกัน

9. ระบบลองใหม่ซับซ้อนกว่าที่คุณคิด

source code เผยให้เห็น:

• ลองใหม่ 10 ครั้งพร้อม exponential backoff และ jitter (ฐาน 500ms)

• การรีเฟรช OAuth token อัตโนมัติเมื่อได้รับ 401/403

• การสำรองโมเดล: ถ้า Opus ล้มเหลว 3 ครั้งด้วยข้อผิดพลาด 529 มันจะสำรองไปใช้ Sonnet โดยอัตโนมัติ

• ตัวเฝ้าระวังสตรีม 90 วินาที — ถ้าการสตรีมหยุดนิ่ง มันจะกลับไปใช้แบบไม่สตรีม

• โหมดถาวรมีการลองใหม่ไม่จำกัด โดยมี backoff สูงสุด 5 นาที

ซึ่งหมายความว่า Claude Code ถูกออกแบบมาให้รันทิ้งไว้ มันจัดการปัญหา API, การจำกัดอัตรา และการหยุดทำงานได้อย่างดี คุณไม่ต้องคอยดูแลมัน ปล่อยให้มันรันในพื้นหลังแล้วกลับมาดูผลลัพธ์

สรุป: การกระทำที่ให้ผลตอบแทนสูงสุดจาก source code:

• เขียน CLAUDE.md จริง → โหลดทุกครั้ง 40K ตัวอักษร การกำหนดค่าที่ให้ผลตอบแทนสูงสุด

• ทำขนานกับ subagents → โมเดล fork แชร์ prompt cache 5 agent ≈ ราคา 1 agent

• กำหนดค่าสิทธิ์ใน settings.json → กำจัดความเหนื่อยล้าจากการคลิกตลอดไป

• ใช้ /compact อย่างจริงจัง → มี 5 กลยุทธ์การบีบอัดเพราะ context pressure เป็นเรื่องจริง

• ตั้งค่า hooks → 25+ เหตุการณ์ 5 ประเภท นี่คือ API ส่วนขยายที่แท้จริง

• ใช้ --continue เสมอ → JSONL persistence + session memory = context ที่สะสม

• เชื่อมต่อ MCP servers → deferred loading หมายถึงไม่มีต้นทุนจนกว่าจะใช้

• ขัดจังหวะอย่างอิสระ → async generators หมายถึงไม่มีบทลงโทษสำหรับการเปลี่ยนเส้นทาง

บรรทัดล่าง: Claude Code คือแพลตฟอร์ม orchestration สำหรับ agent ที่สวม UI ของ terminal

คนที่ได้ผลลัพธ์ 10 เท่าจากมันไม่ใช่คนที่ prompt เก่งกว่า พวกเขากำหนดค่ามัน ทำให้มันทำงานขนานกัน เชื่อมต่อกับมัน ปล่อยให้ context สะสมข้ามเซสชัน

source code ทำให้สิ่งนี้ชัดเจน ตอนนี้คุณรู้แล้วว่ามันทำอะไรภายใต้ฝาครอบ

กด RT ถ้าคุณพบว่าสิ่งนี้มีประโยชน์ 🫶