ஒரு டோஸ்டருடன் எப்போதாவது சண்டை போட்டு இருக்கிறீர்களா?
டெர்மினல் விண்டோவிற்குள் செயற்கை நுண்ணறிவைக் கொண்டு நிரலை எழுத முயற்சித்த முதல் முறை எனக்கு அப்படித் தான் இருந்தது. நான் பணிவான கோரிக்கைகளைத் தொடர்ந்து தட்டச்சு செய்தேன்; டெர்மினல் ஒரு பார்க்கிங் மீட்டரின் உணர்ச்சிப்பூர்வமான வெப்பத்துடன் பதிலளித்தது. அதே நேரத்தில், ஒரு நண்பர் விஷுவல் ஸ்டுடியோ கோடுக்குள் {Claude}-ஐப் பயன்படுத்தி மகிழ்ச்சியுடன் செயல்பாடுகளை மாற்றி அமைத்துக்கொண்டிருந்தார், அவருடைய கர்சர் ஒரு பிராட்வே கோரஸ் லைன் போல் நடனமாடியது.
எனவே: நீங்கள் {Claude}-உடன் நிரலை எழுத விரும்பினால், நீங்கள் அதை {VS Code}-ல் செய்ய வேண்டுமா அல்லது டெர்மினலில் செய்ய வேண்டுமா? எங்களுடைய சிறிய சுற்றுப்புற பேக்-ஆஃப்க்கு வரவேற்கிறோம்—ஒரு புத்திசாலியான "சமையல்காரருக்கு" இரண்டு சிறந்த "சமையலறைகள்". இந்த வழிகாட்டியில், டெர்மினல் எப்போது மகிழ்ச்சியாக வேகமானது (மற்றும் அற்புதமான அறிவாளித்தனமானது), {VS Code} எப்போது உங்களுடைய நட்பு நிரல் ஜோடியாக மாறும், மேலும் உங்கள் திரையைப் பார்த்து முணுமுணுக்க வைக்கும் பொதுவான தவறுகளை எவ்வாறு தவிர்ப்பது என்பதைக் நான் உங்களுக்குக் காண்பிப்பேன். உண்மையான பணிகளைப் படிப்படியாகப் பார்ப்போம், அதனால் நீங்கள் உண்மையில் எவ்வாறு வேலை செய்கிறீர்கள் என்பதற்குப் பொருத்தமான {Claude} நிரல் இடைமுகத்தை நீங்கள் தேர்வு செய்யலாம்.
உண்மையில் நாம் என்ன ஒப்பிடுகிறோம் (மற்றும் நீங்கள் ஏன் கவலைப்பட வேண்டும்)
பல இடங்களில் நீங்கள் {Claude}-உடன் அரட்டை அடிக்கலாம். ஆனால் நிரல் எழுதுவதற்கு, பெரும்பாலானோர் இரண்டு முகாம்களில் ஒன்றில் இறங்குகிறார்கள்:
- {Claude} நீட்டிப்பு அல்லது பக்கப் பட்டையுடன் கூடிய {VS Code}: உங்களுக்கு இன்லைன் பரிந்துரைகள், விரைவான திருத்தங்கள், கோப்பு சார்ந்த உரையாடல்கள் மற்றும் திட்டம் முழுவதுமான சூழல் கிடைக்கும்.
- டெர்மினல் அடிப்படையிலான {Claude}: {CLI} கருவி அல்லது ஷெல் ஒருங்கிணைப்பு, அங்கு நீங்கள் தூண்டுகிறீர்கள், ஒட்டுகிறீர்கள் மற்றும் இயக்குகிறீர்கள்—வேகமாகவும் இலகுவாகவும், எந்த கனமான {UI}-ம் இல்லை.
முடிவு வெறும் அழகியல் பற்றியது மட்டுமல்ல. இது நீங்கள் எப்படி சிந்திக்கிறீர்கள் என்பதைப் பற்றியது. நீங்கள் உங்கள் எடிட்டரில் வாழ்ந்தால், {VS Code} {Claude} அனுபவம் உங்கள் திட்டத்தில் ஒரு புத்திசாலித்தனமான சக ஊழியரைச் சேர்ப்பது போல் இருக்கும். நீங்கள் கட்டளை வரியில் வாழ்ந்தால், டெர்மினல் இடைமுகம் மவுஸைத் தொடாமல் உங்கள் பணியின் வேகத்தை அதிகரிப்பது போல் இருக்கும்.
உண்மையில் முக்கியமான சூழ்நிலைகளில் அவற்றை ஒப்பிட்டுப் பார்ப்போம்.
நிலை 1: “என்னுடைய ஒழுங்கற்ற களஞ்சியத்தைப் புரிந்து கொள்ளுங்கள்”
இதை படம் பிடித்துக் கொள்ளுங்கள்: நீங்கள் ஒரு கோட் தளத்தை மரபுரிமையாகப் பெறுகிறீர்கள், அது 37% செயல்பாடுகள், 62% {TODOs} மற்றும் 1% நம்பிக்கை கொண்டது. {Claude} அறையைப் படித்து, எலும்புக்கூடுகள் எங்கே புதைக்கப்பட்டுள்ளன என்று சொல்ல வேண்டும் என்று நீங்கள் விரும்புகிறீர்கள்.
- {VS Code}-ல்: நீங்கள் திட்டக் கோப்புறையைத் தேர்ந்தெடுக்கிறீர்கள். {Claude} கோப்புகளைக் குறிப்பிடலாம், தாவல்களைத் திறக்கலாம் மற்றும் தொகுதிகள் முழுவதும் உள்ள வடிவங்களைச் சுருக்கமாகக் கூறலாம். நீங்கள், "{API} அழைப்பிலிருந்து {UI}-க்கு தரவு எவ்வாறு செல்கிறது?" என்று கேட்கிறீர்கள். அது ஒரு வரைபடத்துடன் பதிலளிக்கிறது—கிளிக் செய்யக்கூடிய கோப்புப் பாதைகளுடன். ஏற்கனவே உங்கள் {Dewey Decimal} முறையை அறிந்த ஒரு நூலகரிடம் கேட்பது போன்றது.
- டெர்மினலில்: நீங்கள் சிறு துணுக்குகளை ஒட்டலாம் அல்லது கோப்புகளை {Claude}-க்குள் செலுத்தலாம், ஆனால் நீங்களே நூலகராகிறீர்கள். எந்த கோப்புகளைச் சேர்ப்பது மற்றும் அவற்றை எவ்வாறு பிரிப்பது என்பதை நீங்கள் தீர்மானிக்க வேண்டும். விரைவான அபிப்பிராயத்தைப் பெறுவது வேகமானது, ஆனால் நீங்கள் அந்த நடனத்தை ஸ்கிரிப்ட் செய்யாவிட்டால் அது உங்கள் முழு கோட் தளத்தையும் சுற்றி வராது.
தீர்ப்பு: களஞ்சியத்தின் ஆழமான ஆய்வுக்கு, {VS Code}-ன் {Claude} இடைமுகம் சிறந்த குகை ஹெல்மெட் ஆகும்.
நிபுணர் ஆலோசனை: எந்த செயற்கை நுண்ணறிவுக்கும் ஆயிரம் வரி கோப்பை கொட்டிவிட்டு மாயாஜாலத்தை கேட்காதீர்கள். சிறிய அளவிலான சுருக்கங்களைக் கேளுங்கள்: "{src/api/*.ts}-ல் உள்ள பொறுப்புகளைச் சுருக்கமாகக் கூறுங்கள், பிறகு முதல் மூன்று ஆபத்து பகுதிகளை பட்டியலிடுங்கள்." நீங்கள் கூர்மையான முடிவுகளைப் பெறுவீர்கள்—மற்றும் குறைவான பிரமைகள் ஏற்படும்.
நிலை 2: “பொருட்களை உடைக்காமல் மறுசீரமைக்கவும்”
நாங்கள் அனைவரும் இரண்டு-படி மறுசீரமைப்பை அறிவோம்: குறியீட்டை மாற்றவும், சோதனைகளை இயக்கவும், ஜெபம் செய்யவும், மாற்றியமைக்கவும், மீண்டும் செய்யவும்.
- {VS Code}-ல்: {Claude} மறுசீரமைப்புகளை இன்லைனில் முன்மொழியலாம். நீங்கள் வேறுபாடுகளைப் பார்த்து, மாற்றங்களைச் செய்து, உங்கள் சோதனை இயக்கியை கீழே உள்ள டெர்மினல் பேனலில் குரைக்க அனுமதிக்கலாம். அது ஒரு மூடிய பாதையில் வாகனம் ஓட்டப் பயிற்சி எடுப்பது போல் உள்ளது.
- டெர்மினலில்: {Claude} இன்னும் சிறந்த மறுசீரமைப்புத் திட்டங்களை உருவாக்க முடியும், ஆனால் நீங்கள் வெளியீட்டிற்கும் உங்கள் எடிட்டருக்கும் இடையில் {Alt-Tabbing} செய்து, கைமுறையாகப் பேட்சுகளை ஒட்டி, முரண்பாடுகளை கையால் தீர்க்கிறீர்கள். அது செய்யக்கூடியது தான். ஆனால் சிரமம் அதிகம்.
தீர்ப்பு: மறுசீரமைப்பு நுணுக்கத்திற்கு {VS Code} வெற்றி பெறுகிறது. இன்லைன் சூழல் தான் எல்லாம்.
இன்னும் ஒரு குறிப்பு: முதலில் சோதனைகளை எழுத {Claude}-ஐக் கேளுங்கள். "நாங்கள் மறுசீரமைப்பதற்கு முன்பு, {parseInvoice}-ன் தற்போதைய நடத்தையைப் பிடிக்க {Jest} சோதனைகளை உருவாக்கவும்." நடத்தையைப் பூட்டுங்கள், பிறகு கார் உருட்டிக் கொண்டிருக்கும் போதே இயந்திரத்தை மாற்ற {Claude}-ஐ அனுமதிக்கவும்.
நிலை 3: “20 நிமிடங்களில் ஒரு அம்சத்தை ஸ்பைக் செய்யுங்கள்”
உங்கள் தயாரிப்பு மேலாளர், "மதிய உணவு நேரத்தில் ஒரு முன்மாதிரியை உருவாக்க முடியுமா?" என்று கேட்கிறார். மொழிபெயர்ப்பு: ஓரளவுக்கு வேலை செய்யும் ஒன்றை அனுப்புங்கள்.
- டெர்மினலில்: டெர்மினல் {Claude} பிரகாசிக்கும் இடம் இதுதான். நீங்கள் ஒரு தூண்டுதலை எழுதுகிறீர்கள், ஒரு சிறு துணுக்கை ஒட்டுகிறீர்கள், மேலும் உடனடியாக இயக்கக்கூடிய ஒரு கோப்பு முன்மாதிரியை அல்லது ஷெல் ஸ்கிரிப்டைப் பெறுவீர்கள். எந்த சடங்கும் இல்லை. எந்த நீட்டிப்பு மெனுக்களும் இல்லை. நீங்கள் {MacGyver}, மற்றும் உங்கள் பேப்பர்கிளிப் தூண்டுதல் வரியாக இருக்கிறது.
- {VS Code}-ல்: இன்னும் நல்லது! ஆனால் நீங்கள் விரும்பியதை விட பக்கப் பட்டை மற்றும் கோப்பு சூழலை கையாள அதிக நேரம் செலவிடலாம். நீங்கள் ஒரு கோப்பில் அல்லது ஒரு குறுகிய ஸ்கிரிப்டில் வேகமாக மீண்டும் செய்து கொண்டிருந்தால், டெர்மினலின் உரையாடல் வேகத்தை வெல்வது கடினம்.
தீர்ப்பு: டெர்மினல் {Claude} முன்மாதிரி ஸ்ப்ரிண்டர் ஆகும்.
வேக ஹேக்: உங்கள் தூண்டுதலை ஒரு கோப்பிலிருந்து செலுத்துங்கள். உங்கள் ஸ்டேக் விவரங்களுடன் ஒரு {prompt.md}-ஐ வைத்துக் கொள்ளுங்கள் (“நாங்கள் {Node 20, ESM, pnpm, strict TypeScript, Vitest}-ஐப் பயன்படுத்துகிறோம்”). அதை {Claude}-க்கு முன்கூட்டியே செலுத்துங்கள். வேகமான பதில்கள், குறைவான திருத்தங்கள்.
நிலை 4: “இந்த பிழையை குழந்தைக் காப்பகத்திற்குச் செல்ல தாமதமாகிவிட்டது போல் விளக்குங்கள்”
- {VS Code}-ல்: {TypeScript} {linter} ஒரு வெறுப்பை வெளிப்படுத்தும்போது, அந்தத் தொகுதியை ஹைலைட் செய்து, {Claude}-ஐ, "என்ன நடக்கிறது?" என்று கேளுங்கள். சரியான வரியைக் குறிப்பிடும் ஒரு குறிப்பான விளக்கத்தைப் பெறுவீர்கள், பெரும்பாலும் உடனடியாகப் பயன்படுத்தக்கூடிய ஒரு தீர்வும் இருக்கும். அது உங்கள் தோள்பட்டைக்கு மேல் எட்டிப் பார்க்கும் ஒரு நட்பு {TA}-வைப் போன்றது.
- டெர்மினலில்: நீங்கள் பிழையையும் கோட் துண்டையும் ஒட்டுகிறீர்கள். {Claude} தீர்வை வழங்குகிறது. நன்றாக வேலை செய்கிறது—ஆனால் நீங்கள் சூழலை மிகவும் கவனமாக கவனித்துக் கொள்வீர்கள், மேலும் முக்கியமான இறக்குமதியை அல்லது அருகிலுள்ள செயல்பாட்டை விடுவது எளிதாக இருக்கும்.
தீர்ப்பு: நேர நெருக்கடியான விளக்கம் மற்றும் ஒரு கிளிக் திருத்தங்களுக்கு {VS Code} ஒரு மூக்கு நீளம் முன்னிலை.
நிலை 5: “எதிர்கால நான் புகார் செய்யும் முன் இதை ஆவணப்படுத்துங்கள்”
- {VS Code}-ல்: திறந்த கோப்பில் உள்ள செயல்பாடுகளுக்கான ஆவண சரங்களை உருவாக்க, {README} அவுட்லைனை உருவாக்க அல்லது ஒரு முழு கூறுகளையும் சுருக்கமாகக் கூற {Claude}-ஐக் கேளுங்கள். பயன்படுத்துங்கள், மாற்றியமைக்கவும், முடிந்தது.
- டெர்மினலில்: ஒரு கோப்பகப் பட்டியலிலிருந்து ஒரு {README}-ஐ உருவாக்க அல்லது ஒரு விரைவான {ADR} டெம்ப்ளேட்டை உருவாக்க சிறந்தது. நீங்கள் ஏற்கனவே ஷெல்-லில் வாழ்ந்தால், அது ஒரு வசதியான பாதையாக இருக்கும்.
தீர்ப்பு: சமநிலை. ஆவணமாக்கல் தெளிவு பற்றியது; இரண்டு இடைமுகங்களும் அதை நன்றாக உருவாக்க முடியும். நீங்கள் நாளை திறக்கக்கூடிய ஒன்றைப் பயன்படுத்துங்கள்.
{VS Code}-ல் {Claude}: திரையில் நீங்கள் என்ன பெறுகிறீர்கள்
- திட்டச் சூழல்: {Claude} திறந்த கோப்புகளைப் பார்க்க முடியும் (மேலும், நீட்டிப்பைப் பொறுத்து, அதிகமாகவும் பார்க்க முடியும்). அது குறைவான "தயவு செய்து மீதியை ஒட்டவும்" குறுக்கீடுகளாக மொழிபெயர்க்கப்படுகிறது.
- இன்லைன் திருத்தங்கள் மற்றும் வேறுபாடுகள்: குறியீட்டை முன்னும் பின்னும் ஒட்டுவதற்கு பதிலாக, நீங்கள் மாற்றங்களை தொகுதி தொகுதியாக ஏற்கிறீர்கள். அது நாகரீகமானது.
- பன்முக தூண்டுதல்கள்: சில அமைப்புகள் ஸ்கிரீன்ஷாட்கள், பதிவுகள் அல்லது வரைபடங்களைக் கூட கீழே வைக்க உங்களை அனுமதிக்கின்றன. நீங்கள் நிரலை தொடர்ந்து எழுதிக்கொண்டிருக்கும்போது {Claude} அவற்றைப் சூழலாகப் பயன்படுத்துகிறது.
- குறைவான நகல்/ஒட்டுதல் பிழைகள்: கருவிகளுக்கு இடையிலான பயணத்தின் போது எத்தனை பிழைகள் பிறக்கின்றன என்பது அதிர்ச்சியளிக்கிறது.
சாதக பாதகங்கள்:
- கனமான தடம்: {VS Code} மற்றும் ஒரு {AI} நீட்டிப்பு பழைய கணினிகளில் ஒரு தொலைபேசி பெட்டியில் பேக் பேக் அணிந்திருப்பது போல் உணரலாம்.
- {UX} மேல்நிலை: பேனல்கள், பக்கப் பட்டைகள், டோக்கன்கள்—உங்கள் இடைமுகத்திற்கு அதிகமான... இடைமுகம் உள்ளது.
யார் விரும்புவார்கள்: நடுத்தர மற்றும் பெரிய கோட் தளங்களில் பணிபுரிபவர்கள், சோதனை அடிப்படையிலான டெவ்கள், பராமரிப்பாளர்கள் மற்றும் எடிட்டருக்குள் வசிக்கும் ஒரு பணிவான சக ஊழியர் போல் {Claude} செயல்பட வேண்டும் என்று விரும்புபவர்கள்.
டெர்மினலில் {Claude}: சிறுமைவாதத்திற்காக நீங்கள் என்ன பெறுகிறீர்கள்
- உடனடி தூண்டுதல்கள்: திறக்கவும், தட்டச்சு செய்யவும், உள்ளிடவும். இது நிரல் எழுதுதலின் எஸ்பிரெசோ ஷாட் ஆகும்.
- கூட்டமைப்பு: கோப்புகளைச் செலுத்துங்கள், கட்டளைகளைச் சங்கிலிப்படுத்துங்கள், பேட்ச் கோப்புகளை வெளியீட்டைத் திருப்பி விடுங்கள். அது {bash, fish}, அல்லது {zsh}-உடன் பாடுகிறது.
- எங்கு வேண்டுமானாலும் வேலை செய்கிறது: ஒரு சேவையகத்தில் {SSH}-ல் உள்நுழைந்து {GUI} இல்லாமல் {Claude}-ஐ கலந்தாலோசிக்கவும்.
சாதக பாதகங்கள்:
- நீங்களே சூழல் மேலாளர்: {Claude}-க்கு என்ன காட்ட வேண்டும் மற்றும் எவ்வளவு அடிக்கடி காட்ட வேண்டும் என்பதை நீங்கள் தீர்மானிக்க வேண்டும். மிகக் குறைந்த சூழல் → தெளிவற்ற பதில்கள். அதிகம் → டோக்கன் வரம்புகள்.
- கைமுறை இணைப்பு: நீங்கள் அதை ஸ்கிரிப்ட் செய்யாவிட்டால், நீங்கள் ஒரு திருமண திட்டமிடுபவரை விட அதிகமாக நகல்/ஒட்ட வேண்டியிருக்கும்.
யார் விரும்புவார்கள்: {DevOps} நபர்கள், {CLI} ஆர்வலர்கள், முன்மாதிரி ஸ்ப்ரிண்டர்கள் மற்றும் மவுஸ் கிளிக்குகளுக்கு ஒவ்வாமை உள்ளவர்கள்.
{AI} கோட் உதவி குறித்த ஒரு விரைவான யதார்த்த சோதனை
- {Claude} ஆச்சரியமாக இருக்கலாம். அது நம்பிக்கையுடன் தவறாகவும் இருக்கலாம். உங்கள் சோதனை தொகுப்பை சீட் பெல்ட் போல் கையில் வைத்துக் கொள்ளுங்கள்.
- தூண்டுதல்களுடன் துல்லியமாக இருங்கள். "அதை வேகமாக்குங்கள்" என்பது ஒரு ஜாதகம். "டோக்கன்களை முன்கூட்டியே அட்டவணைப்படுத்துவதன் மூலம் {parseLines}-ல் {O(n^2)}-ஐ அகற்ற மறுசீரமைக்கவும்" என்பது ஒரு கோரிக்கை.
- {AI}-ஐ உங்கள் எண்ணங்களைப் படிக்கச் சொல்லாதீர்கள். பதிப்பு, கட்டமைப்பு, கட்டுப்பாடுகள் மற்றும் நீங்கள் விரும்பும் பாணியை சொல்லுங்கள். இது காபி ஆர்டர் செய்வது போன்றது; "காபி" ஆச்சரியங்களை அளிக்கிறது; "மூன்று ஷாட் ஓட்ஸ் பால் காபி, 140°{F}" நீங்கள் உண்மையில் விரும்புவதை அளிக்கிறது.
{VS Code} அல்லது டெர்மினல்? ஒரு விளையாட்டுத்தனமான நேருக்கு நேர்
- அமைவு வேகம்: டெர்மினல் வெற்றி பெறுகிறது. ஒரு ஸ்கிரிப்ட் போதும், நீங்கள் பந்தயத்தில் இருக்கிறீர்கள்.
- திட்ட அளவிலான விழிப்புணர்வு: {VS Code} வெற்றி பெறுகிறது. அது யாரை பேசுகிறது என்பது அதற்குத் தெரியும்.
- மறுசீரமைப்பு பாதுகாப்பு: அருகிலுள்ள இன்லைன் வேறுபாடுகள் மற்றும் சோதனைகளுடன் {VS Code} வெற்றி பெறுகிறது.
- முன்மாதிரி வேகம்: டெர்மினல் தூய வேகத்திற்கு வெற்றி பெறுகிறது.
- கற்றல் வளைவு: சமநிலை. {VS Code}-ல் அதிக கைப்பிடிகள் உள்ளன; டெர்மினலில் குறைவான பாதுகாப்பு வேலிகள் உள்ளன.
- எடுத்துச் செல்லக்கூடிய திறன்: டெர்மினல் வெற்றி பெறுகிறது; இது {SSH}-ல் வேலை செய்கிறது மற்றும் ஒரு {GUI}-ஐச் சார்ந்து இருக்காது.
ஒட்டுமொத்தமாக: உங்கள் நாள் பெரும்பாலும் "பெரிய திட்டம், பல கோப்புகள், எப்போதும் இயங்கும் சோதனைகள்" என்றால், {VS Code}-ஐத் தேர்வு செய்யுங்கள். உங்கள் நாள் "ஸ்கிரிப்டுகள், சேவையகங்கள், ஸ்பைக்குகள் மற்றும் ஆட்டோமேஷன்" என்றால், டெர்மினலைத் தேர்வு செய்யுங்கள். பல டெவலப்பர்கள் இரண்டுமே பயன்படுத்துவதில் மகிழ்ச்சியடைகிறார்கள்—{VS Code} ஆழமான வேலைக்கு, டெர்மினல் விரைவான வெற்றிகளுக்கு.
{VS Code}-ல் ஒரு இனிமையான {Claude} பணிப்பாய்வை எவ்வாறு அமைப்பது
இந்த தொடக்க வழக்கத்தை முயற்சிக்கவும்:
- அமர்வில் ஒரு சிஸ்டம் தூண்டுதலுடன் {Claude}-ஐ அளவீடு செய்யவும்.
- "{You are a meticulous senior engineer. Prefer readability over cleverness. Use TypeScript strict, Jest for tests, and functional patterns.} நீங்கள் கவிதையை அல்ல, பாதுகாப்புக் கம்பிகளை வழங்குகிறீர்கள்.
- ஒவ்வொரு கோரிக்கையையும் கோப்பு அல்லது செயல்பாட்டு பெயருடன் தொடங்கவும்.
- "{In src/utils/parse.ts, simplify parseInvoice.} {Claude} மனதளவில் சரியான கோப்புடன் ஒத்துப்போகிறார், மேலும் இறுக்கமான தீர்வுகளை வழங்குகிறார்.
- கட்டிகளை அல்ல, வேறுபாடுகளைக் கேளுங்கள்.
- "{Propose a minimal diff; avoid changing unrelated code.} உங்கள் எதிர்கால சுயநலம் கோட் மதிப்பாய்வின் போது உங்களுக்கு நன்றி தெரிவிக்கும்.
- ஆபத்தான மாற்றங்களுக்கான சோதனைகளை {Claude} எழுதட்டும்.
- "{Generate Jest tests for edge cases in parseInvoice: negative amounts, malformed dates, Unicode currency symbols.}
- பெயரிடும் கொள்கையை ஏற்றுக்கொள்ளுங்கள்.
- "{Use descriptive names over abbreviations, British spellings allowed only in comments.} நீங்கள் ஒரு பெயரிடும் காஸ்டியூம் பார்ட்டியை அல்ல, நிலையான குறியீட்டைப் பெறுவீர்கள்.
{VS Code}-ல் சரிசெய்தல்:
- {Claude} சூழலை மறந்து கொண்டே இருக்கிறார்: முக்கிய கோப்புகளை மீண்டும் திறக்கவும், என்ன மாறியது என்பதை சுருக்கமாகக் கூறவும், கட்டுப்பாடுகளை மீண்டும் கூறவும். புதிய பணியாளரை பணியில் அமர்த்துவது போல் நடத்துங்கள்—தயவாக, ஆனால் முழுமையாக.
- வெளியீடு மிக நீளமாக உள்ளது: முதலில் ஒரு திட்டத்தைக் கேளுங்கள். "5 தோட்டாக்களைப் பயன்படுத்தி படிகளை கோடிட்டுக் காட்டுங்கள்; ஒப்புதலுக்காக காத்திருங்கள்." பிறகு கட்டுகளாக தொடரவும்.
- பிரமை இறக்குமதிகள்: குறியீட்டை முன்மொழிவதற்கு முன்பு {package.json} மற்றும் திறந்த கோப்பு பட்டியலுக்கு எதிராக இறக்குமதிகளை சரிபார்க்க {Claude}-ஐக் கேளுங்கள்.
ஒரு வேகமான {Claude} டெர்மினல் கருவித்தொகுப்பை எவ்வாறு உருவாக்குவது
கட்டளை வரியை உங்கள் ஏவுதளமாக்குங்கள்:
- தூண்டுதல் சுயவிவரத்தை உருவாக்கவும்: உங்கள் ஸ்டேக் மற்றும் விருப்பங்களை {~/.clauderc} அல்லது {prompt.md}-ல் சேமிக்கவும். ஒவ்வொரு அரட்டையிலும் அதைச் செலுத்துங்கள்:
claude --with prompt.md.
- ஒரு நிபுணரைப் போல் கோப்புகளைச் செலுத்துங்கள்:
claude -f src/parse.ts -f test/parse.test.ts "Explain the failing case".
- பேட்ச் கோப்புகளை உருவாக்கவும்: "ஒருங்கிணைந்த வேறுபாட்டை மட்டும் திருப்பி அனுப்பவும்." ஒரு பேட்சிற்கு திருப்பி விடுங்கள்:
> change.patch பிறகு git apply change.patch.
- கோப்பகங்களை சுருக்கமாகக் கூறவும்:
tree -I node_modules src | claude -p "Summarize the architecture; propose refactor steps".
- டோக்கன் பட்ஜெட்டை வைத்திருங்கள்: சுருக்கமான வெளியீடுகளைக் கேளுங்கள். "அதிகபட்சம் 120 வரிகள்; மீண்டும் மீண்டும் குறியீடு இல்லை; பெயரால் செயல்பாடுகளைக் குறிப்பிடவும்."
டெர்மினலில் சரிசெய்தல்:
- சூழல் வெட்டுக்கள்: பணியைப் பிரிக்கவும். "பகுதி 1: திட்டம். பகுதி 2: தொகுதி {A}-வை செயல்படுத்தவும். பகுதி 3: சோதனைகள்."
- முரண்பாடான திருத்தங்கள்: கோப்பின் மூலம் வேறுபாடுகளை உருவாக்கவும். படிப்படியாகப் பயன்படுத்துங்கள், படிகளுக்கு இடையில் சோதனைகளை இயக்கவும்.
- காணாமல் போன இறக்குமதிகள்: சரிபார்ப்பு பாஸைக் கோருங்கள்: "புதிய இறக்குமதிகளை பட்டியலிடுங்கள்; அவை {package.json}-ல் இருக்கிறதா என்பதை உறுதிப்படுத்தவும்."
இதோ ஒரு ஆச்சரியம்: {Sider.AI} இந்த உலகங்களுக்கு இடையே ஒரு எளிதான பாலமாக இருக்கிறது. இது உங்கள் உலாவியில் அமர்ந்து உங்கள் நிரல் எழுதும் வாழ்க்கையில் இணைக்கிறது—ஆராய்ச்சி, கோட் விளக்கங்கள் மற்றும் {VS Code} அல்லது டெர்மினலில் நீங்கள் ஒட்டக்கூடிய ஸ்மார்ட் சிறு துணுக்குகளுக்கான பக்கப் பட்டையாக இருக்கிறது. {Claude} கோப்புகளை மறுசீரமைக்கும் போது இயங்கும் "லேப் நோட்புக்கை" வைத்துக்கொள்ள நான் இதைப் பயன்படுத்தினேன்: {Sider} தூண்டுதல்களைக் கண்காணிக்கும், ஆவணங்களுக்கான இணைப்புகளை வழங்கும், மேலும் பத்து நிமிடங்களுக்கு முன்பு நீங்கள் உருவாக்கிய அந்த சரியான ரெஜெக்ஸைத் தேடாமல் இருக்க, சிறு துணுக்குகளை சேமிக்கும். இது சரியானது அல்ல—எந்தக் கருவியும் சரியானது அல்ல—ஆனால் சூழலை கையாளுவதற்கும் நகல்/ஒட்டுதல் சோர்வுக்கும், இது ஒரு நாகரீகமான உதவியாளராக இருக்கிறது. நிபுணர் மூவ்: பிழைப் பதிவுகள், ஸ்டாக் டிரேஸ்கள் மற்றும் தொடர்புடைய கோட் துண்டுகளை ஒரு நேர்த்தியான விவரணையில் சேகரிக்க {Sider.AI}-ஐப் பயன்படுத்தவும். பிறகு அந்த க்யூரேட் செய்யப்பட்ட கட்டுகளை இரண்டு இடைமுகத்திலும் {Claude}-க்கு ஒப்படைக்கவும். பொருட்கள் எவ்வளவு சிறப்பாக இருக்கிறதோ, கேக் அவ்வளவு சிறப்பாக இருக்கும். உண்மையான டெமோ: எரிச்சலூட்டும் ஸ்கிரிப்டிலிருந்து சுத்தமான தொகுதிக்கு (இரண்டு வழிகள்)
நீங்கள் {CSV} ஆர்டர்களை அலசி அறிக்கைகளை மின்னஞ்சல் செய்யும் ஒரு பைதான் ஸ்கிரிப்ட்டை வைத்திருக்கிறீர்கள் என்று வைத்துக்கொள்வோம். இது 400 வரிகள் நீளமானது மற்றும் யூனிட் டெஸ்ட்டுகளுக்கு ஒவ்வாமை கொண்டது.
நோக்கம்: பார்சரை ஒரு தொகுதியாக பிரித்தெடுக்கவும், சோதனைகளை எழுதவும் மற்றும் தொகுதிக்கு ஸ்கிரிப்ட் அழைப்பு செய்யவும்.
வழி {A}: {Claude}-உடன் {VS Code}
- திட்டத்தைத் திறந்து, {parse_orders} செயல்பாட்டை ஹைலைட் செய்யவும்.
- தூண்டுதல்: "{Extract parse_orders into src/parser.py. Keep behavior identical. Then propose pytest tests covering malformed rows, missing fields, and UTF-8 edge cases. Prefer pure functions; no globals.}
- மாறுபாடு காட்சியை மதிப்பாய்வு செய்யவும். {parser.py}-ல் உள்ள மாற்றங்களையும் புதிய சோதனைகளையும் மட்டும் ஏற்றுக்கொள்ளவும்.
- ஒருங்கிணைக்கப்பட்ட டெர்மினலில் சோதனைகளை இயக்கவும். {Claude}-ன் உதவியுடன் ஏதேனும் இறக்குமதி குளறுபடிகளை சரிசெய்யவும்.
- ஆவணச் சரங்களைக் கேளுங்கள் மற்றும் புதிய தொகுதியின் {API}-ஐ விளக்கும் {README} சிறு துணுக்கைக் கேளுங்கள்.
விளைவு: சுத்தமான பிரிப்பு, சோதனைகள் எழுதப்பட்டன, ஆவணமாக்கல் தொடங்கப்பட்டது—எல்லாம் ஒரே சாளரத்திற்குள்.
வழி {B}: {Claude}-உடன் டெர்மினல்
- உங்கள் ஸ்டேக் மற்றும் கட்டுப்பாடுகளை விவரிக்கும் ஒரு சுயவிவர தூண்டுதலை {prompt.md}-ல் சேமிக்கவும்.
- செயல்பாடு மற்றும் சில மாதிரி {CSV} வரிகளைச் செலுத்தவும்:
sed -n '1,200p' orders.py | claude -p prompt.md -p "Extract parse_orders into parser.py; output a unified diff only." > patch.diff.
- பேட்சைப் பயன்படுத்தவும்:
git apply patch.diff.
- சோதனைகளைக் கேளுங்கள்:
claude -p "Write pytest tests for parser.py covering malformed rows, missing fields, and UTF-8 edge cases. No explanations, just tests." > tests/test_parser.py.
pytest-ஐ இயக்கவும். உங்களுக்கு தோல்விகள் ஏற்பட்டால், குறிப்பிட்ட சோதனை மற்றும் வரிகளுடன் பிழையை {Claude}-க்கு ஒட்டவும்.
விளைவு: மின்னல் வேகமானது, விசைப்பலகை மட்டும், அதிக ஸ்கிரிப்ட் செய்யக்கூடியது.
உங்கள் மூளைக்கு ஏற்ற பாதையைத் தேர்வு செய்யவும். இரண்டும் ஒரே சுத்தப்படுத்தப்பட்ட குறியீட்டில் வந்து சேரும்; ஒன்று உங்களுக்கு பயிற்சி சக்கரங்களைக் கொடுக்கிறது, மற்றொன்று உங்களுக்கு ஒரு பந்தய மைதானத்தைக் கொடுக்கிறது.
பாதுகாப்பு மற்றும் தனியுரிமை: ஒரு விரைவான பெரியவர்கள் தருணம்
- ரகசியங்களை ஒட்ட வேண்டாம். தூண்டுதல்களில் திருத்தப்பட்ட பதிவுகள் அல்லது போலி டோக்கன்களைப் பயன்படுத்தவும்.
- உங்கள் நீட்டிப்பு அல்லது {CLI} அமைப்புகளைச் சரிபார்க்கவும்: சில டெலிமெட்ரியை அனுப்புகின்றன, சில அனுப்பவில்லை. உங்கள் நிலைமாற்றிகளை தெரிந்து கொள்ளுங்கள்.
- வேலை குறியீட்டிற்காக, நீங்கள் கொள்கைக்குள் இருக்கிறீர்களா என்பதை உறுதிப்படுத்தவும். உங்கள் செயற்கை நுண்ணறிவு சோதனைகளைப் பற்றி ஒரு மாநாட்டுப் பேச்சிலிருந்து உங்கள் சட்டக் குழு அறிந்து கொள்ள விரும்பவில்லை.
கீழே உள்ள வரி: உங்கள் சிறந்த {Claude} கோட் இடைமுகம்
நீங்கள்:
- மல்டி-ஃபைல் திட்டங்களை நிர்வகிக்கவும், இன்லைன் வேறுபாடுகளை விரும்பவும், {Claude} நிலத்தின் தன்மையைப் புரிந்து கொள்ள வேண்டும் என்று விரும்பினால் → {VS Code}-ஐத் தேர்வு செய்யுங்கள்.
- {SSH} அமர்வுகளில் வாழ்கிறீர்கள், ஸ்கிரிப்ட்களை அனுப்பவும் மற்றும் விழாவை விட வேகத்திற்கு மதிப்பு கொடுக்கிறீர்கள் → டெர்மினலைத் தேர்வு செய்யுங்கள்.
- இரண்டு வகையான வேலைகளையும் செய்கிறீர்கள் → கலப்பினக் கூட்டத்தில் சேருங்கள்: மறுசீரமைப்புகள் மற்றும் கட்டிடக்கலைக்கு {VS Code}, ஒரு முறை மற்றும் முன்மாதிரிகளுக்கு டெர்மினல்.
எப்படியிருந்தாலும், நீங்கள் எப்போது வேகமாக முன்னேறுவீர்கள்:
- {Claude}-க்கு மிருதுவான சூழலை வழங்குங்கள்.
- குறுகிய, சோதனைச் செய்யப்பட்ட சுழல்களில் வேலை செய்யுங்கள்.
- வேறுபாடுகள், சோதனைகள் மற்றும் சரிபார்ப்பு பாஸ்களைக் கோருங்கள்.
கடைசியாக ஒன்று: கருவிகள் காலணிகள் போன்றவை. நீங்கள் நாள் முழுவதும் கொப்புளங்கள் இல்லாமல் அணியக்கூடிய “சிறந்த” {Claude} கோட் இடைமுகம் அதுதான். ஒரு வாரம் இரண்டுமே முயற்சி செய்யுங்கள்—எது பொருந்துகிறது என்று உங்கள் விரல்கள் உங்களுக்குச் சொல்லும்.
விரைவான குறிப்பு: அவற்றின் எடையை விட அதிகமாக குத்தும் தூண்டுதல்கள்
- "முதலில் திட்டமிடுங்கள், பிறகு 5 தோட்டாக்களைப் பயன்படுத்தி குறியீட்டை எழுதுங்கள். எனது ஓகேக்காக காத்திருங்கள்."
- "{Return a unified diff for src/utils/format.ts only.}
- "{Before changes, list risks and how to test each.}
- "{Write tests that capture current behavior; don’t improve it yet.}
- "{Verify imports against package.json; list any new dependencies separately.}
- "{Keep functions pure; no hidden I/O. If unavoidable, isolate side effects.}
மகிழ்ச்சியான நிரலாக்கம்—உங்கள் வேறுபாடுகள் சிறியதாகவும் உங்கள் சோதனைகள் சத்தமாகவும் இருக்கட்டும்.
அடிக்கடி கேட்கப்படும் கேள்விகள்
கேள்வி 1: {Claude} கோட் உதவிக்கு எது சிறந்தது: {VS Code} அல்லது டெர்மினல்?
திட்டம் முழுவதுமான சூழல், இன்லைன் வேறுபாடுகள் மற்றும் விரைவான திருத்தங்களை நீங்கள் விரும்பும் போது {VS Code}-ஐப் பயன்படுத்தவும். உங்களுக்கு மூல வேகம், ஸ்கிரிப்ட் செய்யக்கூடிய தன்மை மற்றும் {SSH}-நட்பு தூண்டுதல்கள் தேவைப்படும்போது டெர்மினலைப் பயன்படுத்தவும். பல டெவலப்பர்கள் இரண்டுமே பயன்படுத்துகிறார்கள்—மறுசீரமைப்புகளுக்கு {VS Code}, முன்மாதிரிகளுக்கு டெர்மினல்.
கேள்வி 2: {Claude} டெர்மினல் இடைமுகம் உண்மையான வேலைக்கு போதுமான வேகமானதா?
ஆம்—இது விரைவான ஸ்கிரிப்டுகள், ஸ்பைக்குகள் மற்றும் சேவையக பக்கப் பணிகளுக்கு அருமையானது. {Claude}-க்கு சரியான கோப்புகளைச் செலுத்துங்கள், வேறுபாடுகளைக் கேளுங்கள், மேலும் பேட்ச்களை படிப்படியாகப் பயன்படுத்துங்கள் என்பதை நினைவில் கொள்ளுங்கள்.
கேள்வி 3: {Claude}-உடன் நிரல் எழுதும் போது செயற்கை நுண்ணறிவு பிரமைகளை எவ்வாறு தவிர்ப்பது?
குறிப்பாகவும் சோதனை அடிப்படையிலும் இருங்கள். குறியீட்டிற்கு முன் திட்டங்களைக் கேளுங்கள், குறைந்தபட்ச வேறுபாடுகளைக் கோருங்கள், மேலும் ஒவ்வொரு மாற்றத்திற்குப் பிறகும் உங்கள் தொகுப்பை இயக்கவும். சந்தேகம் இருந்தால், உங்கள் திட்டத்திற்கு எதிராக இறக்குமதிகள் மற்றும் சார்புகளை சரிபார்க்க {Claude}-ஐப் பயன்படுத்தவும்.
கேள்வி 4: {VS Code}-ல் {Claude} எனது முழு களஞ்சியத்தையும் புரிந்து கொள்ள முடியுமா?
அது நீங்கள் திறக்கும் கோப்புகளையும் நீங்கள் பகிர்ந்து கொள்ளும் கட்டிகளையும் புரிந்து கொள்ள முடியும், இது பொதுவாக கவனம் செலுத்தும் பணிகளுக்கு போதுமானதாக இருக்கும். பெரிய கோட் தளங்களுக்கு, டோக்கன் வரம்புகளுக்குள் இருக்க முதலில் சுருக்கங்களையும் பிறகு குறிவைக்கப்பட்ட திருத்தங்களையும் செய்யுங்கள்.
Q5: ஒரு Claude கோடிங் செயல்முறையில் Sider.AI எங்கு உதவுகிறது?
நீங்கள் வேலை செய்யும் போது, தூண்டுதல்கள், சிறு துணுக்குகள் மற்றும் ஆவணங்களை ஒழுங்கமைக்க Sider.AI சிறந்தது. பிழை பதிவுகள் மற்றும் குறியீடு துண்டுகளை ஒரு நேர்த்தியான விவரணையாக சேகரிக்க இதைப் பயன்படுத்தவும், பின்னர் VS Code அல்லது டெர்மினலில் அந்தத் தொகுக்கப்பட்ட சூழலை Claude-க்கு வழங்கவும். 
