திறமையின் மாயை: AI-இன் கடைசி மைல் ஏன் பெரும் விலையைக் கொடுக்க வைக்கிறது

AI குறியீட்டின் (code) 80/20 விதியைப் பற்றி நீங்கள் வாசித்துவிட்டுத் தலையசைப்பீர்கள்.

AI உங்கள் குறியீட்டின் முதல் 80%-ஐ சில நொடிகளில் எழுதிவிடும். அது முன்னேற்றமாகத் தெரியும். அது வேகமாகத் தோன்றும்.

இது ஒரு பொறி.

வேலையின் இறுதி 20% பகுதி உங்கள் நேரத்தின் 80%-ஐ எடுத்துக் கொள்கிறது. இங்கேயே திட்டங்கள் முடங்குகின்றன. இங்கேயே டெவலப்பர்கள் தங்களின் நிதானத்தை இழக்கிறார்கள்.

AI நிகழ்தகவின் (probability) அடிப்படையில் செயல்படுகிறது. அடுத்ததாக வரக்கூடிய வார்த்தை அல்லது குறியீட்டு வரியைக் கணிக்கிறது. அதற்குத் தர்க்கம் (logic) புரியாது. உங்கள் குறிப்பிட்ட சிஸ்டம் கட்டமைப்பைப் (system architecture) பற்றித் தெரியாது. இது ஒரு "happy path"-ஐ உருவாக்குகிறது, இது சரியான சூழலில் மட்டுமே வேலை செய்யும்.

நீங்கள் அந்த "happy path"-ஐத் தாண்டிச் செல்லும்போது, ஒரு சுவரைத் தடுப்பதைப் போலத் தடுமாறுகிறீர்கள்.

இதை நான் Verification Debt என்று அழைக்கிறேன்.

Technical debt என்பது விரைவான தீர்வுகளால் (quick fixes) உருவாகிறது. Verification debt என்பது புரிதல் இல்லாமையால் உருவாகிறது.

நீங்களே குறியீட்டை எழுதும்போது, ஒரு மன வரைபடத்தை (mental map) உருவாக்குகிறீர்கள். ஒவ்வொரு வரியும் ஏன் இருக்கிறது என்பது உங்களுக்குத் தெரியும். AI அதை எழுதும்போது, நீங்கள் உருவாக்காத ஒரு முடிக்கப்பட்ட தயாரிப்பு உங்களுக்குக் கொடுக்கப்படுகிறது. அதன் தர்க்கம் (logic) உங்களுடையது அல்ல. அதன் முடிவு மட்டுமே உங்களுடையது.

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

குறியீட்டை உருவாக்கும் வேகம், வேலை முடிந்துவிட்டது போன்ற ஒரு மாயையை உருவாக்குகிறது. நீங்கள் வேலையை முடித்துவிட்டதாக நினைக்கிறீர்கள். பிறகு edge cases வருகின்றன. ஒருங்கிணைப்பு (Integration) தோல்வியடைகிறது. பாதுகாப்பு குறைபாடுகள் (Security flaws) வெளிப்படுகின்றன.

கடைசி 20% என்பது வெறும் "finishing touches" மட்டுமல்ல. அது தரத்தின் (quality) மையம். அது சோதனை செய்தல் (testing), பிழைதிருத்தம் (debugging) மற்றும் edge-case கையாளுதல் ஆகியவற்றைக் குறிக்கிறது.

இதை எப்படிச் சரிசெய்வது?

AI வெளியீட்டை ஒரு இறுதித் தயாரிப்பாகக் கருதுவதை நிறுத்துங்கள். அதை நம்பகத்தன்மையற்ற தரவாகக் (untrusted data) கருதுங்கள்.

• முதலில் சோதனைகளை (tests) எழுதுங்கள். சோதனைகளை உருவாக்குவதற்கு முன் தர்க்கத்தை (logic) உருவாக்காதீர்கள். AI பதிலளிப்பதற்கு முன்பே தோல்வி எப்படி இருக்கும் என்பதை வரையறுக்கவும்.
• பகுதிகளாகச் சரிபார்க்கவும் (Validate in segments). பிழைகளைக் கண்டறிய முழு சிஸ்டம் ஒருங்கிணைப்பிற்காகக் காத்திருக்க வேண்டாம். ஒவ்வொரு சிறிய தொகுதியையும் தனித்தனியாகச் சோதிக்கவும்.
• தற்காலிகத் தீர்வுகளைத் (patching) தேடுவதைத் தவிர்த்துவிட்டு, அதைத் தூக்கி எறியுங்கள். ஒரு AI செயல்பாடு (function) சோதனையில் தோல்வியடைந்தால், அதை வரி வரியாகச் சரிசெய்ய முயற்சிக்காதீர்கள். அதை நீக்கிவிட்டு வேறு ஒரு prompt-ஐ முயற்சிக்கவும். AI பிழைகளைத் தற்காலிகமாகச் சரிசெய்வது பெரும்பாலும் கூடுதல் பிழைகளையே உருவாக்கும்.

80/20 விதி ஒரு எச்சரிக்கை. AI உங்கள் வேகத்தை அதிகரிக்கிறது, ஆனால் அதைச் சரிபார்க்க வேண்டிய உங்கள் பொறுப்பையும் அதிகரிக்கிறது.

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

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

Source: https://dev.to/amrree/the-illusion-of-efficiency-why-ais-last-mile-costs-everything-a7g

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