ทีม Agent ของ Claude Code: อนาคตของการพัฒนาซอฟต์แวร์ที่มี AI ช่วย

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

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

บทความนี้จะอธิบายการทำงานของทีม Agent บทบาทของแต่ละบทบาทเฉพาะทาง และวิธีประสานงานพวกเขาในโปรเจกต์ซอฟต์แวร์จริง

เพิ่งรู้จัก Claude Code? ปรับพื้นฐานให้แน่นในบ่ายเดียวด้วยคอร์ส Claude Code 101ของเรา

Claude Code Agent Teams คืออะไร?

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

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

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

ในทางปฏิบัติ นั่นหมายความว่าคุณไม่ต้องทำหน้าที่เป็นตัวกลางระหว่างเซสชันอีกต่อไป ทีมจะประสานเอง คุณเพียงเข้ามากำหนดทิศทางและตรวจผลลัพธ์

เหตุผลที่มีทีม Agent

เซสชัน Claude Code เดียวทำงานได้ดีจนกระทั่งโปรเจกต์ใหญ่เกินไป

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

มีสามสถานการณ์ที่เห็นได้ชัด:

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

คำตอบเหมือนที่ทีมมนุษย์ค้นพบมาหลายทศวรรษ: แบ่งงาน

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

แนวคิดเดียวกันใช้กับงานค้นคว้าได้ดี งานที่มีสมมติฐานแข่งกันสามแบบจะเร็วกว่าเมื่อมีเพื่อนร่วมทีมสามคนศึกษาคนละทฤษฎีแบบขนานแล้วค่อยมาสรุป แทนการให้หนึ่งเซสชันวิเคราะห์ทีละแบบตามลำดับ

ความเชี่ยวชาญเฉพาะด้านให้ความลึก ส่วนการขนานให้ความเร็ว เมื่อรวมกันจะทำให้งานที่เซสชันเดียวอาจเพี้ยนหรือใช้เวลานานเกินไป กลายเป็นงานที่ทำได้จริง

ทีม Agent ของ Claude Code ทำงานอย่างไร

หนึ่งเซสชันของทีมจะเดินตามห้าช่วงขั้นตอน โดยมีการออร์เคสเตรตภายใน Claude Code เอง

• กำหนดเป้าหมาย: อธิบายสิ่งที่ต้องการด้วยภาษาธรรมดา แบบที่บรีฟวิศวกรจูเนียร์ หัวหน้าทีมจะอ่านและตัดสินใจว่าจะย่อยงานอย่างไร
• มอบหมายงาน: หัวหน้าสร้างรายการงานร่วมกันและเปิดตัวเพื่อนร่วมทีม โดยกำหนดชื่อ บทบาท และพรอมต์ตั้งต้น สามารถระบุโครงสร้างทีมเองหรือปล่อยให้หัวหน้าจัดการ
• ดำเนินการแบบขนาน: เพื่อนร่วมทีมแต่ละคนจะรับงาน ทำเครื่องหมายว่ากำลังดำเนินการ เสร็จงาน และทำเครื่องหมายว่างานเสร็จ ระบบจัดการลำดับพึ่งพาอัตโนมัติ ล็อกไฟล์ป้องกันชนกัน เพื่อนร่วมทีมส่งข้อความหากันได้โดยตรง ไม่ต้องผ่านหัวหน้า
• รวมผลลัพธ์: หัวหน้ารวบรวมงานที่เสร็จ แก้ความขัดแย้ง และผลิตผลลัพธ์ชิ้นเดียว เช่น PR รายงาน โมดูลที่รีแฟกเตอร์ หรือสิ่งที่เป้าหมายกำหนด
• ทบทวนผลลัพธ์: ตรวจผลงานสุดท้ายเหมือนตรวจ pull request: อ่าน diff รันโค้ด ตรวจเทสต์

บทบาทเฉพาะทางของทีม Agent

บทบาททำให้ทีมเอเจนต์มีรูปร่างชัดเจน มิฉะนั้นจะลงเอยด้วยเซสชันทั่วไปที่ทำงานซ้ำซ้อนกัน Claude Code ไม่มีรายการบทบาทตายตัว — คุณกำหนดบทบาทในบรีฟหรือชี้หัวหน้าไปยังไฟล์กำหนด subagent ที่บันทึกไว้ใต้ .claude/agents/

Planning Agent

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

