เปิด Claude Code ขึ้นมาทีไร ก็ต้องเล่าโครงสร้าง project ใหม่ตั้งแต่ต้น ว่าโฟลเดอร์ไหนทำอะไร ใช้ tech stack อะไร และกฎของทีมเป็นแบบไหน

สั่งงานไปแล้ว มันวิ่งไปคนละทางกับที่ต้องการ กว่าจะรู้ตัวก็เผา token ไปครึ่ง session

หรือสั่งทีเดียวหวังให้ได้งานเป๊ะ แต่งานที่ได้กลับมาอยู่แค่ราว 60% แล้วต้องมานั่งแก้รอบแล้วรอบเล่า

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

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

แผนที่ทริค Claude Code 3 ชั้น จากระดับเริ่มต้น ขยับให้ไว ไปจนถึงโหดขั้นสุด

ชั้นเริ่มต้น: ให้ Claude รู้จัก project โดยไม่ต้องเล่าใหม่

จุดเริ่มต้นของทุกอย่างคือไฟล์เดียว ชื่อ CLAUDE.md

เวลาเปิด project ที่มีไฟล์อยู่แล้ว สิ่งแรกที่ควรทำคือพิมพ์ /init ลงไป Claude Code จะสแกน code base แล้วสร้าง CLAUDE.md ขึ้นมาให้ ไฟล์นี้ทำหน้าที่เหมือนใบสรุปของ project รวมโครงสร้างสถาปัตยกรรม กฎการเขียนของทีม และไฟล์สำคัญไว้ในที่เดียว ผลลัพธ์คือไม่ต้องเล่า project ใหม่ทุก session เพราะ Claude อ่านไฟล์นี้แล้วรู้ทันทีว่ากำลังทำงานกับอะไรอยู่

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

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

อีกทางที่กำลังทยอยเปิดให้ใช้คือการสั่งงานด้วยเสียง ผ่านคำสั่ง /voice ที่เป็นของ Claude Code เอง พิมพ์ไม่ทันก็พูดใส่ terminal ได้เลย

บริบทคือพื้นที่จำกัด ใช้ให้คุ้ม

หัวใจของชั้นเริ่มต้นที่คนชอบมองข้าม คือการรักษาบริบทให้เล็กและสะอาด

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

ถ้าอยากรู้ว่าอะไรกินบริบทอยู่บ้าง ให้พิมพ์ /context มันจะแยกให้ดูเป็นเปอร์เซ็นต์ว่า ส่วนไหนเป็น system prompt ส่วนไหนเป็นเนื้อไฟล์ และส่วนไหนเป็น MCP server พอเห็นเป็นตัวเลขก็รู้ว่าตรงไหนบวม แล้วจัดระเบียบใหม่ได้ถูกจุด

พอบริบทขึ้นไปแตะราว 60% ให้พิมพ์ /compact Claude Code จะบีบอัดประวัติบทสนทนาให้สั้นลงเพื่อไปต่อได้โดยไม่ทิ้งของสำคัญ จุดที่หลายคนไม่รู้คือสั่ง /compact แบบเจาะจงได้ เช่น บอกให้ย่อทุกอย่าง แต่เก็บการตัดสินใจเรื่อง API กับ schema ของฐานข้อมูลไว้ ส่วนเวลาจะสลับไปทำงานคนละเรื่องที่ไม่ต้องใช้ประวัติเดิม ให้พิมพ์ /clear เพื่อล้างกระดานแล้วเริ่มบทสนทนาใหม่ ตรงนี้ไม่ใช่การเริ่มจากศูนย์ เพราะ CLAUDE.md และไฟล์อื่นๆ ยังอยู่ครบ

หลักการคุมบริบท ดูสัดส่วนด้วย slash context, บีบอัดที่ราว 60% ด้วย slash compact, และล้างกระดานเมื่อเปลี่ยนงานด้วย slash clear

สั่งให้น้อย ถามให้มาก

ทริคชุดถัดมาเปลี่ยนวิธีพูดคุยกับ Claude ตั้งแต่ต้น เพื่อตัดรอบแก้ที่ตามมาทีหลัง

