ஒரு AI கோடிங் ஏஜென்ட் எனது கோட்பேஸின் வரைபடத்தை உருவாக்க அனுமதித்தேன், என்ன நடந்தது என்பது இதோ

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

Graft என்ற கருவி தீர்க்க முயற்சிக்கும் துல்லியமான பிரச்சனை அதுவேயாகும். மாதிரி செயல்விளக்கம் (toy demo) அல்லாமல், ஒரு உண்மையான திட்டத்தில் நான் இதை முயற்சித்துப் பார்த்தேன்; மேலும் இது உண்மையில் என்ன செய்கிறது, என்ன கண்டுபிடித்தது மற்றும் எங்கு பின்தங்குகிறது என்பதை உங்களுக்கு விளக்க விரும்புகிறேன்.

உண்மையில் Graft என்றால் என்ன

Graft-ஐ உங்கள் குறியீட்டிற்கான ஒரு நூலகராக நினையுங்கள். எதையாவது புரிந்து கொள்ள வேண்டியிருக்கும் ஒவ்வொரு முறையும் ஓர் AI ஏஜென்ட் கோப்புறைகளில் உலாவுவதற்குப் பதிலாக, Graft ஒரு முறை ஓர் அட்டவணையை (index) உருவாக்குகிறது: உங்கள் குறியீட்டின் ஒவ்வொரு பகுதியும் என்ன செய்கிறது, எந்த functions மற்ற எந்த functions-ஐ அழைக்கின்றன, மற்றும் அனைத்தும் எவ்வாறு இணைகின்றன என்பதை விவரிக்கும் சிறிய, இணைக்கப்பட்ட உரை கோப்புகளின் ஒரு கோப்புறை.

இது இதை இரண்டு அடுக்குகளில் செய்கிறது:

1. ஒரு கட்டமைப்பு வரைபடம், இது tree-sitter எனப்படும் குறியீட்டுப் பாகுபடுத்தல் நுட்பத்தைக் கொண்டு உருவாக்கப்பட்டது. இந்த அடுக்குக்கு எந்த AI மாதிரியும் தேவையில்லை. ஒரு கம்பைலர் படிப்பது போலவே இது உங்கள் குறியீட்டைப் படித்து, function பெயர்கள், வகுப்புகள் (classes) மற்றும் அவற்றுக்கிடையேயான இணைப்புகளைப் பிரித்தெடுக்கிறது.
2. ஒரு விருப்பத்திற்குரிய கருத்து அடுக்கு, இது குறியீட்டின் ஒவ்வொரு பகுதியும் எதற்காகப் பயன்படுகிறது என்பதற்கான எளிய-மொழிச் சுருக்கங்களை எழுத ஓர் AI மாதிரியைப் பயன்படுத்துகிறது. இந்த பகுதி இயங்குவதற்குப் பணம் செலவாகும், ஏனெனில் இது ஓர் AI மாதிரியை அழைக்கிறது, எனவே இது விருப்பத்தேர்வாகும் (opt-in).

முக்கியமான பகுதி: உங்கள் முழு கோட்பேஸையும் வரைபடமாக்கும் முதல் அடுக்குக்கு எந்தக் கட்டணமும் இல்லை மற்றும் API key எதுவும் தேவையில்லை. இது உங்கள் கோப்புகளை லோக்கலாக மட்டுமே பாகுபடுத்துகிறது.

ஒரு உண்மையான திட்டத்தில் இதைச் சோதிக்க நான் ஏன் முடிவு செய்தேன்

நான் ஒரே களஞ்சியத்தில் (repository) பல உண்மையான கோட்பேஸ்களில் பணிபுரிகிறேன்: Kotlin-இல் எழுதப்பட்ட ஓர் Android ஆப், நவீன வலை கட்டமைப்பைக் கொண்டு உருவாக்கப்பட்ட ஒரு வலைத்தளம், இரண்டு சிறிய பின்தளச் சேவைகள் (backend services), மற்றும் இதர பணிகளுக்கான சில Python ஸ்கிரிப்ட்கள். அந்த கோட்பேஸ்களில் ஒன்றான Android ஆப்பில், புதிய அம்சங்களைச் சரியாகப் பிரிப்பதற்குப் பதிலாக அதிலேயே தொடர்ந்து சேர்க்கப்பட்டதால் மூவாயிரத்திற்கும் மேற்பட்ட வரிகளாக வளர்ந்துவிட்ட ஒரே ஒரு கோப்பு உள்ளது. உண்மையான மென்பொருள் திட்டங்களில் இது மிகவும் பொதுவான ஒரு சூழ்நிலையாகும். அனைவரும் "பிறகு" refactor செய்ய நினைப்பார்கள், மேலும் அந்தப் பிற்பாடு தொடர்ந்து தள்ளிப்போய்க்கொண்டே இருக்கும்.

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