ในทางปฏิบัติ หัวหน้าทีมมักสวมบทบาทนี้เอง หรือจะรันเพื่อนร่วมทีมสำหรับวางแผนโดยเฉพาะเมื่อขนาดงานมากพอก็ได้

Coding Agent

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

เอเจนต์โค้ดทำงานได้ดีกับโมเดลที่ถูกกว่า ผู้ใช้งานจำนวนมากรันหัวหน้าบน Opus และเพื่อนร่วมทีมบน Sonnet เพราะการลงมือทำไม่ต้องใช้การให้เหตุผลลึกเท่าการประสานงาน

Testing Agent

เอเจนต์ทดสอบเขียนและรันเทสต์ สามารถทำงานอิงตามสัญญา API ที่ตกลงกันไว้ ขณะที่เพื่อนร่วมทีมฝั่งโค้ดยังสร้างเอ็นด์พอยต์อยู่ ดังนั้นเมื่อโค้ดเสร็จ เทสต์ก็พร้อมรันทันที

ยังสามารถให้เพื่อนร่วมทีมสำหรับทดสอบรันตลอดทั้งเซสชัน เพื่อรันชุดเทสต์ใหม่ทุกครั้งที่เอเจนต์โค้ดทำงานเสร็จหนึ่งงาน

Review Agent

เอเจนต์รีวิวอ่าน diff และตั้งธงบั๊ก ประเด็นสไตล์ เคสขอบ และปัญหาด้านความปลอดภัย การแยกรีวิวเป็นสองเพื่อนร่วมทีมที่มีเลนส์ต่างกัน — คนหนึ่งด้านความปลอดภัย อีกคนด้านประสิทธิภาพ — ได้ผลดีมาก โดยหัวหน้าจะรวมข้อค้นพบของพวกเขา

หากได้เขียนไฟล์กำหนด subagent สำหรับโปรเจกต์ไว้แล้ว เพื่อนร่วมทีมนั้นจะรับมอบเครื่องมือและ system prompt ของมันโดยอัตโนมัติ

Documentation Agent

เอเจนต์เอกสารเขียน docstring อัปเดต README และเอกสารแบบยาว เช่น บันทึกสถาปัตยกรรมหรืออ้างอิง API มักเหมาะจะรันเป็นคนสุดท้าย — เมื่อโค้ดและเทสต์เสร็จ รูปร่างสุดท้ายของงานชัดเจนแล้ว

เหตุใดความเชี่ยวชาญเฉพาะทางจึงให้ผลลัพธ์ที่ดีกว่า

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

การพัฒนาแบบขนานด้วยทีม Agent

การขนานคือหัวใจของทีมเอเจนต์

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

ต่อไปนี้คือสามชุดงานที่ทำแบบขนานได้ดีเป็นพิเศษ

• ฟรอนต์เอนด์และแบ็กเอนด์แบบขนาน: เมื่อสร้างฟีเจอร์ที่ใช้ทั้งสองเลเยอร์ เพื่อนร่วมทีมฝั่งแบ็กเอนด์สามารถสร้างเอ็นด์พอยต์ API ระหว่างที่ฝั่งฟรอนต์เอนด์สร้างคอมโพเนนต์ที่เรียกใช้ สื่อสารกันผ่านข้อความโดยตรง ทันทีที่ฝั่งแบ็กเอนด์กำหนดรูปแบบการตอบกลับ ก็ส่งให้ฝั่งฟรอนต์เอนด์ แล้วทั้งคู่เดินหน้าต่อโดยไม่ต้องรอให้อีกฝ่ายเสร็จทั้งหมด
• อิมพลีเมนต์และทดสอบแบบขนาน: เพื่อนร่วมทีมฝั่งโค้ดเขียนอิมพลีเมนเตชัน ขณะที่เพื่อนร่วมทีมฝั่งทดสอบเขียนเทสต์ตามสัญญาที่ตกลง เมื่อฝั่งโค้ดทำงานเสร็จ เทสต์ก็พร้อมรันทันที เร็วกว่าลำดับปกติที่มักเขียนโค้ดก่อนแล้วค่อยเติมเทสต์ท้ายสุด
• เอกสารและรีวิวโค้ดแบบขนาน: เมื่อเพื่อนร่วมทีมฝั่งโค้ดจบงานส่วนหนึ่ง เพื่อนร่วมทีมเอกสารเริ่มเขียน docstring และอัปเดต README ได้ ขณะเดียวกันเพื่อนร่วมทีมรีวิวอ่าน diff หาเบาะแสบั๊กและปัญหาสไตล์ ทั้งสองไม่บล็อกกัน และทั้งคู่ส่งผลลัพธ์ให้หัวหน้ารวม

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

