Claude Code தொடர் பயிற்சி 3: ஏன் முனையம் மட்டுமே வழங்கப்பட்டது

1.3 ஏன் முனையத்தில் குறியீடு எழுத வேண்டும்?

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

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

AI ஐ முனையத்தில் வைப்பதன் முதன்மை நோக்கம், இந்த இயந்திர வேலைகளை சுருக்குவது ஆகும்.

முனையம் குறியீட்டுக்கு மிக அருகில் உள்ள இடம்

நீங்கள் VS Code, JetBrains அல்லது Vim ஐப் பயன்படுத்தலாம். நீங்கள் எதைப் பயன்படுத்தினாலும், குறியீடு எழுதும் செயல்பாட்டில் முனையத்தைத் தவிர்க்க முடியாது. npm test , git log , grep , make build இயக்குதல் - இந்த செயல்பாடுகள் இயற்கையாகவே கட்டளை வரியில் செய்யப்படுகின்றன.

எனவே, உங்கள் AI கூட்டாளியும் அதே முனையத்தில் இருந்தால், விஷயங்கள் எளிதாகின்றன. கோப்பு உள்ளடக்கங்களை அரட்டை சாளரத்தில் நகலெடுத்து ஒட்ட வேண்டியதில்லை, 'எனது திட்டத்தில் UserService என்ற ஒரு வகுப்பு உள்ளது, அது src/services/user.ts இன் 42 வது வரியில் உள்ளது...' என்று விவரிக்க வேண்டியதில்லை. Claude Code திட்டத்தின் ரூட் கோப்பகத்தில் நிற்கிறது, அது தானாகவே பார்த்துக்கொள்ளும்.

இது சூழலில் ஒரு பரிமாண குறைப்பு தாக்குதல். நீங்கள் Claude Code க்கு 'லாகின் தொகுதியின் பிழை கையாளுதலை மறுசீரமைக்க உதவுங்கள்' என்று சொல்லும்போது, அது உண்மையில் உங்கள் auth/login.ts , errors.ts ஐப் படித்து, அதை அழைக்கும் அனைத்து இடங்களையும் கண்டுபிடித்து, நேரடியாக மாற்றும். இடையில் நீங்கள் இடமாற்றம் செய்ய வேண்டியதில்லை.

உங்களை 'இயக்குபவர்' பாத்திரத்திலிருந்து விடுவித்தல்

உலாவி AI அரட்டையைப் பயன்படுத்தும் போது, நாம் அறியாமலேயே ஒரு 'இடைத்தரகர்' பாத்திரத்தை வகிக்கிறோம்: AI குறியீட்டை வெளியிடுகிறது, நாம் படித்து, சரிபார்த்து, நகலெடுத்து, மீண்டும் தொகுப்பிக்குச் சென்று ஒட்டுகிறோம். குறியீடு வேலை செய்தால் நல்லது; இல்லையென்றால், பிழையை நகலெடுத்து, மீண்டும் கேட்டு, மீண்டும் நகலெடுக்கிறோம். இந்த செயல்முறை மன ஓட்டத்தை மிகவும் குறுக்கிடுகிறது.

Claude Code இன் வடிவமைப்பு சிந்தனை உங்களை மீண்டும் 'சிந்தனையாளர்' நிலைக்கு கொண்டுவருவதாகும். நீங்கள் கருத்தைச் சொல்லுங்கள், அது செயல்படுத்தும். மாற்றங்களைச் செய்த பிறகு, நீங்கள் நேரடியாக முனையத்தில் diff ஐப் பார்த்து, ஏற்கலாமா வேண்டாமா என முடிவு செய்யலாம். இது தானாகவே சோதனை மற்றும் lint ஐ இயக்கவும் உதவும். நீங்கள் அமர்ந்திருக்கும்போது, பெரும்பாலும் குறியீட்டைப் படிப்பதும், முடிவுகளை எடுப்பதுமே, மீண்டும் மீண்டும் சாளரங்களை மாற்றுவதில்லை.

ஏன் தொகுப்பி செருகுநிரல் அல்ல?

நீங்கள் கேட்கலாம்: பிறகு ஏன் நேரடியாக தொகுப்பியில் AI செருகுநிரலை உருவாக்கக்கூடாது?

