Boris Cherny ไม่ได้ใช้ prompt กับ Claude อีกต่อไป
นั่นไม่ใช่ประโยคถอดความที่ดังเป็นไวรัล แต่มันคือคำพูดของเขาเอง ที่ถูกบันทึกไว้: "ผมไม่ได้ prompt Claude อีกต่อไปแล้ว ผมมีลูปที่รันอยู่เพื่อ prompt Claude และหาว่าต้องทำอะไร หน้าที่ของผมคือการเขียนลูป" เขาพูดแบบนี้ในที่สาธารณะหลายครั้ง ทั้งงาน talk ของ Sequoia, บทสัมภาษณ์ของ Acquired, Y Combinator's Startup School และรูปแบบที่อยู่เบื้องหลังมันต่างหากที่เป็นหัวข้อจริงของบทความนี้ ไม่ใช่เคล็ดลับ ไม่ใช่รายการฟีเจอร์ แต่มันคือวิธีเฉพาะที่คนที่สร้าง Claude Code ใช้มันจริง ๆ ในแต่ละวัน ซึ่งตรวจสอบได้จากคำพูดต่อสาธารณะของเขาเอง ไม่ใช่การถอดความมือสอง
นี่คือบทวิเคราะห์แบบครบถ้วน อ้างอิงจากสิ่งที่ Cherny พูดจริง ๆ บวกกับแนวทางปฏิบัติที่ดีที่สุดที่ Anthropic เองได้บันทึกไว้สำหรับเครื่องมือที่เขาสร้างขึ้น
Claude Code ไม่เคยตั้งใจให้เป็นผลิตภัณฑ์
การจะเข้าใจว่า Cherny ใช้เครื่องมือนี้อย่างไร ต้องเริ่มจากการเข้าใจว่ามันมาจากไหน เพราะต้นกำเนิดคือสิ่งที่อธิบายปรัชญาเบื้องหลัง และมันเป็นเรื่องราวที่น่าสนใจกว่าที่คนส่วนใหญ่ที่ใช้เครื่องมือนี้ในทุกวันนี้คิดกัน
Claude Code เริ่มต้นในปี 2021 ในฐานะโปรเจกต์วิจัยด้าน AI safety alignment ไม่ใช่ผลิตภัณฑ์ ตอนแรกเป็น VS Code extension ที่หยาบ ๆ จากนั้นก็กลายเป็น CLI tool ภายในชื่อ clide ที่ใช้กันอยู่ภายใน Anthropic หลายปีก่อนที่ใครภายนอกบริษัทจะเคยได้ยินชื่อ Cherny เข้าร่วมโปรเจกต์ในเดือนกันยายน 2024 และสร้างแกนหลักขึ้นมาใหม่ในรอบเร่งสองสัปดาห์ตอนเดือนธันวาคมปีนั้น การเปิดตัวอย่างเป็นทางการในเดือนกุมภาพันธ์ 2025 เป็นไปอย่างเงียบ ๆ ไม่มีการโปรโมทอะไรมากมาย ได้รับการตอบรับแบบเฉย ๆ มากกว่าตื่นเต้น จากนั้น Claude 4 ก็ออกมา และการถูกนำไปใช้ก็พุ่งทะยานแทบข้ามคืน
การประเมินของเขาเองเกี่ยวกับจุดที่เครื่องมือนี้ยืนอยู่ในตอนนี้ ซึ่งพูดออกมาตรง ๆ: "เราเสร็จไปแค่ 1% เท่านั้น"
กรอบความคิดแบบนั้นสำคัญต่อวิธีที่คุณควรใช้มัน Cherny ไม่ได้กำลังบรรยายผลิตภัณฑ์ที่เสร็จสมบูรณ์พร้อมรูปแบบการใช้งานที่ถูกต้องตายตัว เขากำลังบรรยายสิ่งที่ยังอยู่ระหว่างการสร้างใหม่ตลอดเวลา โดยทีมที่ใช้เครื่องมือนี้เพื่อสร้างเครื่องมือนี้เอง Claude Code ถูกเขียนใหม่ซ้ำแล้วซ้ำเล่าด้วยตัว Claude Code เอง ซึ่งเป็นลูปของการพัฒนาตัวเองที่เกิดขึ้นก่อนที่คำว่า "loop engineering" จะกลายเป็นคำที่ใครใช้กันในที่สาธารณะ ตรงนี้ควรนั่งคิดทบทวนสักครู่ เพราะมันอธิบายสิ่งที่ผู้ใช้ใหม่จำนวนมากงง: ทำไมวิธีใช้เครื่องมือนี้ที่ "ถูกต้อง" ถึงดูเหมือนเปลี่ยนไปเรื่อย ๆ มันไม่ใช่ความไม่สม่ำเสมอ แต่มันคือเครื่องมือที่ผู้สร้างเองยังคงค้นหาอย่างจริงจังว่าจริง ๆ แล้วมันทำอะไรได้บ้าง แบบเรียลไทม์ โดยใช้ตัวเครื่องมือเองเพื่อค้นหาคำตอบ
การใช้เวลาหลายปีเป็นเครื่องมือวิจัยภายในก่อนที่จะกลายเป็นผลิตภัณฑ์ ยังอธิบายด้วยว่าทำไมปรัชญาส่วนใหญ่ด้านล่างนี้ถึงอ่านแล้วดูมีจุดยืนชัดเจนผิดปกติสำหรับซอฟต์แวร์สำหรับนักพัฒนาเครื่องมือหนึ่ง เครื่องมือส่วนใหญ่สะสมฟีเจอร์เพื่อตอบสนองฐานผู้ใช้ภายนอกที่กว้างและมีความต้องการที่แข่งขันกันตั้งแต่วันแรก ตรงกันข้าม Claude Code สะสมปรัชญาของมันก่อน ภายในทีมเล็ก ๆ ที่แก้ปัญหาของตัวเอง ก่อนที่มันจะต้องไปตอบสนองเวิร์กโฟลว์ของใครอื่น นั่นคือเหตุผลว่าทำไมการเข้าใจรูปแบบการใช้งานของ Cherny โดยเฉพาะ ไม่ใช่คำแนะนำ "AI coding tool" ทั่วไป ถึงคุ้มค่ากับเวลาที่ต้องใช้ในการทำความเข้าใจจริง ๆ
จุดเปลี่ยนสำคัญ: จากการ Prompt สู่การออกแบบลูป
สิ่งสำคัญที่สุดเพียงอย่างเดียวที่ Cherny เคยพูดต่อสาธารณะเกี่ยวกับการใช้ Claude Code จริง ๆ ก็คือประโยคเรื่องลูปด้านบน และมันคุ้มค่าที่จะแกะความหมายที่แท้จริงในทางปฏิบัติออกมา ไม่ใช่แค่เป็นประโยคที่เอาไว้พูดอ้าง
Prompt คือคำสั่งเดียว ส่งครั้งเดียว ได้คำตอบครั้งเดียว ลูปคือระบบ: มันทำการ prompt Claude ประเมินสิ่งที่กลับมา ตัดสินใจว่าขั้นต่อไปคืออะไร แล้วทำซ้ำ โดยไม่มีมนุษย์คอยนั่งอยู่ตรงกลางทุก ๆ รอบ Cherny บอกไว้ว่างานของเขาคือ "การเขียนลูป" หมายความว่าเขาทุ่มเทเวลาไปกับการออกแบบระบบที่สร้างและประเมิน prompt ไม่ใช่พิมพ์ prompt เองทีละรอบ
เวิร์กโฟลว์ประจำวันที่เขาเปิดเผยออกมาสะท้อนเรื่องนี้โดยตรง โทรศัพท์คืออินเทอร์เฟซหลัก ไม่ใช่คีย์บอร์ดแล็ปท็อป มีห้าถึงสิบเซสชันที่ทำงานพร้อมกัน แต่ละเซสชันสามารถแตก sub-agent ออกไปได้ บางครั้งเป็นหลายร้อยตัวพร้อมกัน บางครั้งเป็นหลายพันตัวข้ามคืนสำหรับงานที่ลึกกว่า มีลูปหลายสิบตัวที่รันต่อเนื่องในเบื้องหลัง คอยดูแล pull requests ทำให้ continuous integration อยู่ในสภาพแข็งแรง จัดกลุ่ม feedback ตามตารางเวลาประจำ งานประจำพวกนี้ยังคงทำงานอยู่บนเซิร์ฟเวอร์แม้ในช่วงที่เขาปิดแล็ปท็อป
ข้อคิดเชิงปฏิบัติสำหรับใครก็ตามที่ใช้ Claude Code ในชีวิตประจำวัน: เพดานความสามารถของเครื่องมือนี้ไม่ได้ถูกกำหนดโดยว่า prompt เดียวจะดีแค่ไหน แต่มันถูกกำหนดโดยว่าคุณออกแบบระบบรอบ ๆ รอบการทำงานอัตโนมัติซ้ำ ๆ ของการ prompt ตรวจสอบ และลองใหม่ได้ดีแค่ไหน
อะไรที่เปลี่ยนไปจริง ๆ ใน System Prompt และทำไมมันถึงสำคัญ
Cherny ยังพูดตรง ๆ เกี่ยวกับการตัดสินใจทางเทคนิคเฉพาะอย่างหนึ่งที่เผยให้เห็นว่าเขาคิดเกี่ยวกับการสั่ง Claude อย่างไร: "เราลบ system prompt ของ Claude Code ออกไปประมาณ 80% สำหรับโมเดลใหม่ที่สุดของเรา นี่คือสิ่งที่เราได้เรียนรู้เกี่ยวกับการเขียน system prompt"
การตัดทิ้งครั้งนั้นเกิดขึ้นเฉพาะกับโมเดลเจนเนอเรชัน Opus 4.8 โดยลด system prompt จากประมาณ 15,000 ตัวอักษรเหลือราว 4,500 ตัวอักษร โดยไม่ทำให้ผลการประเมินด้าน coding ลดลงอย่างมีนัยสำคัญ บทเรียนเบื้องหลังมัน ตามแนวทาง context-engineering ของ Anthropic เอง คือรายการกฎที่เข้มงวดและละเอียดถี่ถ้วนไม่จำเป็นอีกต่อไปเมื่อโมเดลมีความสามารถพอที่จะใช้วิจารณญาณจริง ๆ กฎกลายเป็นดุลยพินิจ ตัวอย่างการใช้งานเครื่องมือถูกแทนที่ด้วยอินเทอร์เฟซที่ออกแบบมาให้อธิบายตัวเองได้ บริบทที่ละเอียดถี่ถ้วนที่ยัดเข้าไปล่วงหน้าถูกแทนที่ด้วย progressive disclosure ข้อมูลจะถูกแสดงก็ต่อเมื่อสถานการณ์เฉพาะเรียกต้องการจริง ๆ แทนที่จะโหลดเข้าไปในทุกเซสชันเป็นค่าเริ่มต้น
มีรายละเอียดปลีกย่อยหนึ่งที่น่าจะพูดถึงอย่างตรงไปตรงมา เพราะมันทำให้เรื่องเวอร์ชันง่าย ๆ ซับซ้อนขึ้น: ตอนที่ Opus 5 วางจำหน่าย นักพัฒนาอิสระที่ทดสอบพบว่า system prompt จริงของมันยาวขึ้นประมาณ 72% เมื่อเทียบกับของ Opus 4.8 นั่นไม่ได้ขัดแย้งกับบทเรียนข้างต้น แต่มันเป็นบทเรียนในเชิงที่ลึกกว่าเดิม prompt หดตัวลงในเชิงปริมาณกฎที่เข้มงวด แล้วก็โตขึ้นอีกครั้งด้วยการอ้างอิงที่เฉพาะเจาะจงและสมบูรณ์ขึ้น, ตัวอย่างประกอบ, ชุดเทสต์, เกณฑ์การประเมิน ซึ่งเป็นบริบทประเภทที่โมเดลที่เก่งขึ้นจริง ๆ จะใช้ประโยชน์ได้ดี ข้อคิดไม่ใช่ "สั้นกว่าเสมอดีกว่า" แต่มันคือปริมาณคำสั่งควรสอดคล้องกับสิ่งที่โมเดลเฉพาะตัวนั้นจำเป็นต้องใช้เพื่อใช้วิจารณญาณได้ดี ไม่ใช่เป้าหมายตายตัวในทิศทางใดทิศทางหนึ่ง
เขียน CLAUDE.md แบบเดียวกับที่ทีม Anthropic ทำ
เรื่องนี้เชื่อมโดยตรงกับวิธีที่คุณควรจัดโครงสร้างคำสั่งระดับโปรเจกต์ของตัวเอง และเอกสารทางการของ Anthropic เองก็ชัดเจนเจนเกี่ยวกับกรอบความคิดที่ควรใช้: ให้คิดว่า Claude เป็นพนักงานใหม่ที่เก่งมากแต่ความจำเสื่อม และต้องการคำสั่งที่ชัดเจน
ความหมายเชิงปฏิบัติของกรอบความคิดนั้น เก่ง หมายความว่าคุณไม่ต้องอธิบายความสามารถทั่วไปซ้ำซ้อน เพราะมันมีอยู่แล้ว ใหม่ หมายความว่าไม่มีความรู้สะสมเกี่ยวกับประวัติหรือธรรมเนียมปฏิบัติของโปรเจกต์คุณเลย ความจำเสื่อม หมายความว่าทุกเซสชันเริ่มจากศูนย์เสมอ CLAUDE.md คือสิ่งเดียวที่นำพาบริบทข้ามระหว่างเซสชันได้อย่างน่าเชื่อถือ
แนวทางที่ Anthropic บันทึกไว้ตั้งเป้าให้ไฟล์นี้อยู่ใต้ 200 บรรทัด โดยบางทีมที่มีวินัยที่สุดรันที่ประมาณ 60 บรรทัด วิธีทดสอบว่าสิ่งใดควรอยู่ในไฟล์นี้: มันเกี่ยวข้องกับแทบทุกเซสชันจริง ๆ หรือแค่กับงานส่วนแคบ ๆ ตามสถานการณ์ สิ่งที่เป็นสากล เช่น คำสั่ง build, กฎสไตล์ที่ยืดหยุ่นไม่ได้, ความคาดหวังเรื่องการเทสต์, ราวกั้น (guardrails) ที่จริงจัง ควรอยู่ในไฟล์หลัก ส่วนอะไรที่แคบกว่านั้นควรอยู่ในไฟล์ที่ถูก import เข้ามา แล้วค่อยดึงเข้ามาในบริบทเมื่องานของเซสชันนั้นเรียกใช้จริง ๆ โดยใช้ syntax การ import แบบ @path/to/file ที่เครื่องมือรองรับโดยตรง
สำหรับคำสั่งที่ข้ามไม่ได้จริง ๆ วิธีปฏิบัติภายในของ Anthropic ใช้เครื่องหมายเน้นความสำคัญอย่างชัดเจน เช่น "IMPORTANT" หรือ "YOU MUST" ซึ่งสงวนไว้สำหรับกฎไม่กี่ข้อที่ต้นทุนของการที่ Claude พลาดมันสูงจริง ๆ การทำเครื่องหมายแบบนี้กับทุกอย่างจะทำลายจุดประสงค์ทั้งหมด เพราะมันจะหยุดทำหน้าที่เป็นสัญญาณทันทีที่ใช้มันแบบไม่เลือกหน้า
Plan Mode: เข้าใจก่อนลงมือ
รูปแบบพฤติกรรมเฉพาะอย่างหนึ่งที่ควรนำมาสร้างเป็นวิธีทำงานกับเครื่องมือจริง ๆ: ทำให้ Claude วางแผนก่อนที่มันจะลงมือทำ แทนที่จะกระโดดเข้าไปแก้ไขทันที
เรื่องนี้ไม่ใช่แค่การเปิดปิดฟีเจอร์ แต่มันสะท้อนการเปลี่ยนแปลงจริงที่เอกสารของ Anthropic อธิบายไว้: โมเดลใหม่กว่าวางแผนได้อย่างถูกต้องโดยไม่ต้องมีการบังคับทิศทางหนัก ๆ ล่วงหน้าแบบที่โมเดลรุ่นก่อนต้องเจอ ถึงขนาดที่บางทีมรายงานว่าไม่จำเป็นต้องบังคับขั้นตอน plan mode แบบชัดเจนสำหรับทุกงานอีกแล้ว เพราะการใช้เหตุผลค่าเริ่มต้นของโมเดลสร้างแผนที่สอดคล้องกันก่อนลงมือทำอยู่แล้ว ถึงอย่างนั้น สำหรับการเปลี่ยนแปลงที่ซับซ้อนจริง ๆ และเกี่ยวข้องกับหลายไฟล์ การขอให้วางแผนก่อนอย่างชัดเจน และตรวจสอบมันก่อนอนุมัติให้ลงมือทำ ก็ยังคงเป็นจุดตรวจสอบที่มีประโยชน์อย่างแท้จริง เพราะมันจับความเข้าใจผิดในความต้องการได้ก่อนที่มันจะกระจายไปทั่วไฟล์หลายสิบไฟล์ แทนที่จะไปจับทีหลัง
Sub-Agents และการทำงานแบบขนาน
เวิร์กโฟลว์ที่ Cherny เปิดเผยว่ามีการรัน sub-agent นับร้อย บางครั้งนับพัน ในเซสชันเดียว ชี้ไปที่ความสามารถเชิงโครงสร้างที่ควรทำความเข้าใจและใช้อย่างตั้งใจ ไม่ใช่ใช้แบบบังเอิญ
เอเจนต์หลักสามารถแยกงานที่ซับซ้อนออกเป็นชิ้นเล็ก ๆ แล้วส่ง sub-agent ไปทำงานเหล่านั้นอย่างอิสระ โดยแต่ละตัวทำงานในบริบทของตัวเอง แทนที่จะต้องแย่งพื้นที่กันในบทสนทนาต่อเนื่องหนึ่งเดียว เรื่องนี้ให้ประโยชน์สองอย่างพร้อมกัน อย่างแรก มันทำให้งานที่จะล้น context window เดียวถูกแบ่งไปทำงานในหลายบริบทที่เล็กกว่าแทน อย่างที่สอง มันเพิ่มชั้นการตรวจสอบจริง ๆ เพราะ sub-agent ที่ตรวจสอบผลลัพธ์ของเอเจนต์อีกตัวหนึ่งกำลังตรวจสอบงานที่ตัวเองไม่ได้เป็นคนสร้าง ซึ่งเชิงโครงสร้างแล้วน่าเชื่อถือกว่าเอเจนต์ที่ให้คะแนนการบ้านของตัวเองในลมหายใจเดียวกับที่สร้างมันขึ้นมา
สำหรับงานแบบขนานโดยเฉพาะ git worktrees ทำให้หลายเซสชันทำงานบน branch หรือ directory แยกกันพร้อมกันได้โดยไม่ให้การเปลี่ยนแปลงที่ยังไม่เสร็จของเซสชันหนึ่งไปรบกวนอีกเซสชัน นี่คือโครงสร้างพื้นฐานเชิงกลที่อยู่ใต้การรันลูปพร้อมกันหลายตัวแบบที่ Cherny อธิบายว่าทำด้วยตัวเอง ไม่ใช่เอเจนต์ตัวเดียวที่ทำงานเร็วขึ้น แต่เป็นเอเจนต์จำนวนมากที่ทำงานบนชิ้นงานที่แยกจากกันจริง ๆ ในเวลาเดียวกัน
การตัดสินใจใช้ grep: กรณีศึกษาของความเรียบง่ายที่เหนือความฉลาด
การตัดสินใจทางเทคนิคที่เฉพาะเจาะจงและมีการบันทึกไว้อย่างดีจากทีมของ Cherny เอง แสดงให้เห็นปรัชญาในวงกว้างที่ควรซึมซับ Claude Code ทิ้ง vector search และ embeddings ในการค้นหาโค้ดเบส แล้วหันไปใช้ grep และ glob ธรรมดา คำพูดของเขาเกี่ยวกับผลลัพธ์: "ทำได้ดีกว่าทุกอย่าง เกินห่างมาก"
บทเรียนนี้ครอบคลุมไปไกลกว่าการตัดสินใจเฉพาะครั้งนี้ โซลูชันที่ฟังดูซับซ้อนกว่า อย่าง semantic vector search ไม่ได้ดีกว่าโซลูชันที่เรียบง่ายกว่าอย่าง grep โดยอัตโนมัติ ถ้าโซลูชันที่เรียบง่ายกว่านั้นเข้ากับปัญหาจริง ๆ โค้ดเบสมี syntax ที่แม่นยำ, ชื่อฟังก์ชันที่แม่นยำ, เส้นทาง import ที่แม่นยำ ซึ่งเป็นการจับคู่แบบตรงตัวและแม่นยำที่ grep ถนัด และการจับคู่แบบ semantic แบบคลุมเครือสามารถบ่อนทำลายมันได้ด้วยการแสดงผลลัพธ์ที่ดูเข้าท่าแต่ผิด
ข้อคิดเชิงปฏิบัติสำหรับการตั้งค่าเวิร์กโฟลว์ของคุณเอง: อย่าเลือกใช้เครื่องมือหรือสถาปัตยกรรมที่ฟังดูซับซ้อนกว่าเป็นค่าเริ่มต้น เพราะคิดว่าความซับซ้อนแปลว่าความสามารถ ลองตัวเลือกง่าย ๆ กับกรณีการใช้งานจริงของคุณก่อน บ่อยครั้งที่มันชนะ และถึงแม้มันจะไม่ชนะ คุณก็ได้ยืนยันแล้วว่าแนวทางที่ซับซ้อนกว่านั้นสมควรได้ที่ทางของมัน ไม่ใช่แค่เดาไปเอง
อย่าให้เอเจนต์ให้คะแนนงานของตัวเองเด็ดขาด
หลักการที่แยกออกมาและได้รับการยืนยันแล้วจากแนวปฏิบัติด้านวิศวกรรม harness ของ Anthropic เอง ซึ่งเกี่ยวข้องโดยตรงกับวิธีที่คุณควรจัดโครงสร้างขั้นตอนการตรวจสอบในเวิร์กโฟลว์ Claude Code ของตัวเอง: การสร้าง (generation) และการประเมิน (evaluation) ควรเกิดขึ้นในบทบาทที่แยกจากกันจริง ๆ เพราะโมเดลที่ตรวจสอบผลลัพธ์ของตัวเองในลมหายใจเดียวกับที่สร้างมัน มีแนวโน้มจะลำเอียงไปในทางบวก ต่อให้ผู้ตรวจสอบที่เป็นมนุษย์จะเห็นจุดบกพร่องได้ทันทีก็ตาม
ในทางปฏิบัติ หมายความว่าเอเจนต์ที่เขียนโค้ดไม่ควรเป็นรอบเดียวกันกับที่ตัดสินว่าโค้ดนั้นดีพอจะปล่อยออกหรือไม่ ขั้นตอนการประเมินแยกต่างหาก โดยเฉพาะถ้าสามารถเข้าถึงสิ่งที่เอเจนต์ผู้สร้างไม่เห็น เช่น ผลลัพธ์จริงจากชุดเทสต์ หรือเอกสารข้อกำหนดต้นฉบับ จะจับได้ในสิ่งที่การประเมินตนเองมองข้าม นี่คือหลักการเดียวกับที่อยู่เบื้องหลังรูปแบบการตรวจสอบแบบ sub-agent ข้างต้น แต่ประยุกต์เป็นวินัยทั่วไป ไม่ใช่ฟีเจอร์เฉพาะอย่าง
การจัดการ Effort และ Context
สำหรับใครก็ตามที่รันเซสชันที่ยาวและต้องการพลังมากขึ้น การเข้าใจวิธีส่งสัญญาณระดับ effort โดยตรงเป็นเรื่องสำคัญ การใส่คำว่า "ultrathink" ใน prompt จะบอกให้ใช้ความลึกในการคิดสูงสุดสำหรับคำตอบนั้น ๆ โดยไม่เปลี่ยนการตั้งค่าระดับเซสชันโดยรวม สำหรับการจัด orchestration เวิร์กโฟลว์อัตโนมัติระดับเซสชัน การตั้งระดับ effort ไว้ที่ขั้นสูงสุดจะรวมการคิดเชิงลึกเข้ากับการแบ่งงานอัตโนมัติตลอดทั้งเซสชัน ถึงแม้เรื่องนี้ต้องใช้โมเดลที่รองรับระดับ effort นั้นจริง ๆ และไม่ใช่ทุกโมเดลในไลน์อัพเดียวกันจะรองรับ
การจัดการบริบทเองก็สมควรได้รับความใส่ใจอย่างตั้งใจในเซสชันยาว ๆ เมื่อเซสชันยิ่งยาว บริบทที่สะสมมาอาจเริ่มเจือจางสัญญาณของสิ่งที่สำคัญจริง ๆ ในตอนนี้ ซึ่งเป็นปัญหาเดียวกับที่ไฟล์ CLAUDE.md ที่พองโตสร้างขึ้น แต่เกิดขึ้นแบบไดนามิกภายในบทสนทนาเดียว ไม่ใช่แบบคงที่ในไฟล์ การเริ่มเซสชันใหม่เป็นระยะ ๆ สำหรับงานในระยะใหม่จริง ๆ แทนที่จะยืดบทสนทนาเดียวไปเรื่อย ๆ เป็นวินัยเชิงปฏิบัติจริงที่ควรนำมาใช้ แทนที่จะคิดว่าบริบทมากขึ้นดีกว่าเสมอ
ตัวอย่างการใช้งานจริง: ประยุกต์สิ่งเหล่านี้กับงานจริงหนึ่งงาน
เพื่อทำให้ทั้งหมดที่กล่าวมาข้างต้นเป็นรูปธรรมแทนที่จะเป็นนามธรรม นี่คือวิธีที่หลักการเหล่านี้มารวมกันจริง ๆ ในงานธรรมดา ๆ ทั่วไป นั่นคือการเพิ่มฟีเจอร์ใหม่ให้กับโค้ดเบสเดิมที่มีความซับซ้อนพอประมาณ มีไฟล์ที่เชื่อมโยงกันอยู่สองสามไฟล์ มีเทสต์เดิมอยู่บ้าง เป็นการเปลี่ยนแปลงที่ไม่เล็กน้อยแต่ก็ไม่ได้แปลกประหลาดอะไร
เริ่มจาก CLAUDE.md ที่มีอยู่แล้ว สั้น เป็นสากล มีคำสั่ง build และ test กฎสไตล์ที่ยืดหยุ่นไม่ได้ ไม่มีอะไรตามสถานการณ์มาทำให้รก ซึ่งหมายความว่าเซสชันเริ่มต้นด้วยบริบทที่เกี่ยวข้องจริง ๆ ที่โหลดเข้ามาอัตโนมัติ โดยที่คุณไม่ต้องไปอธิบายธรรมเนียมปฏิบัติของโปรเจกต์ใหม่ตั้งแต่ต้น
แทนที่จะเขียน prompt อันยาวเหยียดอันเดียวที่หวังผล โดยบรรยายฟีเจอร์ทั้งหมดอย่างละเอียดจนหมด แค่บรรยายเป้าหมายแล้วปล่อยให้การวางแผนของโมเดลจัดการเรื่องการแบ่งงานเอง โดยเชื่อมั่นในปรัชญาการลดโครงสร้างที่พูดถึงในหัวข้อ system prompt ข้างต้น สำหรับงานขนาดนี้ การขอให้วางแผนก่อนอย่างชัดเจนก็คุ้มค่ากับขั้นตอนที่เพิ่มขึ้น เพราะความเข้าใจผิดในความต้องการที่จับได้ตรงนี้มีต้นทุนแค่การแก้ไขสองนาที แทนที่จะต้องใช้เวลาหนึ่งชั่วโมงเพื่อคลี่คลายการเปลี่ยนแปลงหลายไฟล์ทีหลัง
เมื่อแผนดูเรียบร้อย ก็ปล่อยให้ลงมือทำ ถ้างานแยกออกเป็นชิ้นที่เป็นอิสระจริง ๆ เช่น อัปเดต data model และแยกอัปเดต UI ที่ใช้งานมัน นั่นเป็นตัวเลือกธรรมชาติสำหรับการแบ่งงานแบบ sub-agent โดยแต่ละชิ้นทำงานในบริบทของตัวเอง แทนที่จะแย่งพื้นที่กันในบทสนทนาต่อเนื่องเดียว
ก่อนที่จะถือว่าผลลัพธ์เสร็จสิ้น ให้รันรอบการตรวจสอบแยกต่างหาก แทนที่จะเชื่อรายงานตนเองของเอเจนต์ผู้ลงมือว่า "ทุกอย่างทำงานได้" วิธีนี้อาจง่ายแค่เริ่มเซสชันใหม่ หรือใช้ sub-agent ที่มีสิทธิ์อ่านอย่างเดียว เพื่อตรวจผลลัพธ์จริงจากเทสต์และ diff เทียบกับแผนเดิม ไม่ใช่แค่รับคำยืนยันมั่นใจว่า "เสร็จแล้ว" จากบริบทเดียวกับที่เขียนโค้ด
สังเกตสิ่งที่ไม่มีในตัวอย่างการเดินเรื่องนี้ ไม่มีเครื่องมือแปลกพิสดาร ไม่มีการตั้งค่าที่ผิดปกติ แค่การใช้หลักการธรรมดา ๆ อย่างวางแผนก่อนสำหรับงานซับซ้อนจริง ๆ, แบ่งงานด้วย sub-agent สำหรับชิ้นส่วนที่เป็นอิสระจริง ๆ, และตรวจสอบแบบแยกส่วนแทนการประเมินตนเอง สามหลักการเดียวกับที่ร้อยเรียงผ่านทุกอย่างข้างต้น นำไปใช้กับงานจริงหนึ่งงานแทนการอธิบายแบบนามธรรม
ต่อยอดจากคนคนเดียว
ทุกอย่างที่กล่าวมาข้างต้นอธิบายแนวปฏิบัติสำหรับคนคนเดียวที่ใช้ Claude Code อย่างตั้งใจ เวิร์กโฟลว์ที่ Cherny ยืนยันเอง ไม่ว่าจะเป็น sub-agent หลายร้อยตัวต่อวัน หรือหลายพันตัวข้ามคืน ก็เป็นรูปแบบหนึ่งของการขยายสเกลอยู่แล้ว คือคนคนเดียวคุมงานแบบขนานและอัตโนมัติปริมาณมหาศาลจริง ๆ แต่หลักการเดียวกันนี้ขยายไปถึงทีมที่นำแนวปฏิบัติเหล่านี้มาใช้ร่วมกันได้ โดยมีข้อควรคำนึงเฉพาะสองสามข้อที่ควรพูดถึงตรง ๆ
CLAUDE.md จะหยุดเป็นไฟล์ความชอบส่วนตัวทันทีที่มีคนในทีมมากกว่าหนึ่งคนทำงานกับโค้ดเบสเดียวกันโดยใช้ Claude Code จริง ๆ ปฏิบัติต่อการแก้ไขมันด้วยวินัยการรีวิวแบบเดียวกับที่คุณใช้กับคอนฟิกที่ใช้ร่วมกันซึ่งส่งผลต่อเวิร์กโฟลว์ของทั้งทีม เพื่อนร่วมทีมที่เติมคำสั่ง "hotfix" ครั้งเดียวทิ้งหลังเซสชันที่น่าหงุดหงิดครั้งหนึ่ง โดยไม่ผ่านรีวิว คือกลไกที่สร้างไฟล์ที่พองโตและขัดแย้งในตัวเอง ซึ่งสุดท้ายก็ไม่มีใครเชื่อถือและทำตามอีกต่อไป ขั้นตอนรีวิวแบบเบา ๆ แค่มีอีกคนสักคนเหลือบดู diff ก่อนที่จะ merge ก็สามารถจับปัญหาเหล่านี้ได้เป็นสัดส่วนที่มีนัยสำคัญ ก่อนที่มันจะสะสมกลายเป็นปัญหาจริง ๆ
วินัยการตรวจสอบสำคัญยิ่งขึ้นในระดับทีมมากกว่าระดับผู้ใช้คนเดียว เมื่อคนคนหนึ่งทั้งเขียนและรีวิวงานที่ตัวเองทำร่วมกับเอเจนต์ อย่างน้อยก็มีโอกาสที่เขาจะจับได้เองในสิ่งที่เอเจนต์พลาด แต่เมื่อทีมพึ่งพาผลลัพธ์ของ Claude Code ที่ไหลผ่านกระบวนการรีวิวร่วมกัน หลักการแยกการประเมินจากตอนก่อนหน้านี้ไม่ใช่ตัวเลือกอีกต่อไป มันกลายเป็นกลไกจริงที่ปกป้องโค้ดเบสจากการประเมินตนเองที่มั่นใจแต่ผิดของเอเจนต์ไปถึง production เพราะทางเลือกอื่นคือการไว้วางใจว่ามนุษย์บางคน ในบางจุดของเวิร์กโฟลว์อันยุ่งเหยิงของทีม จะบังเอิญจับได้ในสิ่งที่เอเจนต์ไม่ได้ชี้ธงเอง
ควรกำหนดความเป็นเจ้าของที่ชัดเจนสำหรับการตรวจสอบ CLAUDE.md เป็นระยะ ๆ ด้วย ซึ่งเป็นวินัยการบำรุงรักษาแบบเดียวกับที่แนะนำสำหรับเอกสารร่วมที่สะสมเรื่อย ๆ หากไม่มีเจ้าของที่ได้รับมอบหมายชัดเจน งานนี้มักจะหลุดรอดผ่านช่องโหว่ไป เพราะมันไม่ได้บล็อกงานเร่งด่วนใดงานหนึ่งแบบการ build ที่พัง และการเพิ่มเติมแบบไร้เจ้าของหกเดือนก็ให้ผลลัพธ์เป็นไฟล์ที่พองโตและขัดแย้งกันแบบเดียวกับที่หลักการความเป็นสากลถูกสร้างขึ้นมาเพื่อป้องกันตั้งแต่แรก
จุดที่คนมักใช้หลักการเหล่านี้ผิด
การอ่านผิด ๆ เฉพาะเจาะจงสองสามแบบเกี่ยวกับแนวคิดข้างต้นปรากฏซ้ำแล้วซ้ำเล่า ซึ่งคุ้มค่าที่จะพูดถึงตรง ๆ เพราะแต่ละแบบมีการแก้ไขที่ง่ายและเฉพาะเจาะจง
การมองว่า "ลูปสำคัญกว่า prompt" คือใบอนุญาตให้ข้ามการทำความเข้าใจงานทั้งหมด คำพูดของ Cherny เองคือหน้าที่ของเขาคือการเขียนลูป ไม่ใช่การที่เขาหยุดคิดว่าลูปเหล่านั้นควรทำอะไรจริง ๆ การออกแบบลูปที่ดี นิยามความสำเร็จที่ดี เงื่อนไขการหยุดที่ดี ยังคงต้องเข้าใจปัญหาให้ชัดเจนพอ ๆ กับการเขียน prompt เดียวที่ดี ลูปเข้ามาแทนที่การพิมพ์ซ้ำ ๆ ด้วยมือ ไม่ได้แทนที่การคิดล่วงหน้า
การอ่านการลดขนาด system prompt ว่า "ให้บริบทโมเดลน้อยลงเสมอ" ตัวอย่างโต้แย้งอย่าง Opus 5 ในตอนต้นของบทความนี้มีไว้เพื่อแก้การอ่านผิดนี้โดยเฉพาะ บทเรียนจริงคือปริมาณคำสั่งควรสอดคล้องกับสิ่งที่โมเดลเฉพาะตัวนั้นต้องการจริง ๆ เพื่อใช้วิจารณญาณที่ดี ซึ่งบางครั้งหมายถึงการลดรายการกฎที่เคร่งครัดลง และบางครั้งหมายถึงการเพิ่มเอกสารอ้างอิงที่สมบูรณ์และเฉพาะเจาะจงมากขึ้น การตัดบริบทแบบไม่เลือกหน้าเพราะ "โมเดลใหม่ที่สุดต้องการน้อยกว่า" คือการนำผลการค้นพบที่ละเอียดอ่อนและเฉพาะโมเดลไปใช้เป็นกฎครอบจักรวาล
การแบ่งงานง่าย ๆ ออกเป็น sub-agent มากเกินไปจนเป็นนิสัย การแบ่งงานแบบ sub-agent จะคุ้มกับความซับซ้อนที่เพิ่มขึ้นบนงานชิ้นใหญ่และเป็นอิสระจริง ๆ เท่านั้น การแยกการเปลี่ยนแปลงเล็ก ๆ ที่ผูกแน่นหนากันเป็นชิ้นส่วน sub-agent แบบฝืน ๆ เพียงเพื่อจะใช้แพตเทิร์นนี้ เพิ่มภาระการประสานงานโดยไม่ได้ประโยชน์ที่จะมาชดเชยมันในงานใหญ่ ตัวอย่างการใช้งานจริงในตอนต้นบทความนี้จงใจใช้ sub-agent เฉพาะจุดที่ชิ้นส่วนเป็นอิสระตามธรรมชาติเท่านั้น ไม่ใช่ใช้กับทุกงานไม่ว่าจะขนาดไหน
การข้ามการตรวจสอบโดยคิดว่า "โมเดลใหม่กว่าไม่ต้องการอีกแล้ว" หลักการแยกการประเมินไม่ใช่ทางออกชั่วคราวสำหรับโมเดลที่อ่อนแอกว่า ซึ่งจะกลายเป็นสิ่งไม่จำเป็นเมื่อความสามารถดีขึ้น แต่มันเป็นข้อเท็จจริงเชิงโครงสร้างเกี่ยวกับการประเมินตนเอง โมเดลที่ตรวจสอบงานของตัวเองในบริบทเดียวกับที่สร้างมันจะจับจุดบอดของตัวเองได้ยากกว่าการตรวจสอบอิสระเสมอ ไม่ว่าโมเดลพื้นฐานจะเก่งแค่ไหนก็ตาม เรื่องนี้จริงกับผู้รีวิวที่เป็นมนุษย์ด้วย และมันไม่ได้หยุดเป็นจริงเพียงเพราะผู้รีวิวฉลาดขึ้น
นิสัยประจำวันที่ควรนำมาใช้จริง
เมื่อรวมทุกอย่างข้างต้นเป็นแนวปฏิบัติประจำวันที่เป็นรูปธรรมและใช้ได้จริง นี่คือหน้าตาของการทำตามแนวทางที่ Cherny สาธิตไว้จริง ๆ
หยุดมองทุกงานเป็น prompt เดียวที่ต้องทำให้ถูกต้องตั้งแต่ครั้งแรก ให้ออกแบบลูปแทน: เอเจนต์ที่ลงมือทำงาน, วิธีตรวจสอบว่าความพยายามนั้นสำเร็จหรือไม่, และเส้นทางที่ชัดเจนว่าเกิดอะไรขึ้นต่อไปขึ้นอยู่กับผลตรวจนั้น ไม่ว่าจะผ่าน, ลองใหม่, หรือส่งต่อให้คุณโดยตรง
ทำให้ CLAUDE.md ของคุณสั้น และมองมันเป็นเอกสารปฐมนิเทศสำหรับพนักงานใหม่ที่เก่งแต่ไม่มีบริบท ไม่ใช่คู่มือฉบับสมบูรณ์ ย้ายอะไรที่เป็น situational ไปไว้ในไฟล์ที่ import แทนที่จะทำให้เอกสารหลักพองโต
ใช้ plan mode อย่างตั้งใจกับงานที่ซับซ้อนจริง ๆ และเกี่ยวข้องกับหลายไฟล์ ส่วนงานที่ง่ายกว่าและขอบเขตชัดเจน ให้เชื่อการวางแผนค่าเริ่มต้นของโมเดลแทนการบังคับขั้นตอนเพิ่มเติมทุกที่จนเป็นนิสัย
แบ่งงานใหญ่ให้เป็น sub-agent ที่ทำงานในบริ
