𝗔𝗜 குறியீட்டை எழுதுகிறது. அதற்குத் தேவையான சூழலை (context) வழங்குவது யார்?

AI-ஆல் குறியீட்டை எழுத முடியும். ஆனால் அதற்கு உங்கள் சிஸ்டம் (system) பற்றித் தெரியாது.

நீங்கள் கோடிங்கிற்கு AI-ஐப் பயன்படுத்தும்போது, முதல் பதில் அரிதாகவே சிறந்ததாக இருக்கும். நீங்கள் சூழலை (context) சேர்க்க வேண்டும். தவறுகளைத் திருத்த வேண்டும். நீங்கள் ஏற்கனவே என்ன முயற்சித்தீர்கள் என்பதை விளக்க வேண்டும்.

இந்தச் செயல்முறை 'context engineering' என்று அழைக்கப்படுகிறது. மென்பொருள் பொறியியலில் (software engineering) AI-ஐப் பயன்படுத்துவதில் இதுவே மிக முக்கியமான பகுதியாகும்.

AI நம்பத்தகுந்த குறியீட்டை உருவாக்குகிறது. அது சரியாகத் தோன்றும். அது சோதனைகளில் (tests) கூட வெற்றி பெறலாம். ஆனால் மென்பொருள் என்பது தனித்து இயங்குவதல்ல. அது உங்கள் குறிப்பிட்ட சூழலுக்குப் பொருந்த வேண்டும்.

ஒரு AI-க்கு தானாகவே இவை தெரியாது:

  • கட்டமைப்பு விதிகள் (Architecture rules)
  • பாதுகாப்புத் தேவைகள் (Security needs)
  • ஏற்கனவே உள்ள முறைகள் (Existing patterns)
  • டொமைன் லாஜிக் (Domain logic)
  • தொழில்நுட்ப முடிவுகள் (Technical decisions)

நீங்கள் இந்தச் சூழலை வழங்கவில்லை என்றால், நீங்கள் சிக்கல்களை உருவாக்குகிறீர்கள்.

ஒரு பெரிய ஆபத்து நகல் உருவாக்கம் (duplication). உங்களிடம் ஏற்கனவே ஒரு validation helper அல்லது ஒரு குறிப்பிட்ட error handler இருப்பதை AI அறியாது. அது எளிதாகப் புதிய ஒன்றை உருவாக்கிவிடும். இப்போது உங்கள் சிஸ்டத்தில் ஒரே சிக்கலைத் தீர்க்க இரண்டு வழிகள் இருக்கும். இது 'not repeating yourself' என்ற விதியை மீறுகிறது.

நீங்கள் வேகத்திற்காக மட்டும் மேம்படுத்தினால் (optimize), உங்கள் எதிர்காலத்தைத் தாமதப்படுத்துகிறீர்கள் என்று அர்த்தம். நீங்கள் அம்சங்களை (features) வேகமாக வெளியிடலாம், ஆனால் உங்கள் சிஸ்டத்தை மாற்றுவது கடினமாகிவிடும்.

இதைச் சரிசெய்ய, பொறியியல் அறிவை (engineering knowledge) குறியீடு போலவே நீங்கள் கையாள வேண்டும். அது பின்வருவனவற்றைக் கொண்டிருக்க வேண்டும்:

  • பதிப்புப்படுத்தப்பட்ட (Versioned)
  • மறுஆய்வு செய்யப்பட்ட (Reviewed)
  • உரிமையுடைமை கொண்ட (Owned)
  • புதுப்பித்த நிலையில் உள்ள (Kept current)

ஆவணங்கள் (Documentation) மட்டும் போதாது. காலாவதியான ஆவணங்கள் ஆபத்தானவை. அவை AI-க்குத் தவறான நம்பிக்கையைத் தருகின்றன. உங்கள் குழு இனிப் பயன்படுத்தாத பழைய முறைகளைப் பின்பற்ற மாடலைத் தூண்டுகின்றன.

சிறந்த குழுக்கள் சிறந்த 'prompts'-களை மட்டும் எழுதுவதில்லை. அவை சிறந்த 'guardrails'-களைக் கட்டமைக்கின்றன.

ஒரு விதியைப் பின்பற்றுமாறு AI-யிடம் கேட்பதற்குப் பதிலாக, அதை நடைமுறைப்படுத்த தானியங்கி சோதனைகளைப் (automated tests) பயன்படுத்துங்கள். பின்வருவனவற்றைச் சரிபார்க்க CI/CD-ஐப் பயன்படுத்துங்கள்:

  • Static analysis பிழைகள்
  • பாதுகாப்பு ஓட்டைகள் (Security vulnerabilities)
  • கட்டமைப்பு எல்லை மீறல்கள் (Architectural boundary violations)
  • சார்பு சிக்கல்கள் (Dependency issues)

AI குறியீட்டை உருவாக்குவதை மலிவாக்குகிறது. ஆனால் தயாரிப்பைப் (product) புரிந்துகொள்வதன் முக்கியத்துவத்தைக் குறைப்பதில்லை. உண்மையில், சூழலே (context) மிகவும் மதிப்புமிக்க ஆதாரமாக மாறுகிறது.

அதிகப்படியான குறியீட்டை உருவாக்கும் குழுக்கள் வெற்றியாளர்களாக இருக்க மாட்டார்கள். மாறாக, பல்வேறு பகுதிகள் எவ்வாறு ஒன்றிணைகின்றன என்பதற்கான தெளிவான வழிமுறைகளை வழங்கும் குழுக்களே வெற்றியாளர்களாக இருப்பார்கள்.

Source: https://dev.to/icetique/ai-can-write-the-code-who-gives-it-the-context-2l1b

Optional learning community: https://t.me/GyaanSetuAi