லாகின் பக்கம் சரியாகத் திரையிடப்பட்டது. REST API 200 OK என்ற பதிலை அளித்தது. SaaS boilerplate ஒரு சிறிய linting பிழை கூட இல்லாமல் இயங்கியது. ஒரு வாரத்திற்குத் தேவைப்படும் வேலையை நீங்கள் ஒரே ஒரு மதியத்திற்குள் முடித்துவிட்டீர்கள். AI கோடிங் உதவியாளர்கள் மென்பொருள் உருவாக்கத்தை எவ்வளவு முழுமையாக மாற்றியமைத்துள்ளார்கள் என்றால், புதிய அம்சங்களை உருவாக்குவது பொறியியல் போலத் தெரியாமல், ஒரு மெனுவில் இருந்து ஆர்டர் செய்வது போலத் தோன்றுகிறது. அந்த வசதி உண்மையானதுதான். ஆனால் அது ஒரு விலையைக் கொண்டுள்ளது, அது பெரும்பாலும் மிக முக்கியமான தருணங்களில் மட்டுமே வெளிப்படும். இந்தச் சிக்கலை டெவலப்பர்கள் "Vibe Coding" என்று அழைக்கத் தொடங்கியுள்ளனர், அந்தப் பெயர் இந்தப் பிரச்சனையை மிகச் சரியாகப் பிரதிபலிக்கிறது.
நகலெடுப்பு-ஒட்டுதல் சுழற்சி (The Copy-Paste Loop)
இந்தச் சுழற்சி உண்மையில் எப்படி இருக்கும் என்றால்: நீங்கள் சாட் விண்டோவில் உங்கள் கர்சரை வைத்து, ஒரு அம்சத்தை சாதாரண ஆங்கிலத்தில் விவரிக்கிறீர்கள். ஒரு குறியீட்டுத் தொகுப்பு (code block) உடனடியாகத் தோன்றுகிறது. அதைத் தேர்ந்தெடுத்து, நகலெடுத்து, உங்கள் எடிட்டருக்குத் திரும்பி, ஒட்டி, சேமிக்கிறீர்கள். டெர்மினலில் பிழைகள் எதுவும் தெரியவில்லை. பிரவுசர் சரியான லேஅவுட்டைக் காட்டுகிறது. நீங்கள் மாற்றத்தைச் சேமித்து (commit), அடுத்த டிக்கெட்டைத் திறக்கிறீர்கள். தர்க்கத்தை (logic) ஆராய நீங்கள் ஒரு நிமிடம் கூட நிறுத்தவில்லை. இறக்குமதி செய்யப்பட்ட சார்புகளை (dependencies) நீங்கள் சரிபார்க்கவில்லை. அந்தத் மூன்றாம் தரப்பு லைப்ரரி (third-party library) உண்மையில் அவசியமா அல்லது ஒரு தரப்படுத்தப்பட்ட லைப்ரரி கருவி போதுமானதா என்ற கேள்வியும் உங்களுக்கு இல்லை. இந்த பணிப்பாய்வு (workflow) என்பது வெறும் கேளுங்கள், நகலெடுங்கள், ஒட்டுங்கள், இயக்குங்கள் என்பதுதான். மேலோட்டமாகச் சரியாகத் தெரிந்தால், ஆழமான விஷயங்களும் சரியாக இருக்கும் என்று நீங்கள் கருதுகிறீர்கள். இது எந்த அர்த்தத்திலும் கோடிங் அல்ல. இது கையேட்டைப் படிக்காமல் முன்கூட்டியே தயாரிக்கப்பட்ட பாகங்களை இணைப்பது போன்றது. எந்த குறுக்குவழியைப் போலவும், அது வேலை செய்யாத அந்தத் தருணம் வரும் வரை மட்டுமே இது செயல்படும்.
மிக மோசமான நேரத்தில் கட்டுப்பாட்டை இழத்தல்
ஒரு பிழை (bug) தயாரிப்புச் சூழலில் (production) ஏற்படும்போது, அது உங்கள் மேசைக்கே வரும், AI-இடம் வராது. அதிகாலை இரண்டு மணிக்கு, சாட்பாட் உங்கள் கண்காணிப்புத் தளத்தில் (observability platform) லாகின் செய்திருக்காது. நீங்கள் தான் செய்திருப்பீர்கள். நீங்கள் அனுப்பிய குறியீட்டை நீங்கள் ஒருபோதும் படிக்கவில்லை என்றால், அதன் தோல்விக்கான காரணத்தை உங்களால் பகுத்தறிய முடியாது. உங்களுக்குப் புரியாத கோப்புகளைத் தேடித் தேடி (grep), உங்களுக்குத் தெரியாத தர்க்கத்தைச் சரிசெய்ய (patch) முயற்சிப்பீர்கள். அந்த உணர்வு திசைதிருப்பும் வகையில் இருக்கும். சொந்தமாக கட்டமைப்புகளை எழுதும் ஒரு டெவலப்பர், அந்த அமைப்பைப் பற்றிய ஒரு மன வரைபடத்தை (mental map) உருவாக்குகிறார். எங்கே சிக்கல்கள் உள்ளன என்பதையும், எந்தக் கருத்துக்கள் அந்த அமைப்பைத் தாங்கிப் பிடிக்கின்றன என்பதையும் அவர்கள் அறிவார்கள். Vibe Coding அந்த வரைபடத்தை அழித்துவிடுகிறது. நீங்கள் ஒரு 'பிளாக் பாக்ஸ்' (black box) இயங்குநராக மாறிவிடுகிறீர்கள். தொடரியல் (syntax) சரியாக இருக்கலாம், டெமோ வாடிக்கையாளரை ஈர்த்திருக்கலாம், ஆனால் அந்த அமைப்பு உண்மையாக உங்களுடையது அல்ல. உரிமையாளர் பொறுப்பு என்பது புரிதலைக் கோருகிறது, மேலும் புரிதலைப் பெற நேரம் எடுக்கும். அந்தப் படிநிலையைத் தவிர்ப்பது செலவைக் குறைக்காது. அது அதை மிக அதிக விலையுள்ள தருணத்திற்குத் தள்ளிவிடுகிறது.
இயங்கும் குறியீடு என்பது பாதுகாப்பான குறியீடு அல்ல
AI மாதிரிகள் பயிற்சித் தரவுகளில் காணப்படும் வடிவங்களின் (patterns) அடிப்படையில் பதில்களை உருவாக்குகின்றன. அந்த வடிவங்களில் காலாவதியான மற்றும் பாதுகாப்பற்ற பல உதாரணங்கள் அடங்கியுள்ளன. நீங்கள் நகலெடுத்த லாகின் செயல்பாடு, ஒரு பாதுகாப்பான 'salted slow hash'-க்கு பதிலாக, பழைய ஃபோரம் துணுக்குகளைப் பயன்படுத்தியதால், வேகமான மற்றும் காலாவதியான ஹேஷிங் முறையைப் பயன்படுத்தி கடவுச்சொற்களைச் சேமிக்கலாம். நீங்கள் ஒரு எளிய உதாரணத்தைக் கேட்டதாலும், மாடல் அதற்கு இணங்கியதாலும், API எண்ட் பாயிண்ட் (endpoint) பயனர் உள்ளீட்டை நேரடியாக ஒரு raw SQL சரத்துடன் (string) இணைக்கலாம். நீங்கள் ஒரு serverless frontend-ஐ உருவாக்குகிறீர்கள், backend route அல்ல என்பதை AI அறியாததால், உங்கள் தரவுத்தளத் தகவல்கள் (database credentials) client-side JavaScript-க்குள் கசியக்கூடும்.
உள்ளீட்டுச் சரிபார்ப்பு (input validation) இல்லாமை என்பது பொதுவானது. உருவாக்கப்பட்ட form handler, பயனர்கள் முறையாக நடந்துகொள்வார்கள் என்று கருதுகிறது; மேலும் தரவை அடுத்த நிலைக்கு அனுப்பும் முன் சரங்களின் நீளம் (string lengths), எண் வரம்புகள் (numeric ranges) அல்லது கோப்பு வகைகளைச் சரிபார்க்கத் தவறிவிடுகிறது. அங்கீகாரச் சரிபார்ப்புகள் (authentication checks) முறையான server-side சரிபார்ப்பு இல்லாமல் client-side டோக்கன்களைச் சார்ந்திருக்கலாம், இது ஒரு போலிப் பாதுகாப்பை உருவாக்குகிறது. அதன் பயிற்சியில் பழைய Stack Overflow பதில்கள் இருந்ததால், ஒரு AI 'HttpOnly' அல்லது 'Secure' கொடிகள் (flags) இல்லாத ஒரு session cookie-யை உருவாக்கலாம். ஒவ்வொரு பிரச்சனையும் ஒரு டெமோவின் போது கண்ணுக்குத் தெரியாது. ஆப் இயங்கும். பயனர்கள் லாகின் செய்வார்கள். தரவு பரிமாறப்படும். ஆனால் ஒரு தாக்குதல் நடத்துபவருக்கு (attacker) பாதுகாப்பற்ற ஒரே ஒரு நுழைவுப் புள்ளி போதுமானது. AI வெளியீட்டைப் பாதுகாப்புப் பார்வையில் (security lens) ஆய்வு செய்வது ஒரு பயமல்ல (paranoia). அது தொழில்முறை மென்பொருளுக்கான அடிப்படைத் தேவையாகும்.
முரண்பாட்டு வரி (The Inconsistency Tax)
ஒரு codebase என்பது ஒரு கதை போன்றது. விஷயங்கள் எப்படிச் செய்யப்பட வேண்டும் என்பதை அது புதிய குழு உறுப்பினர்களுக்குக் கற்பிக்கிறது. Vibe Coding அந்த கதையை ஒரு டஜன் முரண்பட்ட மொழிகளாகத் துண்டாக்குகிறது. நீங்கள் நேற்று உருவாக்கிய அம்சம், தெளிவான state reducers-உடன் கூடிய functional React hooks-ஐப் பயன்படுத்துகிறது. இன்று உருவாக்கப்பட்ட அம்சம், சற்று மாறுபட்ட prompt-லிருந்து உருவானதால், மாடல் பழைய முறையைப் பயன்படுத்தியதன் காரணமாக class components-ஐப் பயன்படுத்துகிறது. API அடுக்கு, OpenAPI மூலம் உருவாக்கப்பட்ட stubs மற்றும் கையால் எழுதப்பட்ட route handlers ஆகியவற்றிற்கு இடையே மாறுகிறது. பெயரிடும் முறைகள் (naming conventions) camelCase மற்றும் snake_case ஆகியவற்றிற்கு இடையே மாறுகின்றன. பிழை கையாளுதல் (error handling) ஒரு கோப்பில் காணாமல் போகிறது, மற்றொரு கோப்பில் விரிவான nested try-catch பிளாக்குகளாகத் திரும்புகிறது.
வாரங்கள் செல்லச் செல்ல, அந்தத் திட்டம் ஒரு தொல்பொருள் அகழ்வாராய்ச்சியாக மாறிவிடுகிறது. அடுத்தடுத்துள்ள AI-ஆல் உருவாக்கப்பட்ட மாட்யூல் (module) என்ன மாதிரியான ஊகங்களைச் செய்திருக்கும் என்று உங்களுக்குத் தெரியாததால், ஒரு மாட்யூலை உங்களால் பாதுகாப்பாக மாற்ற முடியாது. Refactoring என்பது மெதுவான மற்றும் ஆபத்தான ஒரு 'whack-a-mole' விளையாட்டாக மாறிவிடுகிறது. சிஸ்டம் கம்பைல் (compile) ஆகிறது, ஆனால் அது இனி ஒருங்கிணைந்து செயல்படுவதில்லை. ஆயிரக்கணக்கான ஒட்டப்பட்ட சிறு துணுக்குகளால் (pasted snippets) அதன் பராமரிப்புத் திறன் (maintainability) அழிந்துவிடுகிறது.
AI-ஐ ஒரு ஆசிரியராக மாற்றுங்கள்
நீங்கள் வெளியீட்டைத் தீவிரமாக வினாடி வினாவிற்கு உட்படுத்தும் போதுதான் உண்மையான கற்றல் நிகழ்கிறது. வேகமாக குறியீடு எழுதும், ஆனால் ஒரு code review-ஐ எதிர்பார்க்கும் ஒரு மூத்த டெவலப்பரைப் (senior developer) போல AI-ஐ நடத்துங்கள். அந்த tree traversal-க்கு iteration-க்கு பதிலாக ஏன் recursion-ஐத் தேர்ந்தெடுத்தது என்று கேளுங்கள். edge cases-களைச் சிறப்பாகக் கையாளக்கூடிய, நினைவகத்தைச் சிக்கனமாகப் பயன்படுத்தும் (memory-efficient) வழி ஏதேனும் உள்ளதா என்று கேளுங்கள். input null ஆக இருக்கும்போது, network request timeout ஆகும்போது அல்லது இரண்டு பயனர்கள் ஒரே நேரத்தில் அந்த function-ஐத் தூண்டும்போது என்ன நடக்கும் என்று கேளுங்கள். ஒரு ஜூனியர் குழு உறுப்பினரின் pull request-ஐ நீங்கள் ஆய்வு செய்வது போல, அதன் தர்க்கத்தை (logic) வரி வரியாக விளக்கச் சொல்லுங்கள்.
மாடலை அதன் தேர்வுகளை நியாயப்படுத்த நீங்கள் கட்டாயப்படுத்தும் போது, நீங்களும் அவற்றைச் புரிந்துகொள்ளத் தூண்டப்படுகிறீர்கள். இது அந்தத் தொடர்பின் தன்மையையே முற்றிலும் மாற்றுகிறது. AI ஒரு autopilot ஆக இருப்பதை நிறுத்திவிட்டு, ஒரு ஆசிரியராக மாறுகிறது. நீங்களாகவே எந்தக் குறியீடும் எழுதக்கூடாது என்பது இலக்கல்ல. உதவியாளர் முதல் பதிவை வரைவு செய்திருந்தாலும், நீங்கள் முழுமையாகப் புரிந்துகொண்ட குறியீட்டை மட்டுமே வெளியிடுவதுதான் இலக்காகும்.
இப்போது உண்மையில் முக்கியத்துவம் வாய்ந்த திறன்கள்
Syntax எழுதுவது நாளுக்கு நாள் எளிதாகி வருகிறது. வாசிப்பதும் மற்றும் பகுத்தறிவதும்...