აგენტით მართული განვითარება: Copilot გამოყენებითი მეცნიერების გაძლიერება

ინტელექტუალური შრომის ავტომატიზაცია AI აგენტებით

პროგრამული ინჟინერიის სწრაფად განვითარებად ლანდშაფტში, ეფექტურობისკენ სწრაფვა ხშირად იწვევს გარღვევის ინოვაციებს. ტაილერ მაკგოფინმა, AI მკვლევარმა, ცოტა ხნის წინ დეტალურად აღწერა მოგზაურობა, რომელიც განასახიერებს ამ სულს: საკუთარი ინტელექტუალური შრომის ავტომატიზაცია აგენტით მართული განვითარების მეშვეობით GitHub Copilot-თან ერთად. ეს არ არის მხოლოდ უფრო სწრაფი კოდირება; ეს ფუნდამენტურად ცვლის დეველოპერის როლს განმეორებადი ანალიზიდან შემოქმედებით პრობლემების გადაჭრასა და სტრატეგიულ ზედამხედველობაზე. მაკგოფინის გამოცდილება ხაზს უსვამს ინჟინრებს შორის ნაცნობ ნიმუშს – ხელსაწყოების შექმნა რუტინული სამუშაოს აღმოსაფხვრელად – მაგრამ ერთი ნაბიჯით წინ მიდის AI აგენტებისთვის რთული ანალიტიკური ამოცანების მინდობით, რომელთა ხელით მასშტაბირება ადრე შეუძლებელი იყო.

მაკგოფინის შთაგონება მისი სამუშაოს კრიტიკული, თუმცა გადამეტებული ასპექტიდან მომდინარეობდა: კოდირების აგენტის მუშაობის ანალიზი ისეთი ბენჩმარკების მიმართ, როგორიცაა TerminalBench2 და SWEBench-Pro. ეს მოიცავდა 'ტრაექტორიების' – აგენტის აზროვნების პროცესებისა და მოქმედებების დეტალური JSON ჟურნალების – დაშლას, რაც შეიძლება ასობით ათას კოდის ხაზს შეადგენდეს მრავალრიცხოვან ამოცანებსა და ბენჩმარკის გაშვებებში. მიუხედავად იმისა, რომ GitHub Copilot უკვე ეხმარებოდა შაბლონების ამოცნობაში, ამ ანალიტიკური ციკლის განმეორებადი ბუნება სრულ ავტომატიზაციას ითხოვდა. ამან განაპირობა 'eval-agents'-ის შექმნა, სისტემა, რომელიც შექმნილია ამ ინტელექტუალური ტვირთის ავტომატიზაციისთვის, რაც მის გუნდს Copilot გამოყენებით მეცნიერებაში საშუალებას აძლევს, მიაღწიოს მსგავს ეფექტურობას.

აგენტით მართული განვითარების გეგმა

'eval-agents'-ის შექმნა ხელმძღვანელობდა პრინციპების მკაფიო ნაკრებით, რომელიც ფოკუსირებული იყო თანამშრომლობასა და მასშტაბურობაზე. მაკგოფინის მიზანი იყო, რომ ეს AI აგენტები მარტივი ყოფილიყო გასაზიარებლად, მარტივი შესაქმნელად და გუნდური კონტრიბუციების ძირითადი საშუალება. ეს მიზნები ასახავს GitHub-ის ძირითად ღირებულებებს, განსაკუთრებით იმას, რაც მისი გამოცდილების დროს დაიხვეწა, როგორც GitHub CLI-ის OSS შემანარჩუნებელი. თუმცა, სწორედ მესამე მიზანმა – კოდირების აგენტების ძირითად კონტრიბუტორად ქცევა – განსაზღვრა პროექტის მიმართულება და მოუტანა მოულოდნელი სარგებელი პირველ ორს.

აგენტური კოდირების სისტემამ გამოიყენა რამდენიმე მძლავრი ხელსაწყო განვითარების პროცესის გასამარტივებლად:

კოდირების აგენტი: Copilot CLI, რომელიც უზრუნველყოფს პირდაპირ ურთიერთქმედებას და კონტროლს.
გამოყენებული მოდელი: Claude Opus 4.6, რომელიც გვთავაზობს გაუმჯობესებულ მსჯელობისა და კოდის გენერაციის შესაძლებლობებს.
IDE: VSCode, რომელიც ემსახურება როგორც ცენტრალური სამუშაო სივრცე განვითარებისთვის.

გადამწყვეტი მნიშვნელობა ჰქონდა Copilot SDK-ს, რომელიც უზრუნველყოფდა არსებულ ინსტრუმენტებზე, MCP სერვერებზე და ახალი ინსტრუმენტებისა და უნარების რეგისტრაციის მექანიზმებზე წვდომას. ამ ფუნდამენტმა გამორიცხა ძირითადი აგენტური ფუნქციონალის ხელახალი გამოგონების საჭიროება, რაც გუნდს საშუალებას აძლევდა, ფოკუსირება მოეხდინა აპლიკაცია-სპეციფიკურ ლოგიკაზე. ამ ინტეგრირებულმა გარემომ ხელი შეუწყო სწრაფ განვითარების ციკლს, რაც ამტკიცებდა, რომ სწორი დაყენებით, AI აგენტებს შეეძლოთ არა მხოლოდ დახმარება, არამედ განვითარების ძალისხმევის მნიშვნელოვანი ნაწილის წარმართვა.

ეფექტური აგენტური კოდირების ძირითადი პრინციპები

აგენტით მართულ პარადიგმაზე გადასვლა მოითხოვს არა მხოლოდ ინსტრუმენტებს; ის მოითხოვს მეთოდოლოგიის შეცვლას. მაკგოფინმა გამოავლინა სამი ძირითადი პრინციპი, რომელიც ფუნდამენტური აღმოჩნდა განვითარების დასაჩქარებლად და თანამშრომლობის გასაძლიერებლად:

პრომპტინგის სტრატეგიები: აგენტებთან ეფექტური ურთიერთქმედება ნიშნავს საუბრის რეჟიმში ყოფნას, სიტყვიერებას და დაგეგმვის პრიორიტეტულობას.
არქიტექტურული სტრატეგიები: სუფთა, კარგად დოკუმენტირებული და რეფაქტორირებული კოდის ბაზა უმნიშვნელოვანესია იმისთვის, რომ აგენტებმა შეძლონ მისი ეფექტურად ნავიგაცია და მასში წვლილის შეტანა.
იტერაციის სტრატეგიები: აზროვნების 'პროცესის დადანაშაულება, არა აგენტების' მიღება, უდანაშაულობის კულტურის მსგავსად, ხელს უწყობს სწრაფ ექსპერიმენტებსა და სწავლას.

ეს სტრატეგიები, თანმიმდევრულად გამოყენებისას, გასაოცარ შედეგებს იძლეოდა. ამ ეფექტურობის დასტურად, ხუთმა ახალმა კონტრიბუტორმა, სულ რაღაც სამ დღეში, ერთობლივად დაამატა 11 ახალი აგენტი, ოთხი ახალი უნარი და შემოიტანა 'eval-agent workflows'-ის კონცეფცია პროექტში. ამ ერთობლივმა სპრინტმა გამოიწვია კოდის გასაოცარი +28,858/-2,884 ხაზის ცვლილება 345 ფაილზე, რაც პრაქტიკაში github-agentic-workflows-ის ღრმა გავლენას აჩვენებს.

აქ მოცემულია ძირითადი პრინციპების შეჯამება:

პრინციპი	აღწერა	სარგებელი აგენტით მართული განვითარებისთვის
პრომპტინგი	მოეპყარით აგენტებს, როგორც უფროს ინჟინრებს: უხელმძღვანელეთ მათ აზროვნებას, ზედმეტად ახსენით ვარაუდები, გამოიყენეთ დაგეგმვის რეჟიმები (`/plan`) შესრულებამდე. იყავით სასაუბრო და დეტალური.	იწვევს უფრო ზუსტ და რელევანტურ შედეგებს, ეხმარება აგენტებს რთული პრობლემების ეფექტურად გადაჭრაში.
არქიტექტურული	პრიორიტეტი მიანიჭეთ რეფაქტორინგს, ყოვლისმომცველ დოკუმენტაციას და მყარ ტესტირებას. შეინახეთ კოდის ბაზა სუფთა, წაკითხვადი და კარგად სტრუქტურირებული. აქტიურად გაასუფთავეთ მკვდარი კოდი.	აგენტებს საშუალებას აძლევს, გაიგონ კოდის ბაზა, შაბლონები და არსებული ფუნქციონალი, რაც ხელს უწყობს ზუსტ კონტრიბუციებს.
იტერაცია	მიიღეთ აზროვნება 'პროცესის დადანაშაულება, არა აგენტების'. დანერგეთ გარანტიები (მკაცრი ტიპის განსაზღვრა, ლინტერები, ფართო ტესტები) შეცდომების თავიდან ასაცილებლად. ისწავლეთ აგენტების შეცდომებიდან პროცესებისა და გარანტიების გაუმჯობესებით.	ხელს უწყობს სწრაფ იტერაციას, აგენტების წვლილისადმი ნდობას და განვითარების მილსადენის უწყვეტ გაუმჯობესებას.

განვითარების დაჩქარება: სტრატეგიები მოქმედებაში

ამ აგენტით მართული მიდგომის წარმატება ამ პრინციპების პრაქტიკულ გამოყენებაშია ფესვგადგმული.

პრომპტინგის სტრატეგიები: AI ინჟინრის ხელმძღვანელობა

AI კოდირების აგენტები, მიუხედავად იმისა, რომ მძლავრია, გამოირჩევიან კარგად განსაზღვრული პრობლემების გადაჭრაში. უფრო რთული ამოცანებისთვის მათ სჭირდებათ ხელმძღვანელობა, ისევე როგორც უმცროს ინჟინრებს. მაკგოფინმა აღმოაჩინა, რომ სასაუბრო სტილში ჩართვა, ვარაუდების ახსნა და დაგეგმვის რეჟიმების გამოყენება ბევრად უფრო ეფექტური იყო, ვიდრე მოკლე ბრძანებები. მაგალითად, მყარი რეგრესიული ტესტების დამატებისას, პრომპტმა, როგორიცაა /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 მოდელთან ერთად, მიგვიყვანა დახვეწილ გადაწყვეტილებებამდე, როგორიცაა კონტრაქტის ტესტირების გარანტიები, რომელთა განახლება მხოლოდ ადამიანის ინჟინრებს შეეძლოთ, რაც უზრუნველყოფდა კრიტიკული ფუნქციონალის დაცვას.

არქიტექტურული სტრატეგიები: AI-ის დახმარებით მიღებული ხარისხის საფუძველი

ადამიანის ინჟინრებისთვის, სუფთა კოდის ბაზის შენარჩუნება, ტესტების დაწერა და ფუნქციების დოკუმენტირება ხშირად უკანა პლანზე გადადის ფუნქციების დანერგვის ზეწოლის ქვეშ. აგენტით მართულ განვითარებაში ესენი უმნიშვნელოვანესი ხდება. მაკგოფინმა აღმოაჩინა, რომ რეფაქტორინგზე, დოკუმენტირებაზე და ტესტ-ქეისების დამატებაზე დახარჯულმა დრომ დრამატულად გააუმჯობესა Copilot-ის უნარი, ნავიგაცია მოეხდინა კოდის ბაზაში და წვლილი შეეტანა მასში. აგენტით ორიენტირებული რეპოზიტორიუმი ეფუძნება სიცხადეს. ეს დეველოპერებს საშუალებას აძლევს, Copilot-ს კითხვებიც კი დაუსვან, მაგალითად, "იმის ცოდნით, რაც ახლა ვიცი, როგორ შევცვლიდი ამის დიზაინს?", რაც თეორიულ რეფაქტორინგს ხელმისაწვდომ პროექტებად აქცევს AI-ის დახმარებით. არქიტექტურულ ჯანმრთელობაზე უწყვეტი ფოკუსირება უზრუნველყოფს, რომ ახალი ფუნქციები უპრობლემოდ მიწოდებული იქნება.

