ஏஜென்ட்-உந்துதல் மேம்பாடு: Copilot பயன்படுத்தப்பட்ட அறிவியலை சூப்பர்சார்ஜ் செய்தல்

AI ஏஜென்ட்களுடன் அறிவுசார் உழைப்பை தானியங்குபடுத்துதல்

மென்பொருள் பொறியியலின் வேகமாக வளர்ந்து வரும் நிலப்பரப்பில், செயல்திறனுக்கான தேடல் பெரும்பாலும் அற்புதமான கண்டுபிடிப்புகளுக்கு வழிவகுக்கிறது. AI ஆராய்ச்சியாளரான டய்லர் மெக்காஃபின், GitHub Copilot உடன் ஏஜென்ட்-உந்துதல் மேம்பாட்டின் மூலம் தனது அறிவுசார் உழைப்பை தானியங்குபடுத்திய ஒரு பயணத்தை சமீபத்தில் விவரித்தார். இது விரைவான குறியீட்டைப் பற்றியது மட்டுமல்ல; இது டெவலப்பரின் பங்கை மீண்டும் மீண்டும் செய்யும் பகுப்பாய்விலிருந்து ஆக்கப்பூர்வமான சிக்கல் தீர்வு மற்றும் மூலோபாய மேற்பார்வைக்கு அடிப்படையாக மாற்றுவதைப் பற்றியது. மெக்காஃபின் அனுபவம் பொறியாளர்களிடையே ஒரு பழக்கமான வடிவத்தை எடுத்துக்காட்டுகிறது - சலிப்பான வேலைகளை அகற்ற கருவிகளை உருவாக்குதல் - ஆனால் AI ஏஜென்ட்களிடம் முன்னர் கைமுறையாக அளவிட முடியாத சிக்கலான பகுப்பாய்வு பணிகளை ஒப்படைப்பதன் மூலம் ஒரு படி மேலே செல்கிறது.

மெக்காஃபினின் உத்வேகம் அவரது வேலையின் ஒரு முக்கியமான, ஆனால் overwhelming பகுதியிலிருந்து உருவானது: TerminalBench2 மற்றும் SWEBench-Pro போன்ற பெஞ்ச்மார்க்குகளுக்கு எதிராக கோடிங் ஏஜென்ட் செயல்திறனை பகுப்பாய்வு செய்தல். இது ஒரு ஏஜென்ட்டின் சிந்தனை செயல்முறைகள் மற்றும் செயல்களின் விரிவான JSON பதிவுகளான 'trajectory'களை ஆய்வு செய்வதை உள்ளடக்கியது - இது எண்ணற்ற பணிகள் மற்றும் பெஞ்ச்மார்க் ஓட்டங்களில் நூறாயிரக்கணக்கான வரிக் குறியீடுகளாக இருக்கலாம். 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' என்ற கருத்தை அறிமுகப்படுத்தினர். இந்த கூட்டுப்பணி விரைவான முயற்சியின் விளைவாக, 345 கோப்புகளில் +28,858/-2,884 வரிக் குறியீடு மாற்றம் ஏற்பட்டது, இது 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 நடைமுறைகளை செயல்படுத்துவது அடங்கும்: இடைமுக ஒருமைப்பாட்டை உறுதிப்படுத்த கடுமையான டைப்பிங், குறியீட்டின் தரத்திற்காக வலுவான லின்டர்கள் மற்றும் விரிவான ஒருங்கிணைப்பு, இறுதி முதல் இறுதி வரை, மற்றும் ஒப்பந்த சோதனைகள். இந்த சோதனைகளை கைமுறையாக உருவாக்குவது விலை உயர்ந்ததாக இருந்தாலும், ஏஜென்ட் உதவி அவற்றை செயல்படுத்துவதற்கு மிகவும் மலிவாக ஆக்குகிறது, புதிய மாற்றங்களில் முக்கியமான நம்பிக்கையை வழங்குகிறது. இந்த அமைப்புகளை அமைப்பதன் மூலம், டெவலப்பர்கள் Copilot தனது சொந்த வேலையை சரிபார்க்க அதிகாரம் அளிக்கிறார்கள், இது ஒரு இளைய பொறியாளர் எப்படி வெற்றிக்கு தயார்படுத்தப்படுகிறாரோ அதையே பிரதிபலிக்கிறது.

ஏஜென்ட்-உந்துதல் மேம்பாட்டு சுழற்சியில் தேர்ச்சி பெறுதல்

இந்தக் கோட்பாடுகளை ஒரு நடைமுறை பணிப்பாய்வில் ஒருங்கிணைப்பது ஒரு சக்திவாய்ந்த, விரைவான மேம்பாட்டு சுழற்சியை உருவாக்குகிறது:

Copilot உடன் திட்டமிடுங்கள்: /plan ஐப் பயன்படுத்தி புதிய அம்சங்களைத் தொடங்கவும். திட்டத்தை மீண்டும் செய்யவும், சோதனைகள் மற்றும் ஆவணப்படுத்தல் புதுப்பிப்புகள் குறியீடு செயல்படுத்தப்படுவதற்கு முன்பே சேர்க்கப்பட்டு முடிக்கப்படுவதை உறுதிசெய்யவும். ஆவணப்படுத்தல் ஏஜென்ட்டிற்கு கூடுதல் வழிகாட்டுதல்களாக செயல்படலாம்.
Autopilot உடன் செயல்படுத்தவும்: /autopilot ஐப் பயன்படுத்தி அம்சத்தைச் செயல்படுத்த Copilot ஐ அனுமதிக்கவும், அதன் குறியீடு உருவாக்கும் திறன்களைப் பயன்படுத்தவும்.
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 செய்திகளை மின்னஞ்சலில் பெறுங்கள்.

பகிர்