title: "การพัฒนาแบบขับเคลื่อนด้วยเอเจนต์: เพิ่มประสิทธิภาพให้ Copilot Applied Science" slug: "agent-driven-development-in-copilot-applied-science" date: "2026-04-02" lang: "th" source: "https://github.blog/ai-and-ml/github-copilot/agent-driven-development-in-copilot-applied-science/" category: "เครื่องมือสำหรับนักพัฒนา" keywords:
- การพัฒนาแบบขับเคลื่อนด้วยเอเจนต์
- GitHub Copilot
- เอเจนต์ AI สำหรับการเขียนโค้ด
- วิศวกรรมซอฟต์แวร์
- ระบบอัตโนมัติ
- Claude Opus
- เครื่องมือสำหรับนักพัฒนา
- การวิจัย AI
- วิศวกรรมพร้อมต์
- การปรับโครงสร้างโค้ด
- CI/CD
- เวิร์กโฟลว์ AI meta_description: "ค้นพบว่าการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ร่วมกับ GitHub Copilot และ Claude Opus กำลังปฏิวัติวิศวกรรมซอฟต์แวร์อย่างไร โดยทำให้งานที่ต้องใช้ความคิดเป็นไปโดยอัตโนมัติ และเร่งกระบวนการทำงานร่วมกันให้รวดเร็วยิ่งขึ้น" image: "/images/articles/agent-driven-development-in-copilot-applied-science.png" image_alt: "ภาพหน้าจอแสดงส่วนต่อประสานการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ของ GitHub Copilot ซึ่งแสดงข้อเสนอแนะโค้ดและเวิร์กโฟลว์การเขียนโค้ดร่วมกัน" quality_score: 94 content_score: 93 seo_score: 95 companies:
- GitHub schema_type: "NewsArticle" reading_time: 7 faq:
- question: "การพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ในบริบทของ GitHub Copilot คืออะไร?" answer: "การพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ (Agent-driven development) หมายถึงกระบวนทัศน์วิศวกรรมซอฟต์แวร์ที่เอเจนต์ AI เช่นเดียวกับที่ขับเคลื่อนด้วย GitHub Copilot เข้ามาเป็นผู้มีส่วนร่วมหลักและผู้ทำงานร่วมกันในกระบวนการพัฒนา แทนที่จะเพียงแค่แนะนำโค้ด เอเจนต์เหล่านี้จะเข้าร่วมอย่างกระตือรือร้นในการวางแผน, การนำไปใช้, การปรับโครงสร้างโค้ด, การทดสอบ, และการจัดทำเอกสารซอฟต์แวร์ วิธีการนี้ใช้ประโยชน์จากความสามารถของ AI ในการทำงานซ้ำ ๆ ที่ต้องใช้ความคิดให้เป็นอัตโนมัติ ช่วยให้นักพัฒนาที่เป็นมนุษย์สามารถมุ่งเน้นไปที่การแก้ปัญหาในระดับที่สูงขึ้น, การออกแบบเชิงกลยุทธ์, และงานที่สร้างสรรค์ ซึ่งจะช่วยเร่งรอบการพัฒนาและปรับปรุงคุณภาพของโค้ดผ่านความช่วยเหลือจาก AI ที่มีโครงสร้างและมาตรการป้องกันที่เข้มงวด"
- question: "โครงการ 'eval-agents' มีที่มาอย่างไร?" answer: "โครงการ 'eval-agents' เกิดขึ้นจากความท้าทายที่นักวิจัย AI ต้องเผชิญร่วมกัน นั่นคือการวิเคราะห์ข้อมูลปริมาณมหาศาล Tyler McGoffin นักวิจัย AI พบว่าตนเองต้องใช้เวลาตรวจสอบ 'วิถีการทำงาน' (trajectories) จำนวนหลายแสนบรรทัดซ้ำแล้วซ้ำเล่า ซึ่งเป็นบันทึกรายละเอียดของกระบวนการคิดและการกระทำของเอเจนต์ AI ระหว่างการประเมินเทียบกับเกณฑ์มาตรฐาน เมื่อตระหนักว่านี่เป็นงานที่ต้องใช้ความคิดมากและซ้ำซาก เขาจึงพยายามทำให้เป็นอัตโนมัติ ด้วยการนำหลักการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์มาใช้ร่วมกับ GitHub Copilot เขาได้สร้าง 'eval-agents' เพื่อวิเคราะห์วิถีการทำงานเหล่านี้ ซึ่งช่วยลดความพยายามที่ต้องทำด้วยตนเองลงได้อย่างมาก และเปลี่ยนงานวิเคราะห์ที่น่าเบื่อให้เป็นกระบวนการอัตโนมัติ"
- question: "องค์ประกอบสำคัญของการตั้งค่าการเขียนโค้ดแบบเอเจนต์สำหรับแนวทางนี้คืออะไร?" answer: "การตั้งค่าการเขียนโค้ดแบบเอเจนต์ที่มีประสิทธิภาพ ตามที่แสดงในแนวทางนี้ โดยทั่วไปจะประกอบด้วยเอเจนต์ AI สำหรับการเขียนโค้ดที่ทรงพลัง เช่น Copilot CLI, โมเดลภาษาขนาดใหญ่ที่แข็งแกร่ง เช่น Claude Opus 4.6 และสภาพแวดล้อมการพัฒนาแบบรวม (IDE) ที่มีฟีเจอร์ครบครัน เช่น VSCode สิ่งสำคัญคือการใช้ประโยชน์จาก SDK เช่น Copilot SDK ซึ่งช่วยให้เข้าถึงเครื่องมือ, เซิร์ฟเวอร์ และกลไกที่จำเป็นสำหรับการลงทะเบียนเครื่องมือและทักษะใหม่ ๆ ซึ่งเป็นโครงสร้างพื้นฐานสำหรับการสร้างและปรับใช้เอเจนต์โดยไม่ต้องสร้างฟังก์ชันการทำงานหลักขึ้นมาใหม่ สภาพแวดล้อมแบบรวมนี้ช่วยให้เกิดการโต้ตอบที่ราบรื่นระหว่างนักพัฒนาและเอเจนต์ AI ตลอดวงจรชีวิตของการพัฒนา"
- question: "กลยุทธ์การพร้อมต์แบบใดที่มีประสิทธิภาพมากที่สุดเมื่อทำงานกับเอเจนต์ AI สำหรับการเขียนโค้ด?" answer: "กลยุทธ์การพร้อมต์ที่มีประสิทธิภาพสำหรับเอเจนต์ AI สำหรับการเขียนโค้ดจะเน้นการโต้ตอบแบบสนทนา, การให้รายละเอียดมาก, และการวางแผน แทนที่จะใช้คำสั่งสั้น ๆ นักพัฒนาจะได้รับผลลัพธ์ที่ดีกว่าโดยการสนทนากับเอเจนต์, อธิบายสมมติฐานอย่างละเอียด, และใช้ประโยชน์จากความเร็วของ AI ในการวางแผนเบื้องต้นก่อนที่จะทำการเปลี่ยนแปลงโค้ด ซึ่งรวมถึงการใช้โหมดการวางแผน (เช่น '/plan') เพื่อระดมสมองหาแนวทางแก้ไขและปรับปรุงแนวคิดร่วมกัน การปฏิบัติต่อเอเจนต์ AI เหมือนวิศวกรฝึกหัดที่ได้รับประโยชน์จากคำแนะนำที่ชัดเจน, บริบท, และข้อเสนอแนะแบบวนซ้ำ จะช่วยให้เอเจนต์สร้างผลลัพธ์ที่แม่นยำและเกี่ยวข้องมากขึ้น ซึ่งนำไปสู่การแก้ปัญหาและการนำฟีเจอร์ไปใช้งานที่เหนือกว่า"
- question: "เหตุใดกลยุทธ์ทางสถาปัตยกรรม เช่น การปรับโครงสร้างโค้ดและการจัดทำเอกสาร จึงมีความสำคัญต่อการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์?" answer: "กลยุทธ์ทางสถาปัตยกรรม เช่น การปรับโครงสร้างโค้ดบ่อยครั้ง, การจัดทำเอกสารที่ครอบคลุม, และการทดสอบที่แข็งแกร่ง ล้วนมีความสำคัญสูงสุดในการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ เนื่องจากสิ่งเหล่านี้สร้างโค้ดเบสที่สะอาดและนำทางได้ง่าย ซึ่งเอเจนต์ AI สามารถทำความเข้าใจและโต้ตอบได้อย่างมีประสิทธิภาพ โค้ดเบสที่ได้รับการดูแลอย่างดี เช่นเดียวกับวิศวกรที่เป็นมนุษย์ จะช่วยให้เอเจนต์ AI สามารถสนับสนุนฟีเจอร์ได้อย่างแม่นยำและมีประสิทธิภาพมากขึ้น ด้วยการให้ความสำคัญกับการอ่านง่าย, รูปแบบที่สอดคล้องกัน, และเอกสารที่ทันสมัย นักพัฒนาจะมั่นใจได้ว่า Copilot สามารถตีความเจตนาของโค้ดเบส, ระบุโอกาสในการปรับปรุง, และนำการเปลี่ยนแปลงไปใช้โดยมีข้อผิดพลาดน้อยที่สุด ทำให้การส่งมอบฟีเจอร์เป็นเรื่องง่ายดาย และอำนวยความสะดวกในการปรับปรุงสถาปัตยกรรมอย่างต่อเนื่อง"
- question: "'วัฒนธรรมที่ไม่ตำหนิ' (blameless culture) นำมาประยุกต์ใช้กับกลยุทธ์การวนซ้ำในการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์อย่างไร?" answer: "การนำ 'วัฒนธรรมที่ไม่ตำหนิ' มาใช้กับการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ หมายถึงการเปลี่ยนจากการคิดแบบ 'เชื่อใจแต่ต้องตรวจสอบ' ไปสู่การให้ความสำคัญกับ 'ตำหนิกระบวนการ ไม่ใช่เอเจนต์' ปรัชญานี้ตระหนักดีว่าเอเจนต์ AI ก็เหมือนกับวิศวกรที่เป็นมนุษย์ ที่สามารถทำผิดพลาดได้ จากนั้น จุดเน้นจึงเปลี่ยนไปที่การนำกระบวนการและมาตรการป้องกันที่แข็งแกร่งมาใช้ เช่น การกำหนดชนิดข้อมูลอย่างเข้มงวด (strict typing), linters ที่ครอบคลุม, และการทดสอบแบบบูรณาการและแบบ end-to-end อย่างกว้างขวาง เพื่อป้องกันข้อผิดพลาด เมื่อเอเจนต์ทำผิดพลาด การตอบสนองคือการเรียนรู้จากข้อผิดพลาดนั้น และเพิ่มมาตรการป้องกันเพิ่มเติม ปรับปรุงกระบวนการและพร้อมต์ เพื่อให้แน่ใจว่าข้อผิดพลาดเดียวกันจะไม่เกิดขึ้นซ้ำ ซึ่งส่งเสริมให้เกิดการวนซ้ำที่รวดเร็วและปลอดภัยทางจิตใจ"
- question: "วงจรการพัฒนาโดยทั่วไปเมื่อใช้การพัฒนาแบบขับเคลื่อนด้วยเอเจนต์เป็นอย่างไร?" answer: "วงจรการพัฒนาโดยทั่วไปในการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์เริ่มต้นด้วยการวางแผนฟีเจอร์ใหม่ร่วมกับ Copilot โดยใช้พร้อมต์ '/plan' เพื่อให้แน่ใจว่าการทดสอบและการอัปเดตเอกสารได้ถูกรวมเข้าไว้ตั้งแต่แรก ถัดไป Copilot จะนำฟีเจอร์ไปใช้ ซึ่งมักจะใช้คำสั่ง '/autopilot' หลังจากนำไปใช้แล้ว วงจรการตรวจสอบจะเริ่มต้นด้วยเอเจนต์ Copilot Code Review โดยจัดการกับความคิดเห็นแบบวนซ้ำ ขั้นตอนสุดท้ายเกี่ยวข้องกับการตรวจสอบโดยมนุษย์เพื่อบังคับใช้รูปแบบและมาตรฐาน นอกเหนือจากวงจรฟีเจอร์นี้ Copilot จะถูกพร้อมต์เป็นระยะเพื่อตรวจสอบการทดสอบที่ขาดหายไป, การทำซ้ำโค้ด, หรือช่องว่างของเอกสาร เพื่อรักษาสภาพแวดล้อมที่ขับเคลื่อนด้วยเอเจนต์ให้ได้รับการปรับปรุงอย่างต่อเนื่อง"
- question: "การพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ส่งผลกระทบต่อประสิทธิภาพการทำงานและการทำงานร่วมกันของทีมอย่างไร?" answer: "ผลกระทบของการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ต่อประสิทธิภาพการทำงานและการทำงานร่วมกันของทีมนั้นเป็นการเปลี่ยนแปลงครั้งใหญ่ นำไปสู่กระบวนการวนซ้ำที่รวดเร็วอย่างไม่น่าเชื่อ ในกรณีหนึ่ง ทีมผู้สนับสนุนใหม่ห้าคน ใช้วิธีการนี้ สร้างเอเจนต์ใหม่ 11 ตัว, ทักษะใหม่ 4 อย่าง, และนำเวิร์กโฟลว์ที่ซับซ้อนไปใช้ได้ภายในเวลาไม่ถึงสามวัน ซึ่งคิดเป็นการเปลี่ยนแปลงโค้ดที่น่าทึ่งถึง +28,858/-2,884 บรรทัด ใน 345 ไฟล์ การเพิ่มผลผลิตอย่างมากนี้เน้นย้ำว่าการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ โดยการทำงานซ้ำ ๆ ให้เป็นอัตโนมัติและให้ความช่วยเหลืออย่างชาญฉลาด ช่วยเร่งการส่งมอบฟีเจอร์อย่างมีนัยสำคัญ ส่งเสริมการทำงานร่วมกันที่ลึกซึ้งยิ่งขึ้น และช่วยให้ทีมสามารถบรรลุระดับนวัตกรรมและประสิทธิภาพที่ไม่เคยมีมาก่อน"
## การทำงานที่ต้องใช้ความคิดให้เป็นอัตโนมัติด้วยเอเจนต์ AI
ในภูมิทัศน์วิศวกรรมซอฟต์แวร์ที่เปลี่ยนแปลงอย่างรวดเร็ว การแสวงหาประสิทธิภาพมักนำไปสู่นวัตกรรมที่ก้าวล้ำ Tyler McGoffin นักวิจัย AI ได้เล่าถึงการเดินทางที่แสดงถึงจิตวิญญาณนี้ นั่นคือการทำงานที่ต้องใช้ความคิดของเขาให้เป็นอัตโนมัติผ่านการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์โดยใช้ GitHub Copilot นี่ไม่ใช่แค่การเขียนโค้ดที่เร็วขึ้นเท่านั้น แต่เป็นการเปลี่ยนบทบาทของนักพัฒนาจากงานวิเคราะห์ที่ซ้ำซากไปสู่การแก้ปัญหาอย่างสร้างสรรค์และการกำกับดูแลเชิงกลยุทธ์ ประสบการณ์ของ McGoffin เน้นย้ำถึงรูปแบบที่คุ้นเคยในหมู่วิศวกร นั่นคือการสร้างเครื่องมือเพื่อกำจัดงานที่น่าเบื่อ แต่เขาได้ก้าวไปอีกขั้นด้วยการมอบหมายงานวิเคราะห์ที่ซับซ้อนซึ่งก่อนหน้านี้ไม่สามารถทำด้วยตนเองได้ให้กับเอเจนต์ AI
แรงบันดาลใจของ McGoffin มาจากแง่มุมที่สำคัญแต่หนักหน่วงในงานของเขา: การวิเคราะห์ประสิทธิภาพของเอเจนต์การเขียนโค้ดเทียบกับเกณฑ์มาตรฐาน เช่น TerminalBench2 และ SWEBench-Pro ซึ่งเกี่ยวข้องกับการวิเคราะห์ 'วิถีการทำงาน' (trajectories) — บันทึก JSON โดยละเอียดของกระบวนการคิดและการกระทำของเอเจนต์ — ซึ่งอาจมีโค้ดหลายแสนบรรทัดในงานและรอบการทดสอบเกณฑ์มาตรฐานจำนวนมาก แม้ว่า GitHub Copilot จะช่วยในการจดจำรูปแบบอยู่แล้ว แต่ลักษณะการทำงานซ้ำ ๆ ของวงจรการวิเคราะห์นี้ทำให้ต้องการระบบอัตโนมัติอย่างเต็มรูปแบบ สิ่งนี้นำไปสู่การสร้าง 'eval-agents' ซึ่งเป็นระบบที่ออกแบบมาเพื่อทำให้ภาระงานที่ต้องใช้ความคิดนี้เป็นอัตโนมัติ ช่วยให้ทีมของเขาใน Copilot Applied Science สามารถบรรลุประสิทธิภาพที่คล้ายกันได้
## พิมพ์เขียวสำหรับการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์
การเริ่มต้นของ 'eval-agents' ได้รับคำแนะนำจากชุดหลักการที่ชัดเจนซึ่งมุ่งเน้นไปที่การทำงานร่วมกันและความสามารถในการขยายขนาด McGoffin ตั้งเป้าที่จะทำให้เอเจนต์ AI เหล่านี้สามารถแบ่งปันได้ง่าย, สร้างได้ง่าย, และเป็นช่องทางหลักสำหรับการมีส่วนร่วมของทีม วัตถุประสงค์เหล่านี้สะท้อนถึงค่านิยมหลักของ GitHub โดยเฉพาะอย่างยิ่งที่ได้รับการขัดเกลาจากประสบการณ์ของเขาในฐานะผู้ดูแล OSS สำหรับ GitHub CLI อย่างไรก็ตาม เป้าหมายที่สาม—การทำให้เอเจนต์การเขียนโค้ดเป็นผู้มีส่วนร่วมหลัก—เป็นสิ่งที่กำหนดทิศทางของโครงการอย่างแท้จริงและปลดล็อกประโยชน์ที่ไม่คาดคิดสำหรับสองเป้าหมายแรก
การตั้งค่าการเขียนโค้ดแบบเอเจนต์ใช้ประโยชน์จากเครื่องมืออันทรงพลังหลายอย่างเพื่อปรับปรุงกระบวนการพัฒนา:
* **เอเจนต์สำหรับเขียนโค้ด**: Copilot CLI, ให้การโต้ตอบและการควบคุมโดยตรง
* **โมเดลที่ใช้**: Claude Opus 4.6, นำเสนอความสามารถในการให้เหตุผลขั้นสูงและการสร้างโค้ด
* **IDE**: VSCode, ทำหน้าที่เป็นพื้นที่ทำงานส่วนกลางสำหรับการพัฒนา
ที่สำคัญ Copilot SDK มีบทบาทสำคัญอย่างยิ่ง โดยให้การเข้าถึงเครื่องมือที่มีอยู่, เซิร์ฟเวอร์ MCP, และกลไกสำหรับการลงทะเบียนเครื่องมือและทักษะใหม่ ๆ รากฐานนี้ช่วยลดความจำเป็นในการสร้างฟังก์ชันการทำงานหลักของเอเจนต์ขึ้นมาใหม่ ทำให้ทีมสามารถมุ่งเน้นไปที่ตรรกะเฉพาะของแอปพลิเคชันได้ สภาพแวดล้อมแบบรวมนี้ส่งเสริมวงจรการพัฒนาที่รวดเร็ว พิสูจน์ให้เห็นว่าด้วยการตั้งค่าที่เหมาะสม เอเจนต์ AI ไม่เพียงแต่สามารถช่วยเหลือได้เท่านั้น แต่ยังสามารถขับเคลื่อนส่วนสำคัญของความพยายามในการพัฒนาได้ด้วย
## หลักการสำคัญสำหรับการเขียนโค้ดแบบเอเจนต์อย่างมีประสิทธิภาพ
การเปลี่ยนไปสู่กระบวนทัศน์ที่ขับเคลื่อนด้วยเอเจนต์นั้นไม่เพียงแต่ต้องการเครื่องมือเท่านั้น แต่ยังต้องการการเปลี่ยนแปลงในวิธีการทำงานด้วย McGoffin ได้ระบุหลักการสำคัญสามประการที่พิสูจน์แล้วว่ามีความสำคัญต่อการเร่งการพัฒนาและการส่งเสริมการทำงานร่วมกัน:
1. **กลยุทธ์การพร้อมต์**: การโต้ตอบกับเอเจนต์อย่างมีประสิทธิภาพหมายถึงการสนทนา, การให้รายละเอียดมาก, และการจัดลำดับความสำคัญของการวางแผน
2. **กลยุทธ์ทางสถาปัตยกรรม**: โค้ดเบสที่สะอาด, มีเอกสารประกอบอย่างดี, และได้รับการปรับโครงสร้างโค้ดมีความสำคัญสูงสุดสำหรับเอเจนต์ในการนำทางและสนับสนุนได้อย่างมีประสิทธิภาพ
3. **กลยุทธ์การวนซ้ำ**: การนำแนวคิด 'ตำหนิกระบวนการ ไม่ใช่เอเจนต์' มาใช้ คล้ายกับวัฒนธรรมที่ไม่ตำหนิ ทำให้สามารถทดลองและเรียนรู้ได้อย่างรวดเร็ว
เมื่อนำกลยุทธ์เหล่านี้ไปใช้อย่างสม่ำเสมอ ก็นำไปสู่ผลลัพธ์ที่น่าทึ่ง ในการยืนยันถึงประสิทธิภาพนี้ ผู้ร่วมให้ข้อมูลใหม่ห้าคน ภายในเวลาเพียงสามวัน ได้เพิ่มเอเจนต์ใหม่ 11 ตัว, ทักษะใหม่ 4 อย่าง, และนำแนวคิด 'เวิร์กโฟลว์ของ eval-agent' เข้ามาในโครงการ การทำงานร่วมกันอย่างรวดเร็วนี้ส่งผลให้เกิดการเปลี่ยนแปลงโค้ดที่โดดเด่นถึง **+28,858/-2,884 บรรทัด** ใน 345 ไฟล์ ซึ่งแสดงให้เห็นถึงผลกระทบอย่างลึกซึ้งของ [github-agentic-workflows](/th/github-agentic-workflows) ในทางปฏิบัติ
นี่คือบทสรุปของหลักการสำคัญ:
| หลักการ | คำอธิบาย | ประโยชน์ต่อการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ |
| :---------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- |
| **การพร้อมต์** | ปฏิบัติต่อเอเจนต์เหมือนวิศวกรอาวุโส: ชี้แนะความคิด, อธิบายสมมติฐานอย่างละเอียด, ใช้ประโยชน์จากโหมดการวางแผน (`/plan`) ก่อนการดำเนินการ สนทนาและให้รายละเอียด | นำไปสู่ผลลัพธ์ที่แม่นยำและเกี่ยวข้องมากขึ้น ช่วยให้เอเจนต์แก้ปัญหาที่ซับซ้อนได้อย่างมีประสิทธิภาพ |
| **สถาปัตยกรรม** | ให้ความสำคัญกับการปรับโครงสร้างโค้ด, การจัดทำเอกสารที่ครอบคลุม, และการทดสอบที่แข็งแกร่ง รักษาโค้ดเบสให้สะอาด, อ่านง่าย, และมีโครงสร้างที่ดี กำจัดโค้ดที่ไม่ได้ใช้อย่างกระตือรือร้น | ช่วยให้เอเจนต์เข้าใจโค้ดเบส, รูปแบบ, และฟังก์ชันการทำงานที่มีอยู่ ซึ่งช่วยให้การมีส่วนร่วมเป็นไปอย่างแม่นยำ |
| **การวนซ้ำ** | นำแนวคิด 'ตำหนิกระบวนการ ไม่ใช่เอเจนต์' มาใช้ ใช้มาตรการป้องกัน (การกำหนดชนิดข้อมูลอย่างเข้มงวด, linters, การทดสอบอย่างกว้างขวาง) เพื่อป้องกันข้อผิดพลาด เรียนรู้จากข้อผิดพลาดของเอเจนต์โดยการปรับปรุงกระบวนการและมาตรการป้องกัน | ส่งเสริมการวนซ้ำที่รวดเร็ว, สร้างความมั่นใจในการมีส่วนร่วมของเอเจนต์, และปรับปรุงกระบวนการพัฒนาอย่างต่อเนื่อง |
## เร่งการพัฒนา: กลยุทธ์ในการปฏิบัติ
ความสำเร็จของแนวทางที่ขับเคลื่อนด้วยเอเจนต์นี้มีรากฐานมาจากการประยุกต์ใช้หลักการเหล่านี้ในทางปฏิบัติ
### กลยุทธ์การพร้อมต์: การชี้แนะวิศวกร AI
เอเจนต์ AI สำหรับการเขียนโค้ด แม้จะทรงพลัง แต่ก็เก่งในปัญหาที่มีขอบเขตชัดเจน สำหรับงานที่ซับซ้อนมากขึ้น พวกเขาต้องการคำแนะนำ เช่นเดียวกับวิศวกรฝึกหัด McGoffin พบว่าการมีส่วนร่วมในรูปแบบการสนทนา, การอธิบายสมมติฐาน, และการใช้โหมดการวางแผนนั้นมีประสิทธิภาพมากกว่าคำสั่งสั้น ๆ มาก ตัวอย่างเช่น เมื่อเพิ่มการทดสอบการถดถอยที่แข็งแกร่ง พร้อมต์เช่น `/plan I've recently observed Copilot happily updating tests to fit its new paradigms even though those tests shouldn't be updated. How can I create a reserved test space that Copilot can't touch or must reserve to protect against regressions?` ได้เริ่มต้นบทสนทนาที่มีประสิทธิผล การโต้ตอบไปมานี้ มักจะเกิดขึ้นกับโมเดล [Claude Opus 4.6](/th/claude-opus-4-6) อันทรงพลัง นำไปสู่โซลูชันที่ซับซ้อน เช่น มาตรการป้องกันการทดสอบสัญญา (contract testing guardrails) ซึ่งมีเพียงวิศวกรที่เป็นมนุษย์เท่านั้นที่สามารถอัปเดตได้ ทำให้มั่นใจได้ว่าฟังก์ชันการทำงานที่สำคัญยังคงได้รับการปกป้อง
### กลยุทธ์ทางสถาปัตยกรรม: รากฐานของคุณภาพที่ขับเคลื่อนด้วย AI
สำหรับวิศวกรที่เป็นมนุษย์ การรักษาโค้ดเบสให้สะอาด, การเขียนการทดสอบ, และการจัดทำเอกสารฟีเจอร์ มักจะถูกลดความสำคัญลงภายใต้แรงกดดันจากฟีเจอร์ใหม่ ๆ ในการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ สิ่งเหล่านี้กลับกลายเป็นสิ่งสำคัญสูงสุด McGoffin ค้นพบว่าการใช้เวลาในการปรับโครงสร้างโค้ด, การจัดทำเอกสาร, และการเพิ่มกรณีทดสอบ ช่วยปรับปรุงความสามารถของ Copilot ในการนำทางและสนับสนุนโค้ดเบสได้อย่างมาก พื้นที่เก็บข้อมูลที่เน้นเอเจนต์จะเติบโตได้ด้วยความชัดเจน สิ่งนี้ช่วยให้นักพัฒนาสามารถพร้อมต์ Copilot ด้วยคำถามเช่น "จากสิ่งที่ฉันรู้ตอนนี้ ฉันจะออกแบบสิ่งนี้ให้แตกต่างออกไปได้อย่างไร?" เปลี่ยนการปรับโครงสร้างโค้ดเชิงทฤษฎีให้เป็นโครงการที่ทำได้จริงด้วยความช่วยเหลือจาก AI การมุ่งเน้นอย่างต่อเนื่องเกี่ยวกับสุขภาพทางสถาปัตยกรรมนี้ช่วยให้มั่นใจได้ว่าฟีเจอร์ใหม่ ๆ สามารถส่งมอบได้อย่างง่ายดาย
### กลยุทธ์การวนซ้ำ: เชื่อมั่นในกระบวนการ ไม่ใช่แค่เอเจนต์
วิวัฒนาการของโมเดล AI ได้เปลี่ยนกรอบความคิดจาก "เชื่อใจแต่ต้องตรวจสอบ" ไปสู่ท่าทีที่เชื่อใจมากขึ้น คล้ายกับวิธีที่ทีมที่มีประสิทธิภาพดำเนินงานด้วยปรัชญา "ตำหนิกระบวนการ ไม่ใช่คน" 'วัฒนธรรมที่ไม่ตำหนิ' ในการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์นี้ หมายความว่าเมื่อเอเจนต์ AI ทำผิดพลาด การตอบสนองคือการปรับปรุงกระบวนการและมาตรการป้องกันที่เกี่ยวข้อง ไม่ใช่การตำหนิเอเจนต์เอง ซึ่งเกี่ยวข้องกับการนำแนวทางปฏิบัติ CI/CD ที่เข้มงวดมาใช้: การกำหนดชนิดข้อมูลอย่างเข้มงวด (strict typing) เพื่อให้มั่นใจถึงความสอดคล้องของส่วนต่อประสาน, linters ที่แข็งแกร่งสำหรับคุณภาพโค้ด, และการทดสอบแบบบูรณาการ, end-to-end, และ contract test อย่างกว้างขวาง แม้ว่าการสร้างการทดสอบเหล่านี้ด้วยตนเองอาจมีค่าใช้จ่ายสูง แต่ความช่วยเหลือจากเอเจนต์ทำให้การนำไปใช้ถูกลงมาก ซึ่งให้ความมั่นใจที่สำคัญในการเปลี่ยนแปลงใหม่ ๆ ด้วยการตั้งค่าระบบเหล่านี้ นักพัฒนาจะช่วยให้ Copilot ตรวจสอบงานของตัวเองได้ ซึ่งสะท้อนให้เห็นว่าวิศวกรฝึกหัดถูกจัดเตรียมให้ประสบความสำเร็จได้อย่างไร
## การควบคุมวงจรการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์
การรวมหลักการเหล่านี้เข้ากับเวิร์กโฟลว์ที่ใช้งานได้จริงจะสร้างวงจรการพัฒนาที่ทรงพลังและรวดเร็วขึ้น:
1. **วางแผนร่วมกับ Copilot**: เริ่มต้นฟีเจอร์ใหม่โดยใช้ `/plan` ปรับปรุงแผนให้แน่ใจว่าการทดสอบและการอัปเดตเอกสารรวมอยู่ด้วยและเสร็จสิ้นก่อนการนำโค้ดไปใช้ เอกสารสามารถทำหน้าที่เป็นชุดแนวทางเพิ่มเติมสำหรับเอเจนต์ได้
2. **นำไปใช้ด้วย Autopilot**: ให้ Copilot นำฟีเจอร์ไปใช้โดยใช้ `/autopilot` ซึ่งใช้ประโยชน์จากความสามารถในการสร้างโค้ด
3. **ตรวจสอบด้วย Copilot Code Review**: พร้อมต์ Copilot เพื่อเริ่มต้นวงจรการตรวจสอบ ซึ่งเกี่ยวข้องกับการร้องขอเอเจนต์ Copilot Code Review, การจัดการกับความคิดเห็น, และการร้องขอการตรวจสอบซ้ำจนกว่าปัญหาจะได้รับการแก้ไข
4. **การตรวจสอบโดยมนุษย์**: ทำการตรวจสอบขั้นสุดท้ายโดยมนุษย์เพื่อให้แน่ใจว่ามีการบังคับใช้รูปแบบและการตัดสินใจที่ซับซ้อนสอดคล้องกับเจตนาเชิงกลยุทธ์
นอกเหนือจากวงจรฟีเจอร์นี้ การเพิ่มประสิทธิภาพอย่างต่อเนื่องเป็นสิ่งสำคัญ McGoffin พร้อมต์ Copilot เป็นประจำด้วยคำสั่งเช่น `/plan Review the code for any missing tests, any tests that may be broken, and dead code` หรือ `/plan Review the documentation and code to identify any documentation gaps.` การตรวจสอบเหล่านี้ ซึ่งดำเนินการเป็นรายสัปดาห์หรือเมื่อมีการรวมฟีเจอร์ใหม่ ๆ เข้ามา ช่วยให้สภาพแวดล้อมการพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ยังคงมีสุขภาพดีและมีประสิทธิภาพ
## อนาคตของวิศวกรรมซอฟต์แวร์ด้วย AI
สิ่งที่เริ่มต้นจากการแสวงหาส่วนตัวเพื่อทำให้งานวิเคราะห์ที่น่าหงุดหงิดเป็นอัตโนมัติ ได้พัฒนาไปสู่กระบวนทัศน์ใหม่สำหรับการพัฒนาซอฟต์แวร์ การพัฒนาแบบขับเคลื่อนด้วยเอเจนต์ ซึ่งขับเคลื่อนโดยเครื่องมืออย่าง GitHub Copilot และโมเดลขั้นสูงเช่น Claude Opus ไม่ใช่แค่การทำให้นักพัฒนาทำงานเร็วขึ้นเท่านั้น แต่เป็นการเปลี่ยนแปลงลักษณะการทำงานของนักวิจัย AI และวิศวกรซอฟต์แวร์โดยพื้นฐาน ด้วยการมอบหมายงานที่ต้องใช้ความคิดให้กับเอเจนต์อัจฉริยะ ทีมงานสามารถบรรลุระดับประสิทธิภาพการทำงาน, การทำงานร่วมกัน, และนวัตกรรมที่ไม่เคยมีมาก่อน โดยมุ่งเน้นไปที่ความท้าทายที่สร้างสรรค์และเชิงกลยุทธ์ที่ขับเคลื่อนความก้าวหน้าอย่างแท้จริง แนวทางนี้บ่งบอกถึงอนาคตที่น่าตื่นเต้นซึ่งเอเจนต์ AI ไม่ใช่แค่เครื่องมือ แต่เป็นสมาชิกที่สำคัญของทีมพัฒนา เปลี่ยนแปลงวิธีการสร้างและบำรุงรักษาซอฟต์แวร์ของเรา
แหล่งที่มา
https://github.blog/ai-and-ml/github-copilot/agent-driven-development-in-copilot-applied-science/คำถามที่พบบ่อย
What is agent-driven development in the context of GitHub Copilot?
Agent-driven development refers to a software engineering paradigm where AI agents, such as those powered by GitHub Copilot, become primary contributors and collaborators in the development process. Instead of merely suggesting code, these agents actively participate in planning, implementing, refactoring, testing, and documenting software. This approach leverages the AI's ability to automate repetitive intellectual tasks, allowing human engineers to focus on higher-level problem-solving, strategic design, and creative work, thereby accelerating development cycles and improving code quality through structured AI assistance and rigorous guardrails.
How did the 'eval-agents' project originate?
The 'eval-agents' project was born out of a common challenge faced by AI researchers: analyzing vast quantities of data. Tyler McGoffin, an AI researcher, found himself repeatedly poring over hundreds of thousands of lines of 'trajectories'—detailed logs of AI agent thought processes and actions during benchmark evaluations. Recognizing this as an intellectually toilsome and repetitive task, he sought to automate it. By applying agent-driven development principles with GitHub Copilot, he created 'eval-agents' to analyze these trajectories, significantly reducing the manual effort required and transforming a tedious analytical chore into an automated process.
What are the key components of an agentic coding setup for this approach?
An effective agentic coding setup, as demonstrated in this approach, typically includes a powerful AI coding agent like Copilot CLI, a robust underlying large language model such as Claude Opus 4.6, and a feature-rich Integrated Development Environment (IDE) like VSCode. Crucially, leveraging an SDK, such as the Copilot SDK, provides access to essential tools, servers, and mechanisms for registering new tools and skills, offering a foundational infrastructure for building and deploying agents without reinventing core functionalities. This integrated environment enables seamless interaction between the developer and the AI agent throughout the development lifecycle.
What prompting strategies are most effective when working with AI coding agents?
Effective prompting strategies for AI coding agents emphasize conversational, verbose, and planning-oriented interactions. Rather than terse problem statements, developers achieve better results by engaging agents in a dialogue, over-explaining assumptions, and leveraging the AI's speed for initial planning before committing to code changes. This involves using planning modes (e.g., '/plan') to collaboratively brainstorm solutions and refine ideas. Treating the AI agent like a junior engineer who benefits from clear guidance, context, and iterative feedback helps it to produce more accurate and relevant outputs, leading to superior problem-solving and feature implementation.
Why are architectural strategies like refactoring and documentation crucial for agent-driven development?
Architectural strategies like frequent refactoring, comprehensive documentation, and robust testing are paramount in agent-driven development because they create a clean, navigable codebase that AI agents can effectively understand and interact with. A well-maintained codebase, much like for human engineers, allows AI agents to contribute features more accurately and efficiently. By prioritizing readability, consistent patterns, and up-to-date documentation, developers ensure that Copilot can interpret the codebase's intent, identify opportunities for improvement, and implement changes with minimal errors, making feature delivery trivial and facilitating continuous re-architecture.
How does a 'blameless culture' apply to iteration strategies in agent-driven development?
Applying a 'blameless culture' to agent-driven development means shifting from a 'trust but verify' mindset to one that prioritizes 'blame process, not agents.' This philosophy acknowledges that AI agents, like human engineers, can make mistakes. The focus then shifts to implementing robust processes and guardrails—such as strict typing, comprehensive linters, and extensive integration and end-to-end tests—to prevent errors. When an agent does make a mistake, the response is to learn from it and introduce additional guardrails, refining the processes and prompts to ensure the same error isn't repeated, fostering a rapid and psychologically safe iteration pipeline.
What is the typical development loop when using agent-driven development?
The typical development loop in agent-driven development begins with planning a new feature collaboratively with Copilot using a '/plan' prompt, ensuring testing and documentation updates are integrated early. Next, Copilot implements the feature, often using an '/autopilot' command. Following implementation, a review loop is initiated with a Copilot Code Review agent, addressing comments iteratively. The final stage involves a human review to enforce patterns and standards. Outside this feature loop, Copilot is periodically prompted to review for missing tests, code duplication, or documentation gaps, maintaining a continuously optimized agent-driven environment.
What kind of impact did agent-driven development have on team productivity and collaboration?
The impact of agent-driven development on team productivity and collaboration was transformative, leading to an incredibly rapid iteration pipeline. In one instance, a team of five new contributors, using this methodology, created 11 new agents, four new skills, and implemented complex workflows in less than three days. This amounted to a staggering change of +28,858/-2,884 lines of code across 345 files. This dramatic increase in output highlights how agent-driven development, by automating routine tasks and providing intelligent assistance, significantly accelerates feature delivery, fosters deeper collaboration, and enables teams to achieve unprecedented levels of innovation and efficiency.
อัปเดตข่าวสาร
รับข่าว AI ล่าสุดในกล่องจดหมายของคุณ