AI தனக்குத்தானே Code எழுதி Update பண்ணிக்குமா? புது டெக்னாலஜி சொல்வது என்ன?

என்ன நடந்தது?#

சென்னை OMR-ல் இருக்கும் ஒரு IT கம்பெனி ஜூனியர் டெவலப்பரை யோசித்துப் பாருங்கள். காலையில் ஆபீஸ் வந்து ஒரு Code எழுதுகிறார். அதில் நாலைந்து Bug வருகிறது. உடனே Stack Overflow தேடி, பிழையைச் சரிசெய்கிறார். இப்படித் தினமும் தவறுகளைத் திருத்தித் திருத்தி, மூன்று நான்கு வருடங்களில் ஒரு பக்கா சீனியர் டெவலப்பராக அவர் மாறுகிறார் அல்லவா?

இப்போ இதே மூன்று வருட அனுபவத்தை, ஒரு AI மாடல் வெறும் நாற்பதே நிமிடத்தில் ஒரு Server Farm-க்குள் தனக்குத்தானே கற்றுக் கொண்டால் எப்படி இருக்கும்? இது ஏதோ ஹாலிவுட் சயின்ஸ் பிக்ஷன் சினிமா கதை இல்லைங்க. முன்னணி AI ஆராய்ச்சி நிறுவனங்கள் இப்போது இந்த 'Autonomous Self-Improvement' முறையைத்தான் நிஜமாக்கிக் கொண்டிருக்கின்றன.

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

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

இது எப்படி வேலை செய்யும்?#

கொஞ்ச காலத்திற்கு முன்பு கம்ப்யூட்டர்கள் செஸ் மற்றும் Go விளையாட்டுகளைக் கற்றுக்கொண்ட கதையை நினைத்துப் பாருங்கள். யாரும் உட்கார்ந்து ஒவ்வொரு காயையும் எப்படி நகர்த்த வேண்டும் என்று கம்ப்யூட்டருக்குச் சொல்லிக் கொடுக்கவில்லை. அது தனக்குத்தானே கோடிக்கணக்கான ஆட்டங்களை விளையாடி, எந்த நகர்வு வெற்றி தரும் என்று தானாகவே கற்றுக்கொண்டது.

அதாவது, அதே Self-play லாஜிக்கை இப்போ கோடிங் மற்றும் மேத்ஸ் கணக்குகளுக்கும் கொண்டு வந்துவிட்டார்கள். உதாரணமாக, AI-யிடம் ஒரு கஷ்டமான கோடிங் பிரச்னையைக் கொடுத்தால், அது ஒரே ஒரு பதிலை மட்டும் தராது. ஐம்பது விதமான வழிகளில் Code எழுதும். அப்புறம் ஒரு பாதுகாப்பான Sandbox சூழலில் அந்த Code-ஐ ரன் பண்ணிப் பார்க்கும்.

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

இன்னொரு பக்கம் Synthetic Data என்று சொல்லப்படும் செயற்கை டேட்டா முறை வேகமாக வளர்ந்து வருகிறது. அதாவது, ஒரு பெரிய Teacher AI மாடல் பல கடினமான புதிர்களையும் கணக்குகளையும் உருவாக்கும். சின்ன Student AI மாடல் அதைத் தீர்க்க முயற்சிக்கும். ஒரு Automated Verifier நடுவராக இருந்து, எது சரி எது தவறு என்று தீர்ப்பு சொல்லும். இப்படித் தனக்குள்ளேயே கேள்வி கேட்டு பதில் சொல்லி AI மாடல்கள் அறிவை வளர்த்துக்கொள்கின்றன.

இந்தியாவுல / நம்ம Phone-ல என்ன மாறும்?#

நம்ம ஊர் IT துறையை எடுத்துக்கொண்டால், சென்னை தரமணி முதல் பெங்களூரு எலக்ட்ரானிக் சிட்டி வரை லட்சக்கணக்கான இளைஞர்கள் செய்வது Basic Testing, Code Migration, Documentation போன்ற வேலைகள்தான். AI தனக்குத்தானே Code எழுதி Bug Fix செய்யத் தொடங்கினால், இந்த அடிப்படை வேலைகளுக்கு ஆட்கள் தேவைப்படுவது வெகுவாகக் குறையும்.