ทีม Agent ของ Claude Code สำหรับโค้ดเบสขนาดใหญ่

โค้ดเบสขนาดใหญ่คือกรณีที่ทีมเอเจนต์เป็นสิ่งจำเป็นมากกว่าจะเป็นของแถม

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

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

สิ่งนี้สำคัญที่สุดในสามสถานการณ์ต่อไปนี้:

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

แต่มันก็มีต้นทุน

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

ยิ่งโปรเจกต์ใหญ่ ยิ่งได้ประโยชน์จากทีม Agent แต่อย่าใช้เกินจำเป็น — สำหรับบั๊กเล็ก ๆ เซสชันเดียวถูกกว่าและมีประสิทธิภาพพอ ๆ กัน

ทีม Agent และ Claude Tag

ทีมเอเจนต์ไม่ใช่ที่เดียวที่ Anthropic คิดใหม่ว่า AI จะเข้ากับเวิร์กโฟลว์ทีมได้อย่างไร

Claude Tag เป็นฟีเจอร์แยกต่างหากที่พา Claude เข้าไปใน Slack ในฐานะผู้เข้าร่วมเชิงองค์กรที่ใช้ร่วมกัน คุณแท็ก @Claude ในช่อง แล้ว Claude จะรับงานโดยใช้เครื่องมือขององค์กรคุณและบริบทร่วมของช่องนั้น มันจดจำสิ่งที่ถูกพูดคุย ติดตามงานเอง และทำงานภายใต้อัตลักษณ์ขององค์กรคุณ

ทั้งสองฟีเจอร์แก้ปัญหาการประสานงานคนละแบบ ทีมเอเจนต์ประสานหลายเซสชัน Claude Code บนเครื่องนักพัฒนาคนเดียวเพื่อภารกิจที่โฟกัสอย่างหนึ่ง ส่วน Claude Tag ประสานอัตลักษณ์ Claude เดียวกับทีมมนุษย์ใน Slack ตลอดหลายวันหรือหลายสัปดาห์ แต่มุ่งไปในทิศเดียวกัน: AI กำลังขยับจากเครื่องมือที่คนคนเดียวใช้ลำพัง มาเป็นผู้เล่นที่ทำงานในเวิร์กโฟลว์ของทีม

สิ่งนี้เปลี่ยนความสามารถที่ AI ต้องเก่ง

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

แนวปฏิบัติที่ดีที่สุดในการสร้างทีม Agent

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

นี่คือแนวทางที่ควรทำ:

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

• แยกงานก่อนค่อยขนาน: วางแผนก่อน แล้วค่อยขนาน รันขั้นตอนการวางแผนเพื่อแตกงานเป็นงานย่อยที่มีอินพุต เอาต์พุต และการพึ่งพาชัดเจน จากนั้นค่อยส่งแผนให้ทีมปฏิบัติ แผนใช้โทเค็นไม่กี่พัน แต่ทีมที่เดินผิดทิศอาจใช้หลายแสน

• แชร์มาตรฐานผ่าน CLAUDE.md: ทุกเพื่อนร่วมทีมจะอ่านไฟล์ CLAUDE.md ในไดเรกทอรีทำงานเมื่อเริ่ม ทำให้ใส่ข้อกำหนดร่วมได้ที่นั่น รวมถึงสไตล์โค้ด โครงสร้างไฟล์ แนวทางทดสอบ และรูปแบบข้อความคอมมิต

• ฝังคิวรีวิวไว้ในแผน: ตรวจความคืบหน้าของเพื่อนร่วมทีม เปลี่ยนทิศทางคนที่เริ่มหลุด และตรวจงานหัวหน้าก่อนรับเข้า สำหรับงานเสี่ยง ให้บังคับอนุมัติแผนก่อนลงมือเปลี่ยน นี่จะบังคับให้เพื่อนร่วมทีมแสดงแผนก่อนและรอหัวหน้าอนุมัติ