იტერაციის სტრატეგიები: ენდობა პროცესს და არა მხოლოდ აგენტს

AI მოდელების ევოლუციამ შეცვალა აზროვნება "ენდე, მაგრამ გადაამოწმე"-დან უფრო სანდო პოზიციაზე, ანალოგიურად იმისა, თუ როგორ მუშაობენ ეფექტური გუნდები "პროცესის დადანაშაულების, არა ადამიანების" ფილოსოფიით. ეს "უდანაშაულობის კულტურა" აგენტით მართულ განვითარებაში ნიშნავს, რომ როდესაც AI აგენტი შეცდომას უშვებს, პასუხი არის ძირითადი პროცესებისა და გარანტიების გაუმჯობესება, ვიდრე თავად აგენტის დადანაშაულება. ეს მოიცავს მკაცრი CI/CD პრაქტიკის დანერგვას: მკაცრი ტიპის განსაზღვრა ინტერფეისის შესაბამისობის უზრუნველსაყოფად, მყარი ლინტერები კოდის ხარისხისთვის და ფართო ინტეგრაციული, end-to-end და კონტრაქტული ტესტები. მიუხედავად იმისა, რომ ამ ტესტების ხელით აგება შეიძლება ძვირი იყოს, აგენტის დახმარება მათ განხორციელებას ბევრად აიაფებს, რაც უზრუნველყოფს კრიტიკულ ნდობას ახალი ცვლილებების მიმართ. ამ სისტემების დაყენებით, დეველოპერები Copilot-ს აძლევენ უფლებას, შეამოწმოს საკუთარი ნამუშევარი, რაც ასახავს იმას, თუ როგორ ემზადება უმცროსი ინჟინერი წარმატებისთვის.

აგენტით მართული განვითარების ციკლის დაუფლება

ამ პრინციპების პრაქტიკულ სამუშაო პროცესში ინტეგრირება ქმნის მძლავრ, დაჩქარებულ განვითარების ციკლს:

დაგეგმვა Copilot-თან ერთად: ახალი ფუნქციების ინიცირება /plan-ის გამოყენებით. გეგმის იტერაცია, ტესტებისა და დოკუმენტაციის განახლებების ჩართვა და დასრულება კოდის განხორციელებამდე. დოკუმენტაცია შეიძლება იყოს აგენტისთვის დამატებითი მითითებების ნაკრები.
დანერგვა Autopilot-ით: მიეცით Copilot-ს ფუნქციის დანერგვის უფლება /autopilot-ის გამოყენებით, მისი კოდის გენერაციის შესაძლებლობების გამოყენებით.
განხილვა Copilot Code Review-თან ერთად: სთხოვეთ Copilot-ს, წამოიწყოს განხილვის ციკლი. ეს მოიცავს Copilot Code Review აგენტის მოთხოვნას, მისი კომენტარების განხილვას და განხილვების ხელახლა მოთხოვნას მანამ, სანამ საკითხები არ გადაწყდება.
ადამიანური განხილვა: ჩაატარეთ საბოლოო ადამიანური განხილვა იმის უზრუნველსაყოფად, რომ შაბლონები დაცულია და რთული გადაწყვეტილებები შეესაბამება სტრატეგიულ მიზანს.

ფუნქციური ციკლის მიღმა, უწყვეტი ოპტიმიზაცია მთავარია. მაკგოფინი რუტინულად სთხოვს 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 სიახლეები ელფოსტაზე.

გაზიარება