அதேநேரம், ஒரு AI எழுதிய Code சரியா வேலை செய்யுதா, அதில் செக்யூரிட்டி ஓட்டைகள் இருக்கா என்று கண்காணிக்கும் 'AI Evaluation' மற்றும் 'System Architect' வேலைகளுக்கு உச்சக்கட்ட டிமாண்ட் உருவாகும். அதாவது, வேலைகள் அழியாது; ஆனால் செய்யும் விதம் தலைகீழாக மாறும்.

நம்ம அன்றாட Phone பயன்பாட்டிலும் பெரிய மாற்றம் வரும். இப்போதெல்லாம் ஒரு App-ல் Bug இருந்தால், டெவலப்பர்கள் அதைச் சரிசெய்து Play Store-ல் Update விட வாரம் கணக்கில் ஆகும். ஆனால், வருங்காலத்தில் உங்க Phone-ல் இருக்கும் AI Agent-களே சின்னச் சின்ன சாப்ட்வேர் பிழைகளைத் தனக்குத்தானே கண்டறிந்து நொடிப்பொழுதில் சரிசெய்து கொள்ளும் அளவுக்கு வேகம் கூடும்.

நீங்க இப்போ என்ன பண்ணுங்க?#

நீங்க IT துறையில் இருக்கீங்களா அல்லது காலேஜில் கம்ப்யூட்டர் சயின்ஸ் படிக்கிறீர்களா? அப்போ இந்த மாற்றத்தைக் கண்டு பயப்படத் தேவையில்லை. ஆனால் பழையபடி வெறும் Syntax மனப்பாடம் பண்ணுவதை உடனே நிறுத்துங்க.

AI டூல்களை வெறும் ChatGPT போலப் பேச மட்டும் பயன்படுத்தாமல், Cursor போன்ற Agentic கோடிங் டூல்களை உங்கள் அன்றாட வேலைகளில் இணைத்துப் பழகுங்கள். லாஜிக் எப்படி வேலை செய்கிறது, ஒரு முழு சாப்ட்வேர் கட்டமைப்பை எப்படி உருவாக்குவது என்பதில் உங்கள் கவனத்தைத் திருப்புங்கள்.

AI தனக்குத்தானே கற்றுக்கொள்ளும் காலம் வேகமாக நெருங்கிவிட்டது. அந்த AI-க்கு சரியான வழிகாட்டும் மேனேஜராக நீங்க மாறினால், டெக் உலகில் உங்கள் இடம் எப்போதுமே பாதுகாப்பாக இருக்கும்!

இந்த Self-Improving Loop எங்கே தடுமாறும்?#

AI தனக்குத்தானே Code எழுதி, Sandbox-ல ரன் பண்ணி, Bug-ஐ திருத்திக்கொள்ள முடியும்னா, ஏன் இன்னும் Runaway Superintelligence வரல? கேள்வி நியாயந்தான். பதில் ஒரே வார்த்தையில — Verification. அதாவது AI சொல்லும் Logic உண்மையா, அது Generate பண்ணின Answer Hallucination இல்லையா என்று சரிபார்க்க Rock-solid Automated Referee System வேணும். இல்லன்னா மாடல் தன் சொந்த தவறான கற்பனையை உண்மைனு நம்பி, அதே Garbage-ஐ மீண்டும் மீண்டும் ட்ரெய்னிங் Data-வா எடுத்துக்கும். சென்னை Tidel Park அல்லது Guindy Industrial Estate-ல ஒரு ஜூனியர் டெவலப்பர் தவறான Stack Overflow snippet-ஐ copy-paste பண்ணி Production-ல விட்ட மாதிரி, AI-யும் தவறான Feedback Loop-ல சிக்கினா முழு Pipeline-மே கெட்டுப்போகும்.

இப்போ Frontier Labs என்ன பண்றாங்கன்னா, Code ரன் ஆனதும் Compiler Error, Unit Test Result, Runtime Exception எல்லாத்தையும் Automated Verifier பார்த்து Grade போடும். Math அல்லது Logic Puzzle-ன்னா exact match பார்த்து சரி தவறு சொல்லும். ஆனால் Open-ended Business Logic, UI/UX Decision, Real-world Edge Case மாதிரி விஷயத்துல Verifier உருவாக்குறது இன்னும் பெரிய சவால். Step-by-step-ஆ பார்த்தா: முதல்ல Problem Generate, அப்புறம் Multiple Solutions, Sandbox Execution, Verifier Score, அதன் பிறகு Model Weight Update. இந்த சங்கிலியில Verifier பலவீனமா இருந்தா முழு Loop-மே Useless. அதனாலதான் Labs இப்போ Synthetic Data-ஐ விட Verifier Quality-ல அதிக Focus போட்டுக்கிட்டு இருக்காங்க.