• จำกัดขนาดทีม: เริ่มที่สามถึงห้าคนสำหรับเวิร์กโฟลว์ส่วนใหญ่ เกินกว่านั้น ภาระประสานงานจะโตเร็วกว่าความเร็วจากการขนาน

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

• อนุมัติล่วงหน้าสำหรับงานประจำ: พรอมต์ขอสิทธิจากเพื่อนร่วมทีมจะส่งขึ้นมาที่หัวหน้า ทีมสี่คนอาจสร้างพรอมต์สี่เท่า กำหนดรายการ permissions.allow ไว้ก่อนสปอว์นทีม เพื่อให้งานประจำ เช่น อ่านไฟล์หรือรันเทสต์ ไม่มาขัดจังหวะงาน

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

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

ทีม Agent ของ Claude Code ในทางปฏิบัติ

ต่อไปนี้คือภาพรวมตั้งแต่ต้นจนจบ

จะยกตัวอย่างเล็ก ๆ: REST API "hello world" บน FastAPI ที่อ่านข้อความจากฐานข้อมูล SQLite พร้อมหน้า HTML เล็ก ๆ ที่เรียก API และแสดงผล แอปมีเส้นทางฝั่งแบ็กเอนด์ เลเยอร์ฐานข้อมูล ฟรอนต์เอนด์แบบสแตติก และเอกสารใน readme จึงเหมาะกับทีมสี่คน

เปิดใช้ทีมเอเจนต์

ทีมเอเจนต์เป็นฟีเจอร์ทดลองและปิดไว้ตามค่าเริ่มต้น เปิดใช้งานโดยตั้งค่าตัวแปรสภาพแวดล้อม ในเชลล์หรือในไฟล์ตั้งค่าของ Claude Code

ไฟล์ตั้งค่าอยู่ที่ ~/.claude/settings.json เปิดแล้วเพิ่ม:

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

หากไม่อยากแก้ไฟล์ตั้งค่า ให้ตั้งค่าตัวแปรในเชลล์ก่อนเริ่ม Claude Code ได้:

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

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

เริ่ม Claude Code และบรีฟทีม

สร้างไดเรกทอรีว่างสำหรับโปรเจกต์และเริ่ม Claude Code ภายใน:

mkdir hello-api && cd hello-api
claude

จากนั้นบรีฟทีม พรอมต์เป็นภาษาธรรมดา แต่ยิ่งระบุบทบาทและขอบเขตชัด ทีมยิ่งทำงานดี ต่อไปนี้คือพรอมต์สำหรับ hello world API:

Create an agent team to build a small "hello world" REST API.

The project is a FastAPI service that returns a greeting from a SQLite
database, plus a tiny HTML page that calls the API and shows the result.
- One teammate on the database: create app/db.py with a sqlite3 connection
  to a greetings.db file. Define a get_greeting() function that returns
  the message column from the first row. On import, create the table if
  it doesn't exist and seed it with "Hello, World!" if empty.
- One teammate on the backend: build a FastAPI app in app/main.py with
  a GET /greeting endpoint that calls get_greeting() from app/db.py.
  Add permissive CORS and mount the static/ directory at the root so
  the HTML page is served from the same origin.
- One teammate on the frontend: build static/index.html as a single page
  that fetches /greeting on load, shows a spinner while loading, displays
  the greeting in a centered card on success, and shows an error message
  on failure. Inline the CSS and JavaScript.
- One teammate on docs: write README.md with installation, run, and
  open-in-browser steps, plus an API reference table. Also create
  requirements.txt with fastapi and uvicorn[standard].
Use Sonnet for each teammate. Require plan approval before any teammate
makes changes.

มีสามประเด็นที่ควรสังเกตในพรอมต์นี้ ขอบเขตไฟล์ (app/db.py, app/main.py, static/index.html, README.md, requirements.txt) ป้องกันงานทับกัน การเลือกโมเดล (Sonnet) ช่วยคุมต้นทุนโทเค็น และ plan approval บังคับให้เพื่อนร่วมทีมแสดงแผนก่อนเขียนโค้ด ซึ่งให้จุดตรวจเพื่อปรับทิศทางหากใครเข้าใจบรีฟผิด

ดูทีมลงมือทำงาน

หลังส่งพรอมต์ หัวหน้าจะแตกงานเป็นงานย่อยและเริ่มเพื่อนร่วมทีม จะเห็นพาเนลเอเจนต์ที่ด้านล่างเทอร์มินัล โดยมีหนึ่งแถวต่อเพื่อนร่วมทีม