இதை அமைத்தல்

படி 1: கருவியை நிறுவுதல்

உங்கள் கணினியில் ஏதேனும் ஒரு டெவலப்பர் கருவியை குளோபலாக நிறுவுவது போலவே, Graft ஒரு சிறிய கட்டளை வரி (command-line) நிரலாக நிறுவப்படுகிறது:

npm install -g @nanonets/graft

படி 2: இது எதை மாற்றும் என்பதை முன்னோட்டமிடுதல்

உங்கள் திட்டத்தில் எதையும் இணைப்பதற்கு முன், எதையும் தொடாமலேயே அது எந்தெந்தக் கோப்புகளை உருவாக்கும் அல்லது மாற்றியமைக்கும் என்பதைத் துல்லியமாகக் காட்டும்படி நீங்கள் அதைக் கேட்கலாம்:

graft init --dry-run

இது ஒரு சிறிய பட்டியலை அச்சிட்டது: AI கோடிங் உதவியாளர்களுக்கான சில உள்ளமைவுக் கோப்புகள் (configuration files), ஒரு skill கோப்பு, மற்றும் உருவாக்கப்பட்ட வரைபடத்திற்கான ஒரு கோப்புறை. எதற்கும் ஒப்புக்கொள்வதற்கு முன் இந்தப் பட்டியலைப் பார்ப்பது, உங்கள் திட்டத்தை மதிக்கும் ஒரு கருவியின் நல்ல அறிகுறியாகும்.

படி 3: இந்தத் திட்டத்திற்கு மட்டும் வரையறுத்து (scoped) இதை இயக்குதல்

இது போன்ற சில கருவிகள் நீங்கள் பணிபுரியும் திட்டத்தை மட்டுமல்லாமல், உங்கள் கணினியிலுள்ள ஒவ்வொரு திட்டத்தையும் பாதிக்கும் உலகளாவிய உள்ளமைவை (global configuration) எழுத விரும்புகின்றன. எனக்கு அது தேவையில்லை, எனவே எல்லாவற்றையும் லோக்கலாக வைத்திருக்க ஒரு flag-ஐப் பயன்படுத்தினேன்:

graft init --no-global -y

இது திட்டத்திலுள்ள ஒவ்வொரு உண்மையான மூலக் கோப்பையும் பாகுபடுத்தி (என் விஷயத்தில், Kotlin, TypeScript, JavaScript மற்றும் Python முழுவதும் 77 கோப்புகள்), 561 தனித்துவமான குறியீட்டுத் துண்டுகள் மற்றும் அவற்றுக்கிடையே 1,229 இணைப்புகளைக் கொண்ட ஒரு வரைபடத்தை, சில வினாடிகளில், எந்த AI மாதிரியும் ஈடுபடாமல் மற்றும் எந்தச் செலவும் இல்லாமல் உருவாக்கியது.

இதைச் செயல்படுத்துதல்

இங்குதான் இது சுவாரஸ்யமானது. Graft-இடம் களஞ்சியம் முழுமைக்குமான ஒரு வழிகாட்டுதல் வரைபடத்தைக் (repo-wide orientation map) கேட்டேன், மேலும் அது உடனடியாக அந்த பிரம்மாண்டமான Android கோப்பிற்குள் உள்ள ஒரு function-ஐ, முழு திட்டத்திலும் மிகவும் சார்ந்திருக்கக்கூடிய ஒரே குறியீட்டுப் பகுதியாகக் கொடியிட்டுக் காட்டியது; அதை வேறு பத்து இடங்கள் அழைக்கின்றன.

பிறகு நான் இன்னும் ஒரு துல்லியமான கேள்வியைக் கேட்டேன்: அந்த ஒரு function-ஐ நான் மாற்றினால் பாதிக்கப்படக்கூடிய அனைத்தையும் எனக்குக் காட்டுங்கள். Graft முழு சங்கிலியையும் கண்டறிந்தது: ஒவ்வொரு திரை, ஒவ்வொரு உதவி கோப்பு (helper file), அந்த function-ன் செயல்பாடு தாக்கத்தை ஏற்படுத்தக்கூடிய ஒவ்வொரு இடம் என அனைத்தையும் உடனடியாகவும் இலவசமாகவும் அது கண்டறிந்தது.