தொகுப்பி செருகுநிரல்கள் நிச்சயமாக பயனுள்ளவை, மேலும் பல குழுக்கள் ஏற்கனவே பயன்படுத்துகின்றன. ஆனால் முனையத்தில் உள்ள Claude Code செருகுநிரல்களால் எளிதில் மாற்ற முடியாத சில விஷயங்களைக் கொண்டுள்ளது:

தொகுப்பியின் கட்டுப்பாடு இல்லை. நீங்கள் இன்று VS Code ஐப் பயன்படுத்துகிறீர்கள், நாளை Neovim க்கு மாற்றுகிறீர்கள், GUI இல்லாத தொலை சேவையகங்களில் கூட Claude Code ஐப் பயன்படுத்தலாம். இது நீங்கள் தேர்ந்தெடுக்கும் கருவியுடன் தொடர்புடையதல்ல.
மேலும் 'அசாதாரணமான' விஷயங்களைச் செய்யலாம். முனையத்தில், இது எந்த Shell கட்டளையையும் செயல்படுத்த முடியும். இதன் பொருள் அது செய்யக்கூடிய விஷயங்களின் எல்லை மிகவும் விரிவானது - டேட்டாபேஸ் இடம்பெயர்வை சரிபார்க்க Docker கொள்கலனைத் தொடங்கலாம், தொலை கிளையை இழுத்து மோதல்களைச் சரிபார்க்கலாம், குறியீட்டை மாற்றிய பின் தானாக e2e சோதனைகளை இயக்கலாம். இந்த விஷயங்களை தொகுப்பி செருகுநிரல்கள் பொதுவாக தைரியமாக செய்ய மாட்டாது, அல்லது செய்யவே முடியாது.
தொகுதி செயலாக்கம் மற்றும் தன்னியக்கமாக்கல். நீங்கள் Claude Code ஐ ஸ்கிரிப்ட்டில் வைத்து, பல ரெப்போக்களை செயலாக்கவும், தொகுதி ஆவணங்களை உருவாக்கவும், Issues ஐ தானாக கையாளவும் உதவலாம். இப்போது அது 'உதவியாளர்' அல்ல, மாறாக உற்பத்தி வரிசையில் ஒரு பகுதியாகும்.

எனது சொந்த சிறிய உதாரணம்

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

நான் நேரடியாக அந்த திட்ட கோப்பகத்தில் Claude Code ஐத் தொடங்கி, அதற்கு சொன்னேன்: 'இந்த திட்டத்தை படிப்படியாக TypeScript கடுமையான பயன்முறைக்கு இடம்பெயர்க்கவும், ஒவ்வொரு முறையும் சில கோப்புகளை மாற்றவும், ஒவ்வொரு தொகுதியும் மாற்றிய பின் tsc --noEmit ஐ இயக்கவும், பிழை இருந்தால் தானாக சரிசெய்யவும், அனைத்தும் நிறைவேறும் வரை.'

அடுத்த அரை மணி நேரத்தில், நான் அடிப்படையில் ஒரு காரியத்தை மட்டுமே செய்தேன்: அது மாற்றிய diff ஐப் பார்த்து, ஆமாம் அல்லது இல்லை என்று சொன்னேன். எப்போதாவது அதற்கு 'இங்கே வகைக்கு any வேண்டாம், ஒரு interface வரையறுக்கவும்' என்று சொன்னேன், அது தொடர்ந்து வேலை செய்தது. இறுதியில் திட்டம் தொகுப்பு நிறைவேறியது, நான் மதிப்பிட்ட நேரத்தை விட பல மடங்கு வேகமாக.

இது நிச்சயமாக Claude Code செருகுநிரலை விட புத்திசாலி என்று அர்த்தமல்ல. ஆனால் இது 'மாற்று-சரிபார்-சரிசெய்' என்ற மூடிய சுழற்சியை தானாக முடிக்க முடியும், இது அரட்டை AI க்கும் இதற்கும் இடையேயான அடிப்படை வேறுபாடு ஆகும்.

இறுதியில், முனையம் AI க்கு கைகால்களைக் கொடுத்தது

AI ஐ முனையத்தில் வைப்பது, அதற்கு செயல்படுத்தும் திறனை அளிக்கிறது, வெறும் பரிந்துரைக்கும் திறனை அல்ல.

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

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