เริ่มที่ plan mode เสมอ กด shift+tab เพื่อสลับโหมด พอ Claude อยู่ในโหมดนี้ มันจะอ่านและค้นได้ แต่จะไม่แตะไฟล์อะไรเลย มันจะร่างขั้นตอน ถามคำถามให้ชัด และวางแนวทางทั้งหมดก่อนเขียน code สักบรรทัด ถ้าพอใจแล้วค่อยออกจากโหมดแล้วสั่งให้ลงมือ แค่ขั้นตอนนี้ก็ช่วยลดจำนวนครั้งที่ต้องย้อนกลับมาแก้ได้มาก

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

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

ปิดท้ายชั้นเริ่มต้นด้วยทริคสำคัญข้อหนึ่ง คือฝังการตรวจงานเข้าไปในรายการสิ่งที่ต้องทำเลย เวลา Claude สร้างรายการ to-do ตอนเริ่มงาน ให้แทรกขั้นตอนตรวจสอบเข้าไปด้วย เช่น ถ้า to-do หนึ่งคือสร้างหน้าเว็บ to-do ถัดไปก็ให้เป็น "แคปหน้าจอแล้วเช็กว่าหน้าตาถูกต้องไหม" และอีกขั้นคือ "เปิด Chrome DevTools ดูว่ามี error อะไรหรือเปล่า" พอทำแบบนี้ Claude จะไม่ใช่แค่สร้างของแล้วโยนมาให้ตรวจ แต่มันจะสร้าง ตรวจเอง แก้เอง แล้วค่อยส่ง เสริมอีกประโยคได้ว่า "อย่าเพิ่งไป to-do ถัดไป จนกว่าจะมั่นใจ 95% ว่าอันนี้เรียบร้อยแล้ว" เพราะ AI ยิงทีเดียวให้ตรงเป๊ะได้ยาก สู้ให้มันยิงทีเดียวได้ 90% ดีกว่ายิงได้แค่ 60%

ชั้นขยับให้ไว: เลิกทำงานคนเดียว

พอคุมพื้นฐานได้แล้ว ชั้นถัดมาคือเปลี่ยนจากคุม Claude ตัวเดียว ไปเป็นคุมทีมและสะสมความรู้เอาไว้ใช้ซ้ำ

ทริคแรกของชั้นนี้คือ sub-agents (ตัวช่วยย่อยที่แตกออกไปทำงานเอง) เวลาเจอปัญหาซับซ้อน ลองสั่งใน prompt ให้ session หลักแตก sub-agents ออกไป แต่ละตัวจะมีบริบทเป็นของตัวเอง ใช้โมเดลของตัวเองได้ และทำงานขนานกัน ตัวหลักจึงยังสะอาด ขณะที่ตัวย่อยกระจายกันไปค้นข้อมูล เขียนเทส หรือทดลองหลายแนวทาง พอเสร็จก็รายงานกลับมาที่ตัวหลัก เหมือนมีทีมแทนที่จะมีลูกน้องแค่คนเดียว

จับคู่ sub-agents กับการเลือกโมเดลให้คุ้มได้ด้วย เช่นใช้ Haiku ซึ่งเป็นโมเดลที่ถูกกว่ากับ sub-agents ที่ทำงานง่ายหรืองานปริมาณมาก อาจให้มันไล่อ่านบทความเป็นร้อยๆ ชิ้น อ่าน token หลักแสน แล้วสรุปคีย์สำคัญกลับมาให้ตัวหลักไม่กี่บรรทัด ส่วนตัวหลักยังอยู่บน Opus ไม่มีเหตุผลที่จะเอาโมเดลหนักและแพงไปอ่าน token เป็นแสน ทั้งที่ต้องการแค่ข้อมูลไม่กี่จุด ถ้าจัดให้ถูก จะคุมค่าใช้จ่ายได้โดยไม่เสียคุณภาพในจุดสำคัญ

สอนมันครั้งเดียว ใช้ได้ทั้งทีม

ทริคที่ทำให้ความรู้ไม่หายไปกับ session คือ skills (ชุดความรู้แพ็คสำเร็จที่เรียกใช้ซ้ำได้)