குறியீட்டை நேரடியாகப் படிப்பதன் மூலமாகவோ, அல்லது எல்லாவற்றையும் grep செய்யுமாறு ஓர் AI உதவியாளரிடம் கேட்பதன் மூலமாகவோ அதே பதிலைப் பெறுவது என்பது தோராயமாக 200,000 டோக்கன்கள் மதிப்புள்ள கோப்பு உள்ளடக்கத்தைப் படிப்பதாகும். வரைபடத்தை மீண்டும் பயன்படுத்துவதன் மூலம் Graft-ன் சொந்த கணக்கீட்டுக் கருவி (accounting tool) அவ்வளவு சேமித்ததாகக் காட்டியது. இடைநிலை Claude மாதிரிக்கான தற்போதைய விலையில், இது ஒரே ஒரு பரிமாற்றத்தில் சேமிக்கப்பட்ட சுமார் நாற்பது சென்ட்கள் ஆகும். இது சிறிதாகத் தோன்றலாம், ஆனால் மனிதரோ அல்லது AI-யோ, அந்த கோட்பேஸைப் பற்றி இதே போன்ற ஒரு கேள்வியைக் கேட்கும் ஒவ்வொரு முறையும் அந்த சேமிப்பு மீண்டும் நிகழ்கிறது; அங்குதான் உண்மையான மதிப்பு கூடுகிறது.

எனக்குப் பிடிக்காதவை

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

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

முடிவுரை

AI கோடிங் உதவியாளர்களுடன் பணிபுரிவதில் உள்ள ஒரு உண்மையான, அன்றாட எரிச்சலை Graft தீர்க்கிறது: அமர்வுகளுக்கு இடையில் ஒருபோதும் மாறாத குறியீட்டைத் தொடர்ந்து மீண்டும் கண்டறிவது. உண்மையில் சிக்கலான, பல மொழிகள் கொண்ட ஒரு திட்டத்தில், லோக்கல் பாகுபடுத்தலைத் தவிர வேறெதுவும் இல்லாமல், நொடிகளில், இலவசமாக, துல்லியமான மற்றும் பயனுள்ள பதில்களை இது உருவாக்கியது. இது மாயாஜாலம் அல்ல, மேலும் இது உங்கள் பணிப்பாய்வில் (workflow) ஒரு சிறிய அளவு தேவையற்ற பேச்சைச் சேர்க்கிறது; ஆனால் மாற்றங்களைச் செய்வதற்கு முன் ஓர் AI உதவியாளர் ஒரு கோட்பேஸைப் புரிந்து கொள்ள உதவுவதற்கான ஓர் அடித்தளமாக, இது தனக்கான இடத்தைப் பெற்றுள்ளது.

நன்மைகள்

• முக்கிய அம்சத்திற்கு எந்த AI மாதிரியும் தேவையில்லாமல், பல மொழி கோட்பேஸின் முழு வரைபடத்தையும் சில நொடிகளில் உருவாக்குகிறது
• கட்டமைப்பு வரைபடத்திற்கு (structural graph) இயக்க எந்தச் செலவும் இல்லை, ஏனெனில் இது முற்றிலும் ஆஃப்லைனில் செயல்படுகிறது
• ஒரு மாற்றத்தின் முழு "blast radius"-ஐக் கண்டறிய முடியும், அதாவது நீங்கள் திருத்தவிருக்கும் குறியீட்டைச் சார்ந்திருக்கும் அனைத்தையும்
• உங்கள் பிற திட்டங்களின் அமைப்புகளைத் தொடாமல் ஒரே திட்டத்திற்கு மட்டும் வரையறுக்க (scoped) முடியும்
• உருவாக்கப்பட்ட தரவை தானாகவே version control-லிருந்து விலக்கி வைக்கிறது, எனவே இது பகிரப்பட்ட களஞ்சியத்தைக் (repository) குழப்பாது
• ஒரே திட்டத்தில் ஒரே நேரத்தில் பல நிரலாக்க மொழிகளில் செயல்படுகிறது

குறைபாடுகள்