நம்ம ஊர்ல Common Mistake என்னன்னா, AI Generate பண்ணின Code-ஐ Manual Review இல்லாம Direct-ா Deploy பண்ணிடுறது. OMR-ல இருக்கும் சில Service Company Team-கள் “AI எழுதிடுச்சு, Time Save ஆச்சு”னு நினைச்சு Release பண்ணி, பின்னால Wrong Calculation, Security Hole, Data Leak மாதிரி Complaint வரும். Self-improving AI வந்தாலும், மனிதர் Verifier Design பண்ணற Skill இல்லாம போனா ஆபத்து அதிகம். அடுத்த கட்டத்துல AI Evaluation, Test Case Design, Architecture Review தான் Core Skill-ஆ நிற்கும் — Basic Bug Fixing Auto-pilot-க்கு போயிடும்.

அடுத்ததா என்ன Expect பண்ணலாம்? Comparison மற்றும் Daily-life#

பழைய முறை vs புது முறை Comparison பண்ணிப் பாருங்க. முன்னாடி ஒரு Chennai IT Services Project-ல Feature Add பண்ணனும்னா Requirement Gathering, Manual Coding, Peer Review, QA Testing, UATனு வாரம் கணக்கு ஆகும். இப்போ Agentic Coding Tool + Sandbox Self-Repair வந்ததும், அதே Cycle மணி நேரத்துல சுருங்க ஆரம்பிச்சிருக்கு. ஆனா Expectation-ல மக்கள் செய்யும் தவறு: “AI எல்லாத்தையும் தனியா முடிச்சிடும், Engineer வேலை முடிஞ்சு போச்சு”னு நினைக்கிறாங்க. உண்மை என்னன்னா, AI Trial-and-Error வேகமா செய்யும்; ஆனா எந்த Architecture Choose பண்ணனும், எந்த Verifier Rule போடனும், எந்த Business Constraint Ignore பண்ணக்கூடாதுனு முடிவு மனிதர் கையிலதான் இருக்கும்.

Real Tamil Nadu daily-life உதாரணம்: நீங்க Coimbatore-ல Small Product Company-ல Mobile App Maintain பண்றீங்கனு வச்சுக்கோங்க. Customer Dialer Flow-ல Bug வந்தா, முன்னாடி Log பாத்து, Fix எழுதி, Build போட்டு, Play Store Update-க்கு காத்திருப்பீங்க. வருங்காலத்துல On-device அல்லது Secure Cloud Agent சின்ன Logic Error-ஐ தனக்குத்தானே கண்டுபிடிச்சு Patch Propose பண்ணலாம். ஆனா Payment Calculation, User Privacy, Compliance Rule மாதிரி Critical Path-ல Automated Referee இல்லாம AI-யை Free-ஆ விட்டீங்கன்னா Wrong Refund அல்லது Data Mix-up வர வாய்ப்பு. அதனால “AI ஓடட்டும்”னு விடாம, Evaluation Checklist மற்றும் Sandbox Policy வைக்கறது அடுத்த Must-have Skill.

என்ன Expect பண்ணலாம்னா: அடுத்த கட்டத்துல Standard Debugging, Repetitive Unit Testing வேலைகள் வேகமா Auto-pilot-க்கு நகரும். அதே நேரம் System Architecture, AI Output Evaluation, Verifier Design, Security Boundary Setting இந்த நான்குக்கு டிமாண்ட் ஏறும். College-ல இருக்கீங்களா, TCS/Infosys/Startup எங்க இருந்தாலும் Syntax Memorize நிறுத்தி, “இந்த Solution-ஐ எப்படி Automatically Grade பண்ணுவேன்?”னு கேள்வி கேட்கப் பழகுங்க. Self-play + Synthetic Loop வளரும்; அதை Safe-ஆ நடத்தற மனிதர் தான் நீங்க. அந்த Shift-ஐ இப்போ Understand பண்ணினா, Tech Career-ல நீங்க Backfoot-ல போகாம Lead Position-ல நில்லுவீங்க.