ลองสร้างไฟล์ prompt ที่ใช้ซ้ำได้ไว้ในโฟลเดอร์ .claude/skills/ เช่น techdebt.md ที่บอก Claude ว่าจะสแกนหาหนี้ทางเทคนิคยังไง หรือ codereview.md ที่รู้ว่าจะรีวิว code base นี้แบบไหน จากนั้นแค่เรียก skill นั้นด้วยภาษาธรรมดา หรือใช้เป็น /command ตรงๆ มันก็จะรันกระบวนการเดิมทุกครั้ง ข้อดีคือ commit ขึ้น GitHub ได้ ทั้งทีมก็หยิบไปใช้ต่อได้ทันที เท่ากับเปลี่ยนขั้นตอนการทำงานมาตรฐานของทีมให้เป็นอัตโนมัติ

คู่กับ skills คือคอยอัปเดต CLAUDE.md อยู่เสมอ เจอแพตเทิร์นใหม่ เจอจุดที่เคยพลาด หรือมีกฎใหม่ของ project ก็บันทึกลงไป รอบหน้าที่เปิดขึ้นมา Claude จะรู้ทันที ช่วยกันไม่ให้พลาดซ้ำ และทำให้มันเข้าใจ project กับวิธีทำงานมากขึ้นเรื่อยๆ แต่มีข้อแม้สำคัญคืออย่าให้มันบวม เพราะ CLAUDE.md ทำหน้าที่คล้าย system prompt ที่โหลดเข้าไปในทุกบทสนทนา ทุกบรรทัดในนั้นกินบริบท แนวที่พอดีคือเก็บเฉพาะข้อมูลสำคัญที่สุด คุมไว้ราว 150 ถึง 200 บรรทัด ถ้าเริ่มยาวกว่านั้นก็ถึงเวลาตัดทอน

วิธีตัดทอนคือให้ CLAUDE.md ชี้ไปไฟล์อื่นแทน เนื้อหาที่ไม่ได้ใช้ทุกครั้ง เช่น คู่มือสไตล์ บริบทธุรกิจ หรือเอกสารอ้างอิง ให้แยกไปไฟล์ต่างหากแล้ววางลิงก์ไว้ใน CLAUDE.md Claude จะรู้ว่าต้องไปหาที่ไหนเวลาต้องใช้ โดยไม่ต้องแบกข้อมูลทั้งหมดไว้ใน system prompt ตลอดเวลา system prompt ไม่จำเป็นต้องรู้สถานะล่าสุดของทุก project แค่ต้องรู้ว่าจะไปหาข้อมูลนั้นได้ที่ไหน

พอเห็นว่าผิดทาง ให้รีบดึงกลับ

อีกชุดของชั้นนี้คือการคุมทิศทางให้ทันก่อนจะเสียบริบทไปเปล่าๆ

พอเห็นว่า Claude เริ่มวิ่งผิดทาง อย่ารอให้มันทำจนจบ กด escape แก้ทิศแล้วสั่งใหม่ทันที ทุก token ที่ใช้ไปกับทิศทางที่ผิดคือบริบทที่เสียเปล่า คุมให้แน่นและคุมให้ไว

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

ถ้าเลี้ยวผิดแล้วอยากย้อนเร็วๆ ใช้ /rewind ได้ Claude จะถอยกลับไปจุดก่อนหน้าในบทสนทนาโดยไม่ต้องเริ่มใหม่ทั้งหมด

ส่วนคนที่รันหลาย session พร้อมกัน ทริคที่ช่วยได้มากคือ hooks สำหรับแจ้งเตือน พิมพ์ /hooks หรือสั่งด้วยภาษาธรรมดาก็ได้ ตั้งให้มีเสียงเตือนเมื่อ session ทำงานเสร็จ ระหว่างนั้นจะได้ไปทำอย่างอื่นบนเครื่อง หรือเปิด Claude Code ทิ้งไว้พร้อมกันหลายสิบ session พอได้ยินเสียงก็รู้ว่า session หนึ่งเสร็จแล้วและรอ input อยู่

