การประมวลผลด้วย AI: จุดสิ้นสุดของ 'AI ในรูปแบบข้อความ' สำหรับซอฟต์แวร์

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

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

จากสคริปต์แบบคงที่สู่เวิร์กโฟลว์แบบ Agentic ที่ปรับเปลี่ยนได้

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

GitHub Copilot SDK ปลดปล่อยแอปพลิเคชันจากข้อจำกัดเหล่านี้โดยอนุญาตให้มอบหมายเจตนาแทนที่จะเข้ารหัสทุกขั้นตอนอย่างชัดเจน ลองนึกภาพแอปพลิเคชันที่ต้องการ "เตรียมที่เก็บข้อมูลนี้สำหรับการเผยแพร่" แทนที่จะเป็นสคริปต์ที่ตายตัว Copilot SDK ช่วยให้เอเจนต์ AI สามารถ:

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

การเปลี่ยนแปลงนี้มีความสำคัญต่อระบบซอฟต์แวร์สมัยใหม่ เมื่อแอปพลิเคชันขยายขนาดและสภาพแวดล้อมมีการพัฒนา เวิร์กโฟลว์ที่ตายตัวมักจะล้มเหลว การประมวลผลแบบ Agentic ซึ่งขับเคลื่อนโดย Copilot SDK ช่วยให้ซอฟต์แวร์สามารถปรับตัวและแก้ไขตนเองได้ รักษาการสังเกตการณ์และข้อจำกัดโดยไม่ต้องแบกรับภาระในการสร้างการจัดระเบียบที่ซับซ้อนขึ้นใหม่ตลอดเวลา สิ่งนี้ทำให้ AI เป็นผู้มีส่วนร่วมที่กระตือรือร้นและชาญฉลาดในวงจรการพัฒนา ก้าวข้ามการเติมโค้ดพื้นฐานไปสู่การทำงานอัตโนมัติแบบอัจฉริยะ สำหรับข้อมูลเชิงลึกเพิ่มเติมเกี่ยวกับวิธีการรักษาความปลอดภัยเวิร์กโฟลว์ที่ซับซ้อนเหล่านี้ โปรดดู สถาปัตยกรรมความปลอดภัยของ GitHub Agentic Workflows

บริบทที่มีโครงสร้างสำหรับ AI ที่น่าเชื่อถือ: Model Context Protocol (MCP)

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

GitHub Copilot SDK จัดการกับปัญหานี้ด้วยแนวทางที่มีโครงสร้างและประกอบได้กับบริบท โดยใช้ประโยชน์จาก Model Context Protocol (MCP) ด้วย MCP นักพัฒนาสามารถ:

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

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

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

AI ในฐานะโครงสร้างพื้นฐาน: การฝังการประมวลผลนอกเหนือจาก IDE

ในอดีต เครื่องมือ AI สำหรับนักพัฒนาส่วนใหญ่มักถูกจำกัดอยู่แค่ Integrated Development Environment (IDE) แม้จะมีคุณค่าสำหรับการเขียนโค้ด แต่ระบบนิเวศของซอฟต์แวร์สมัยใหม่ขยายออกไปไกลกว่าแค่ตัวแก้ไขเดียว ทีมงานต้องการความสามารถแบบ Agentic ในสภาพแวดล้อมที่หลากหลาย: แอปพลิเคชันเดสก์ท็อป เครื่องมือปฏิบัติการภายใน บริการพื้นหลัง แพลตฟอร์ม SaaS และระบบที่ขับเคลื่อนด้วยเหตุการณ์

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

คุณสมบัติ	ยุค "AI ในรูปแบบข้อความ"	ยุค "AI ในรูปแบบการประมวลผล" (Copilot SDK)
การโต้ตอบ	อินพุตข้อความ, เอาต์พุตข้อความ	วงจรการประมวลผลที่ตั้งโปรแกรมได้
เวิร์กโฟลว์	การตัดสินใจด้วยตนเอง, สคริปต์ที่เปราะบาง	เอเจนต์ที่ปรับตัวได้, แก้ไขตนเองได้
บริบท	มักฝังอยู่ในพรอมต์ (เปราะบาง)	มีโครงสร้างผ่าน MCP, ดึงข้อมูลแบบเรียลไทม์
การบูรณาการ	การแลกเปลี่ยนแบบแยก, เน้น IDE	ฝังได้ทุกที่ (แอป, บริการ, SaaS)
บทบาทนักพัฒนา	การทำ Prompt Engineering, การจัดระเบียบด้วยตนเอง	การกำหนดเจตนา, ข้อจำกัด, เครื่องมือ
หลักการสำคัญ	AI ให้คำแนะนำ, มนุษย์ประมวลผล	AI วางแผนและประมวลผล, มนุษย์ดูแล

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