สร้างเอเจนต์แล้ว

แต่ละแสดงชื่อเพื่อนร่วมทีมและสิ่งที่กำลังทำอยู่ หัวหน้าจะเติมรายการงานร่วมและมอบหมายหรือปล่อยงานตามการพึ่งพา เพื่อนร่วมทีมฝั่งแบ็กเอนด์จะรอเลเยอร์ฐานข้อมูลเพราะมีการอิมพอร์ต get_greeting() จากมัน ส่วนเพื่อนร่วมทีมเอกสารจะรอจนส่วนอื่นเดินหน้าไปไกลพอที่จะอธิบายได้แม่นยำ

คุณยังดูรายการงานได้ กด Ctrl+T เพื่อสลับ รายการจะแสดงทุกงาน สถานะ (รอ ดำเนินการ หรือเสร็จสิ้น) และใครเป็นเจ้าของงาน

สลับไปมาระหว่างเพื่อนร่วมทีม

เพื่อนร่วมทีมแต่ละคนคือเซสชัน Claude Code เต็มรูปแบบ และคุณคุยกับใครก็ได้

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

กด Esc เพื่อกลับไปยังหัวหน้า

เปลี่ยนทิศเพื่อนร่วมทีมที่หลุดทาง

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

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

การอนุมัติเพื่อนร่วมทีมฐานข้อมูล

คุณอ่านสคีมาและแนวทางที่เสนอ แล้วอนุมัติหรือปฏิเสธพร้อมคำแนะนำได้ หากแผนขาดสิ่งใด ตอบกลับเช่น "ใช้ SQLAlchemy แทน sqlite3 ตรง ๆ" แล้วเพื่อนร่วมทีมจะวางแผนใหม่

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

ปิดงานและรีวิว

เมื่อเพื่อนร่วมทีมทั้งหมดเสร็จงาน หัวหน้าจะรายงานสรุปสั้น ๆ และคำสั่งที่ต้องใช้เพื่อรันโปรเจกต์

คำแนะนำสุดท้ายจากหัวหน้า

ถึงจุดนี้ ให้รีวิวงาน เปิดไฟล์ที่สร้างในเอดิเตอร์และอ่าน diff

ไฟล์ app/main.py ที่สร้างขึ้น

ยังสามารถตรวจฐานข้อมูลที่เอเจนต์ฐานข้อมูลสร้างและใส่ข้อมูลตั้งต้นได้

ตาราง greetings

จากนั้นติดตั้ง dependencies รัน uvicorn app.main:app --reload และเปิด http://localhost:8000 ในเบราว์เซอร์เพื่อยืนยันว่า stack ทั้งหมดทำงานตั้งแต่ต้นจนจบ

แอปสุดท้าย

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

จบเพียงเท่านี้!

สรุป

ทีม Agent ของ Claude Code เน้นสองสิ่ง: ความเชี่ยวชาญเฉพาะทางและการประสานงาน แต่ละเพื่อนร่วมทีมมีส่วนงานของตัวเองและหน้าต่างบริบทของตัวเอง หัวหน้าช่วยรักษาการจัดแนว รายการงานช่วยให้ซิงก์กัน และการส่งข้อความโดยตรงช่วยไม่ให้ต้องรอคุณคอยส่งข่าวระหว่างเซสชัน

ภาพใหญ่คือการพัฒนาที่มี AI ช่วยกำลังขยับจากงานเดี่ยวสู่การประสานงาน ทีมเอเจนต์คือวิธีที่การเปลี่ยนแปลงนี้ปรากฏใน Claude Code วันนี้ และรูปแบบเดียวกันกำลังปรากฏใน Claude Tag สำหรับ Slack นักพัฒนาที่คุ้นเคยกับสิ่งนี้ตั้งแต่ตอนนี้จะใช้เวลาน้อยลงกับข้อจำกัดด้านบริบท และใช้เวลามากขึ้นกับการส่งมอบฟีเจอร์จริง

กำลังมองหาการรับรองด้าน Generative AI อยู่หรือไม่? ดูการรับรอง Generative AI ที่ดีที่สุดในปี 2026 รวมถึงคอร์สเด่น เคล็ดลับการเตรียมตัว และคำถามที่พบบ่อย