มันมองเห็น ใช้ข้อนี้ให้เต็มที่

ทริคที่ปลดล็อกงานฝั่งหน้าตาเว็บได้เยอะ คือการจำไว้ว่า Claude มองเห็นภาพได้จริง

ป้อนภาพ error ให้มันดูได้ ป้อนเว็บที่เป็นแรงบันดาลใจให้มันดูได้ และทำลูปตรวจงานตัวเองด้วยภาพได้ เช่น สั่งว่า "แคปหน้าจอเว็บ แล้วบอกหน่อยว่าเลย์เอาต์ดูถูกต้องไหม" มันจะแคปจริง วิเคราะห์ด้วยสายตา แล้วบอกว่าตรงไหนเพี้ยน เอาแนวคิดการตรวจงานตัวเองมารวมกับเรื่องนี้ได้เลย โดยให้มันออกแบบหน้าเว็บ แคปหน้าจอ ปรับแก้ แล้ววนแบบนี้สักสามรอบก่อนส่ง V1 ผลคือ V1 ที่ได้ดีกว่าการให้มันยิงรวดเดียวมาก

ขยับจากภาพนิ่งไปอีกขั้นคือ Chrome DevTools ที่ Claude เปิด browser ไปโต้ตอบกับแอปและตรวจการทำงานจริงได้ คล้ายลูปแคปหน้าจอ แต่เปลี่ยนจากเรื่องดีไซน์ไปเป็นการทำงานจริงของปุ่มและฟอร์ม ตรงนี้ช่วยงานฝั่งหน้าบ้านได้มาก และยังหมายความว่าตรงไหนที่ไม่มี API ให้เรียก มันเข้าไปกดและกรอกเองได้

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

ชั้นโหดขั้นสุด: รันทั้งกองทัพพร้อมกัน

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

เริ่มที่การรันหลาย session พร้อมกันด้วย git worktree ปกติ project จะอยู่ในโฟลเดอร์เดียวที่มีไฟล์ทั้งหมด ถ้าเปิดสอง session ในโฟลเดอร์เดียวกันพร้อมกัน งานอาจทับกันเอง git worktree แก้ปัญหานี้ได้ ให้คิดว่ามันคือสำเนา project แบบขนาน แต่ประหยัดกว่าการก๊อปทั้งโฟลเดอร์มาก พิมพ์ claude --worktree <ชื่อ feature> Claude จะสร้างพื้นที่ทำงานแยกบน branch ของตัวเอง เปิด terminal อีกบานแล้วพิมพ์แบบเดิมด้วยชื่อ feature ใหม่ ก็ได้อีก branch แยกออกมา รันพร้อมกันได้สามสี่ห้าตัวโดยไม่เหยียบงานกันเอง พอเสร็จก็สั่ง merge branch กลับเข้า project หลักเหมือน branch git ทั่วไป

การรันหลายงานขนานกัน sub-agents แตกจากตัวหลัก, git worktree แยก branch ต่อ session, และ agent teams ที่คุยกันเองได้

ตัดของที่กินบริบทโดยไม่จำเป็น

แกนเรื่องบริบทกลับมาอีกครั้งในชั้นนี้ แต่คราวนี้เป็นการตัดที่ต้นทาง

ทริคหนึ่งคือใช้ API endpoint แทน MCP server ในบางสถานการณ์ MCP server ดีตรงที่เห็นเครื่องมือทั้งหมดและใช้อันไหนก็ได้ แต่มันโหลดนิยามของเครื่องมือทั้งชุดเข้าไปในบริบท ถ้ากำลังประหยัด token อยู่ บางทีเรียก API endpoint ตรงๆ คุ้มกว่า เช่น ใช้ Notion แต่งานนี้ต้องอ่านฐานข้อมูลเดียว ก็ไม่จำเป็นต้องโชว์วิธีทำทุกฟังก์ชันให้ Claude ดู เขียน endpoint นั้นตายตัวลงไปเลย ก็ประหยัด token ไปได้มหาศาล