• ஒவ்வொரு செய்திக்கும் இயங்கும் ஒரு hook-ஐ நிறுவுகிறது, இது குறியீடு தொடர்பில்லாத உரையாடல்களில் இரைச்சலாகத் தோன்றலாம்
• மிகவும் புதிய மென்பொருள், இதுவரை குறுகிய காலச் செயல்பாட்டு வரலாற்றையே கொண்டுள்ளது
• ஆழமான, AI-summary அடுக்குக்கு இன்னும் உங்கள் சொந்த AI மாதிரி அணுகல் தேவைப்படுகிறது மற்றும் நீங்கள் அதை இயக்கினால் பணம் செலவாகும்
• அமைப்பு முறை உங்கள் திட்டம் முழுவதும் பல configuration கோப்புகளைத் தொடுகிறது, எனவே அதை ஏற்கும் முன் என்ன எழுதப்படுகிறது என்பதை மதிப்பாய்வு செய்வது நல்லது

எச்சரிக்கை

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

அடிக்கடி கேட்கப்படும் கேள்விகள்

• Graft என்றால் என்ன? — இது ஒரு கோட்பேஸின் லோக்கல், இணைக்கப்பட்ட வரைபடத்தை உருவாக்கும் ஒரு கருவியாகும், இதன் மூலம் AI கோடிங் உதவியாளர்கள் (மற்றும் டெவலப்பர்கள்) ஒவ்வொரு முறையும் புதிதாக மீண்டும் ஆராயாமல் விரைவாகப் புரிந்து கொள்ள முடியும்.
• இது செயல்பட ஓர் AI மாதிரி தேவையா? — இல்லை. இதன் முக்கிய அம்சமான உங்கள் குறியீட்டின் கட்டமைப்பு வரைபடம் (structural map), குறியீட்டுப் பாகுபடுத்தல் நுட்பத்தைப் பயன்படுத்தி முற்றிலும் ஆஃப்லைனில் செயல்படுகிறது. விருப்பத்திற்குரிய ஆழமான அடுக்கு ஓர் AI மாதிரியைப் பயன்படுத்துகிறது, ஆனால் அந்த பகுதி கட்டாயமில்லை.
• ஏற்கனவே உள்ள திட்டத்தில் இதை நிறுவுவது பாதுகாப்பானதா? — எதற்கும் ஒப்புக்கொள்வதற்கு முன் அது எதை உருவாக்கும் அல்லது மாற்றும் என்பதை நீங்கள் துல்லியமாக முன்னோட்டமிடலாம், இது எந்தவொரு புதிய டெவலப்பர் கருவியையும் ஏற்றுக்கொள்வதற்கு முன் ஒரு நியாயமான பாதுகாப்புச் சோதனையாகும்.
• ஒரே திட்டத்தில் ஒன்றுக்கும் மேற்பட்ட நிரலாக்க மொழிகளில் இது செயல்படுமா? — ஆம், எனது சோதனையின் போது கம்பைல் செய்யப்பட்ட மொபைல் ஆப் மொழி மற்றும் பல வலை ஸ்கிரிப்டிங் மொழிகள் உட்பட பல மொழிகளை ஒரே இயக்கத்தில் ஒன்றாகப் பாகுபடுத்தியது.
• அதே கணினியிலுள்ள எனது பிற திட்டங்களை இது பாதிக்குமா? — நீங்கள் அனுமதித்தால் மட்டுமே. எல்லாவற்றையும் ஒரு திட்டக் கோப்புறைக்கு மட்டுமே வரையறுக்க (scoped) ஓர் அமைப்பு உள்ளது.
• ஒரு சிறிய, எளிய திட்டத்தில் இதைப் பயன்படுத்துவது பயனுள்ளதா? — பெரும்பாலும் அவ்வளவாக இல்லை. ஒரு கோட்பேஸின் அளவு மற்றும் சிக்கலான தன்மை அதிகரிக்கும் போது இதன் பலன் அதிகரிக்கிறது, குறிப்பாக அதிக வரலாற்றைக் குவித்துள்ள பெரிய கோப்புகளுக்கு.
• உருவாக்கப்பட்ட வரைபடத்தை version control-இல் சேர்க்க வேண்டுமா? — இல்லை, இது லோக்கலாக மீண்டும் உருவாக்கப்படும் வகையில் வடிவமைக்கப்பட்டுள்ளது மற்றும் பொதுவாக version control-லிருந்து தானாகவே விலக்கப்படுகிறது.
• மிகப் பெரிய குறைபாடு எது? — ஒவ்வொரு செய்தியிலும் சரிபார்க்கும் ஒரு hook, இது குறியீட்டுடன் எந்தத் தொடர்பும் இல்லாத உரையாடல்களில் தேவையற்ற அரட்டையாக உணரப்படலாம்.

குறிச்சொற்கள்

#ai #developertools #codingagents #productivity #softwareengineering #devtools #automation #codereview #techtools #programming