การเปลี่ยนแปลงเชิงสถาปัตยกรรม: AI ที่ตั้งโปรแกรมได้และอนาคต

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

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

แหล่งที่มา

https://github.blog/ai-and-ml/github-copilot/the-era-of-ai-as-text-is-over-execution-is-the-new-interface/

คำถามที่พบบ่อย

What is the core shift from 'AI as text' to 'AI as execution' introduced by the GitHub Copilot SDK?

The fundamental shift signifies a move from AI systems that merely generate text output from text input, requiring manual human intervention for the next steps, to systems where AI can actively plan, execute, adapt, and recover from errors within a predefined set of constraints. This means AI transitions from a passive assistant to an active participant, capable of orchestrating complex, multi-step operations directly within software applications, making it a functional component rather than just a conversational interface. The Copilot SDK provides the tools to embed this execution layer into any application.

How does the GitHub Copilot SDK enable sophisticated agentic workflows within applications?

The GitHub Copilot SDK empowers applications by providing access to the same production-tested planning and execution engine that drives GitHub Copilot CLI. Instead of building complex orchestration stacks from scratch, developers can embed this SDK to delegate intent to AI agents. These agents can explore repositories, plan necessary steps, modify files, run commands, and adapt to unforeseen issues—all while respecting defined boundaries. This allows software to become more adaptive and resilient, moving beyond rigid, scripted workflows to dynamic, context-aware operations.

What is the Model Context Protocol (MCP) and why is it crucial for grounded AI execution?

The Model Context Protocol (MCP) is a vital component that enables structured and composable context for AI agents. Rather than embedding critical system logic and data within prompts—a practice that leads to brittle, hard-to-test workflows—MCP allows applications to define domain-specific tools and agent skills. The execution engine then uses MCP to retrieve relevant context directly at runtime, such as service ownership data, API schemas, or dependency rules. This ensures that AI agents operate on real, permissioned data and systems, preventing guesswork and making AI workflows more reliable and maintainable.

Beyond the Integrated Development Environment (IDE), where can the GitHub Copilot SDK embed AI execution?

The GitHub Copilot SDK liberates AI execution from being confined primarily to the IDE, allowing it to function as a pervasive application-layer capability. This means agentic capabilities can be seamlessly integrated into a wide array of environments, including desktop applications, internal operational tools, background services, SaaS platforms, and event-driven systems. By enabling applications to programmatically invoke Copilot upon specific events—like a file change, deployment trigger, or user action—the SDK transforms AI from a mere helper in a side window into core infrastructure that operates wherever the software runs.

What are the primary benefits of delegating multi-step tasks to AI agents using the Copilot SDK?

Delegating multi-step tasks to AI agents via the Copilot SDK offers significant advantages over traditional scripting. It allows software to handle workflows that are context-dependent, change dynamically mid-run, or require robust error recovery, which typically break down fixed scripts. By delegating 'intent' rather than explicit steps, agents can autonomously explore, plan, execute, and adapt within defined constraints. This leads to more scalable, adaptable, and observable systems, freeing developers from continually rebuilding bespoke orchestration layers for complex, evolving processes.

How does the Copilot SDK improve the reliability and adaptability of AI-powered systems?

The Copilot SDK enhances reliability and adaptability by providing a robust execution layer and integrating structured context. Its production-tested planning and execution engine ensures agents can plan complex operations, execute commands, modify files, and recover from errors, making systems more resilient. Furthermore, by utilizing the Model Context Protocol (MCP), agents access real-time, structured, and permissioned context—like API schemas or dependency graphs—rather than relying on potentially outdated or generalized prompt information. This grounding in real data ensures agents make informed decisions, reducing errors and increasing the system's ability to adapt to changing conditions and constraints.

Is the GitHub Copilot SDK primarily for professional developers, or can others benefit from its capabilities?

While the GitHub Copilot SDK is designed to empower professional developers by extending agentic AI capabilities into their applications and infrastructure, its benefits ripple outwards. By enabling AI to handle complex, multi-step tasks and integrate directly into various software systems, it streamlines workflows, reduces manual effort, and enhances the adaptability of applications. This ultimately benefits end-users and organizations by leading to more efficient, intelligent, and robust software, even if the direct interaction with the SDK is primarily on the developer's side. The SDK makes AI a fundamental infrastructure component across the software ecosystem.

อัปเดตข่าวสาร

รับข่าว AI ล่าสุดในกล่องจดหมายของคุณ

แชร์