อีกทริคที่หลายคนคาดไม่ถึง คือถามข้อมูลโดยไม่ต้องเขียน SQL แค่เชื่อมเครื่องมือ CLI อย่าง bq ของ BigQuery เข้ากับ Claude Code แล้วถามเป็นภาษาคนได้เลย เช่น "ไตรมาสที่แล้วรายได้มาจากช่องทางไหนสูงสุด 10 อันดับ" Claude จะแปลงเป็น query ที่ถูกต้อง รันให้ แล้วตอบกลับมา โดยไม่ต้องเขียน SQL เอง และวิธีนี้ใช้ได้กับเครื่องมือ CLI ตัวอื่นๆ ด้วย

เมื่อเจอโจทย์ที่ต้องคิดหนักจริงๆ อย่างการตัดสินใจเรื่องสถาปัตยกรรม การ debug ที่ซับซ้อน การ refactor ก้อนใหญ่ หรือยิงไปสองสามรอบแล้วยังไม่ได้คำตอบที่ใช่ ให้ลองพิมพ์คำว่า ultrathink ลงไป Claude จะใช้โหมดคิดหนัก โดยมีงบสูงสุดราว 32,000 token ก่อนตอบ ของแบบนี้ไม่ควรเอามาใช้กับงานแก้เล็กๆ แต่ควรงัดออกมาใช้เมื่อกำลังตัดสินใจเรื่องที่กระทบทั้งระบบ

ปลอดภัยกว่าโดยไม่ช้าลง

ทริคที่ควรรู้ก่อนปล่อยให้ Claude ทำงานเองยาวๆ คือการตั้งสิทธิ์ให้ดี

หลายคนใช้ --dangerously-skip-permissions เพื่อให้ Claude รันได้โดยไม่ต้องขออนุมัติทุกขั้น วิธีนี้เร็วจริง แต่ชื่อมันก็บอกอยู่แล้วว่าอันตราย วิธีที่ฉลาดกว่าคือเข้าไปตั้งสิทธิ์ แล้วอนุญาตเฉพาะคำสั่งที่รู้ว่าปลอดภัยอย่างชัดเจน พร้อมปฏิเสธอะไรก็ตามที่ทำลายของได้ อย่างคำสั่งลบหรือ remove ผลที่ได้คือความเร็วและอิสระเท่ากับการข้ามสิทธิ์ทั้งหมด แต่ไม่อันตรายแบบนั้น และจุดสำคัญคือรายการปฏิเสธมาก่อนรายการอนุญาตเสมอ

ทิป: ตั้ง allow ให้คำสั่งที่ปลอดภัย และ deny ให้คำสั่งที่ทำลายของได้ จะได้ความเร็วเท่า --dangerously-skip-permissions โดยที่ deny มีสิทธิ์เหนือ allow เสมอ ปลอดภัยกว่าแบบไม่ต้องแลกความเร็ว

ขยับ Claude ออกจากโต๊ะทำงาน

อีกชุดของชั้นโหดคือการพา Claude Code ออกไปทำงานนอกเครื่องและนอกเวลานั่งเฝ้า

ทริคแรกคือรันบน VPS เพื่อให้ session ทำงานตลอดเวลา มันจะรันต่อแม้ปิดฝาแล็ปท็อปไปแล้ว เวลาจะคุยด้วยก็ SSH เข้าไป หรือสั่งผ่าน Telegram ก็ได้ เหมาะกับงานที่รันยาวๆ และไม่อยากนั่งเฝ้า terminal บนเครื่อง

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

ส่วนงานที่ต้องทำซ้ำเป็นรอบ ใช้ /loop ได้ เช่น พิมพ์ว่า "ทุก 5 นาที เช็กสถานะการ deploy ให้หน่อย" Claude จะรันคำสั่งนั้นซ้ำใน session เดิมทุก 5 นาที จนกว่าจะปิด session ตั้งให้คอยดู PR ดู error log หรือดึง build มาดูก็ได้ มันรันอยู่เบื้องหลัง แล้วค่อยมาสะกิดเมื่อมีอะไรที่ต้องตัดสินใจ จะตั้งเป็นการเตือนครั้งเดียวด้วยภาษาธรรมดาก็ได้ ข้อจำกัดที่ควรรู้คือ /loop อยู่ได้ราว 3 วัน ถ้าต้องการงานอัตโนมัติที่ยาวกว่านั้น ต้องไปใช้ scheduled task บน desktop แทน แต่ต่างกันตรงที่ทุกครั้งที่งานนั้นเด้งขึ้นมา มันเป็น session ใหม่ที่ไม่มีความจำของบริบทเดิม

จากทีมเดี่ยว สู่ทีมที่คุยกันเอง

ทริคที่ต่อยอดจาก sub-agents คือ agent teams (ทีมตัวช่วยที่คุยกันเองได้)

sub-agents รันขนานกันได้และมีบริบทใหม่ของตัวเอง แต่คุยกันเองไม่ได้ ส่วน agent teams เป็นแบบนั้น แต่ตัวช่วยทุกตัวคุยกันได้ ใช้รายการงานร่วมกัน สื่อสารกันเอง และมอบหมายงานให้กันได้ ทั้งยังคุยกับตัวช่วยแต่ละตัวได้ตรงๆ แทนที่จะต้องผ่านตัวหลักอย่างเดียว ของแบบนี้แพงกว่าและรันนานกว่า แต่ให้ผลลัพธ์ที่เข้ากันเป็นเนื้อเดียวมากกว่าสำหรับ project ใหญ่

ปิดท้ายด้วยทริคที่แก้ปัญหาเรื้อรังของ AI กับ code ได้ตรงจุด คือ Context7 MCP ติดตั้ง Context7 เป็น MCP server แล้วเวลาต้องการข้อมูลจากเอกสารปัจจุบัน ก็สั่งให้เรียกใช้ได้เลย ปัญหาที่มันแก้คือข้อมูลที่ Claude เรียนมามีจุดตัด ทำให้บางทีมันแนะนำฟังก์ชันหรือ API ที่ถูกเปลี่ยนชื่อ ถูกเลิกใช้ หรือไม่มีอยู่จริงแล้ว Context7 ดึงเอกสารทางเทคนิคที่ตรงกับเวอร์ชันจริง พร้อมตัวอย่าง code สดๆ จากไลบรารียอดนิยมจำนวนมาก แล้วฉีดเข้าไปในบทสนทนาก่อนที่ Claude จะเริ่มเขียน code ติดตั้งครั้งเดียว coding agent ทุกตัวก็ทำงานบนข้อมูลที่ทันสมัยขึ้น

เส้นเดียวที่ร้อยทริคทั้งหมดเข้าด้วยกัน

อ่านมาถึงตรงนี้แล้วจะเห็นว่า ทริคทั้งหมดไม่ได้กระจัดกระจาย แต่วนอยู่กับสามเรื่องเดียว

การคุมบริบทให้สะอาดผ่าน /init, /context, /compact, การให้ CLAUDE.md ชี้ไปไฟล์อื่น และการเลือก API endpoint แทน MCP ล้วนเป็นเรื่องเดียวกัน คือไม่ปล่อยให้ของรกมาเบียดพื้นที่คิดของ Claude

การให้มันเช็กงานตัวเองผ่าน plan mode, การฝังขั้นตอนตรวจสอบลงใน to-do, ลูปแคปหน้าจอ และ Context7 ล้วนเป็นการบังคับให้มันยืนยันก่อนว่าถูก แทนที่จะเดาแล้วส่งมาให้แก้

การรันหลายอย่างขนานกันด้วย sub-agents, git worktree และ agent teams คือการเลิกคิดว่าต้องคุมทีละตัว แล้วขยับมาคุมทั้งทีม

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

ไม่ต้องทำครบ 32 ข้อในวันเดียว เริ่มจาก /init กับ plan mode วันนี้ก่อน แล้วค่อยไต่ขึ้นไปทีละชั้น ยิ่ง Claude Code ทำงานได้เร็วเท่าไร คนที่คุมบริบทเป็นและให้มันตรวจงานตัวเองเป็น ยิ่งได้เปรียบมากขึ้นเท่านั้น