நீங்கள் Claude Code-ஐ நிறுவியுள்ளீர்கள். அதன் அடிப்படைகளைக் கற்றுக்கொண்டு, சில ப்ராம்ப்ட்களை (prompts) எழுதியிருப்பீர்கள், ஒருவேளை உங்கள் புராஜெக்ட் ரூட்டில் (project root) ஒரு CLAUDE.md கோப்பையும் உருவாக்கியிருக்கலாம். பிறகு அந்தத் தருணம் வருகிறது. Claude ஒரு நுணுக்கமான புராஜெக்ட் மரபுமுறையை (convention) தவறவிடுவதையோ, ஒரு தவறான திட்டத்திற்காக (Bad plan) இருபது காசுகள் மதிப்பிலான டோக்கன்களை வீணாக்குவதையோ அல்லது மூன்றாவது முறையாக உங்கள் பாதுகாப்பு விதிகளைப் பின்பற்றத் தவறுவதையோ நீங்கள் பார்க்கிறீர்கள். இந்தத் கருவி இன்னும் சிறப்பாகச் செயல்பட முடியும் என்று உங்களுக்குத் தெரியும், ஆனால் அதிகாரப்பூர்வ ஆவணங்கள் அதன் இயந்திரத்தைப் (engine) பற்றி மட்டுமே கூறுகின்றன. உங்கள் அன்றாடப் பணிப்பாய்விற்கு (workflow) எந்த சமூகத்தால் உருவாக்கப்பட்ட டயர்கள், டர்போசார்ஜர்கள் மற்றும் வழிசெலுத்தல் அமைப்புகள் (navigation systems) சரியாகப் பொருந்தும் என்பதை அது உங்களுக்குச் சொல்லவில்லை. நல்ல விஷயங்களைக் கண்டறிய என்பது சிதறிக்கிடக்கும் Twitter திரெட்கள், Discord துணுக்குகள் மற்றும் கைவிடப்பட்ட சோதனைகளுக்கு இடையே ஊடுருவிச் செல்வதாகும்.
அதே இடைவெளியைத்தான் awesome-claude-code நிரப்புகிறது.
GitHub பயனரான hesreallyhim என்பவரால் உருவாக்கப்பட்ட இந்தத் களஞ்சியம் (repository), சுமார் 47,000 ஸ்டார்கள் (stars) மற்றும் கிட்டத்தட்ட 4,000 ஃபோர்க்குகளை (forks) பெற்றுள்ளது. இந்த எண்கள் வெறும் பெருமைக்காக மட்டும் அல்ல. திறந்த மூல (open-source) கலாச்சாரத்தில், இந்த அளவு என்பது பயனர்கள் தங்கள் கவனத்தின் மூலம் வாக்களிக்கிறார்கள் என்பதைக் குறிக்கிறது. இது ஒரு உயிருள்ள வடிகட்டி. Claude Code தானாகவே வாரந்தோறும் புதிய அம்சங்களை வெளியிடுவதால், ஒரு நிலையான வலைப்பதிவு (blog post) சில நாட்களிலேயே காலாவதியாகிவிடும். சமூகத்துடன் இணைந்து நகரும் ஒரு தொகுக்கப்பட்ட களஞ்சியம் (curated repository), உங்களைச் சிதைந்த பிளக்-இன்களில் இருந்து விலக்கி, மற்றவர்களின் உற்பத்திச் சூழலில் (production environment) நிலைத்து நின்ற கருவிகளை நோக்கி வழிநடத்தும் ஒரு நிகழ்நேர வரைபடமாகச் செயல்படுகிறது.
ஏன் இந்தச் சூழலுக்கு (Ecosystem) ஒரு வரைபடம் தேவை?
Claude Code என்பது ஒரு சாதாரண சாட் விண்டோ (chat wrapper) அல்ல. இது ஷெல் கட்டளைகளை (shell commands) இயக்கக்கூடிய, கோப்புகளைப் படிக்கக்கூடிய, துணை ஏஜென்ட்களை (sub-agents) உருவாக்கக்கூடிய மற்றும் தனது வேலையைத் தானே மேம்படுத்திக்கொள்ளக்கூடிய ஒரு ஏஜென்டிக் கோடிங் சூழலாகும் (agentic coding environment). அந்த ஆற்றல் சிக்கலையும் உருவாக்குகிறது. ஒரு மையக் குறியீடு (central index) இல்லையென்றால், ஒவ்வொரு பயனரும் ஒரே மாதிரியான அமைப்புகளை மீண்டும் மீண்டும் உருவாக்கிக்கொண்டிருப்பார்கள், ஒரே மாதிரியான ப்ராம்ப்ட் இன்ஜினியரிங்கைத் திரும்பத் திரும்பச் செய்வார்கள் மற்றும் ஒரே மாதிரியான ஆட்டோமேஷன் ஹூக்குகளைத் (automation hooks) தேடிக்கொண்டிருப்பார்கள். awesome-claude-code களஞ்சியம் அந்தத் தேவையற்றத் திரும்பத் திரும்பச் செய்யும் செயலை ஒரு பிழையாகக் கருதுகிறது. இது தீர்வுகளை மக்கள் உண்மையில் வேலை செய்யும் முறையிலேயே ஆறு வகைகளாகப் பிரிக்கிறது.
ஏஜென்ட் திறன்கள்: ஒரு கோப்பில் உள்ள நிபுணத்துவ அறிவு
ஏஜென்ட் திறன்கள் (Agent skills) என்பவை Claude-க்கு குறிப்பிட்ட துறை சார்ந்த செயல்பாடுகளைக் கற்பிக்கும் Markdown கோப்புகளாகும். உங்கள் CLAUDE.md-இல் தெளிவற்ற அறிவுறுத்தல்களைத் திணிப்பதற்குப் பதிலாக, ஒரு சுருக்கமான பாடப்புத்தகம் போலச் செயல்படும் ஒரு திறன் கோப்பை (skill file) நீங்கள் அதில் சேர்க்கலாம். இந்தத் தொகுப்பு Trail of Bits வெளியிட்ட பாதுகாப்புத் திறன்களுடன் இணைக்கப்பட்டுள்ளது. ஒன்றை ஏற்றினால், Claude பொதுவான "உங்கள் இன்புட்களைச் சுத்திகரிக்கவும்" (sanitize your inputs) போன்ற ஆலோசனைகளை வழங்குவதை நிறுத்திவிட்டு, memory-safe முறைகள், dependency அபாயச்ங்கிலிகள் மற்றும் supply-chain சுகாதாரம் ஆகியவற்றைத் தெரிந்த ஒரு தணிக்கையாளர் (auditor) போலச் சிந்திக்கத் தொடங்கும். கிளவுட் தளங்களுக்கான (cloud platforms) DevOps திறன்களும் இதில் உள்ளன. ஒவ்வொரு முறையும் IAM கொள்கை அமைப்பு அல்லது Kubernetes வள வரம்புகளை (resource limits) மீண்டும் விளக்க வேண்டிய அவசியமில்லை; திறன் கோப்பு ஒருமுறை மாடலைத் தயார்படுத்திவிடும், அதன் பிறகு உங்கள் அடுத்தடுத்த ப்ராம்ப்ட்கள் அந்தத் தெளிவான சூழலைப் பயன்படுத்திச் செயல்படும்.
பணிப்பாய்வுகள் (Workflows): முதல் வரி குறியீட்டிற்கு முன்பே ஒழுக்கத்தைக் கட்டாயப்படுத்துதல்
இங்கு தனித்துத் தெரிவது RIPER பணிப்பாய்வு (workflow) ஆகும். இது Research, Ideate, Plan, Execute, மற்றும் Review என்பதைக் குறிக்கிறது. நடைமுறையில், இது ማለት தொடர்புடைய கோப்புகளை ஆய்வு செய்தும், கட்டுப்பாடுகளைச் சிந்தித்தும், ஒரு திட்டத்தை வரைந்தும் முடிக்காமல் Claude உங்கள் கோட் பேஸைத் (codebase) தொட முடியாது என்பதாகும். ஒரு டோக்கன் கூடச் செலவிடப்படுவதற்கு முன்பே அந்த அணுகுமுறையை அங்கீகரிக்க உங்களுக்கு ஒரு வாய்ப்பு கிடைக்கிறது. Claude ஒரு கோப்பின் பாதியைத் தன்னம்பிக்கையுடன் refactor செய்துவிட்டு, இறுதியில் build-ஐ உடைப்பதைப் பார்த்த எவருக்கும், இந்த இடைவேளை மிகவும் மதிப்புமிக்கது. இது கருவியை ஒரு ஆர்வமுள்ள தட்டச்சு செய்பவரிடமிருந்து ஒரு கவனமான வடிவமைப்பாளராக (architect) மாற்றுகிறது. சிக்கலான refactorகள், அறிமுகமில்லாத கோட் பேஸ்கள் அல்லது ஒரு தவறான முடிவின் விலை, ஒரு திட்டத்திற்காக முப்பது வினாடிகள் காத்திருப்பதை விட அதிகமாக இருக்கும் எந்தவொரு பணிக்கும் இதைப் பயன்படுத்தவும்.
கருவிகள் (Tooling): செலவுகளையும் உள்ளடக்கத்தையும் காணுதல்
கருவிகள் பிரிவில் ccflare மற்றும் claude-devtools ஆகியவை அடங்கும்.
நீங்கள் தினமும் Claude Code-ஐப் பயன்படுத்தினால், API செலவுகள் நீங்கள் எதிர்பார்ப்பதை விட வேகமாகத் திரளும். பல கருவி அழைப்புகளுடன் கூடிய ஒரு நீண்ட ஏஜென்டிக் அமர்வு (agentic session), ஒரு நல்ல மதிய உணவை விட அதிகச் செலவைச் செய்யலாம். ccflare உங்கள் டோக்கன் செலவை நிகழ்நேரத்தில் (real time) கண்காணிக்கிறது, எந்தச் செயல்பாடுகள் அதிக கிரெடிட்களைச் செலவிடுகின்றன என்பதைத் தனித்தனியாகக் காட்டுகிறது. அந்தத் தெளிவுதான் உங்கள் பணிப்பாய்வை மேம்படுத்துவதற்கும், எதிர்பாராத பில்லுக்கு ஆளாவதற்கும் இடையிலான வித்தியாசமாகும்.
claude-devtools ஒரு வேறு மர்மத்தைத் தீர்க்கிறது. இணையத் தேடல், சோதனை அல்லது ஆவணமாக்கல் பணிகளைக் கையாள Claude துணை ஏஜென்ட்களை உருவாக்கும்போது, முக்கியத் தளம் (main thread) ஒரு கருப்புப் பெட்டி (black box) போலத் தெரியலாம். இந்தத் கருவி அதன் செயல்பாட்டு வரைபடத்தை (execution graph) வெளிப்படுத்துகிறது. எந்தத் துணை ஏஜென்ட் எந்தக் கோப்பைக் கையாண்டது, அது திட்டத்திலிருந்து எங்கு விலகியது மற்றும் ஒரு குறிப்பிட்ட பணி ஏன் தோல்வியடைந்தது என்பதை நீங்கள் பார்க்கலாம். அந்தத் தெளிவு இல்லாமல் ஏஜென்டிக் மென்பொருளை டீபக் (debug) செய்வது என்பது, லாக்ஸ் (logs) இல்லாத ஒரு விநியோகிக்கப்பட்ட அமைப்பை (distributed system) சரிசெய்ய முயல்வதைப் போன்றது.
ஹூக்ஸ் (Hooks): நிலைத்திருக்கும் தானியங்கி முறைகள்
Hooks என்பது Claude Code-ன் வாழ்க்கைச் சுழற்சியில் (lifecycle) குறிப்பிட்ட தருணங்களில் இயங்கும் ஸ்கிரிப்ட்கள் ஆகும். ஒரு கருவி (tool) தொடங்குவதற்கு முன்போ, ஒரு பதில் முடிந்த பின்னரோ அல்லது பிற வரையறுக்கப்பட்ட நிகழ்வுகளின் போதோ நீங்கள் ஒன்றைப் பயன்படுத்தலாம். இந்தத் தொகுப்பு (repository) "hello world" என்பதையும் தாண்டிச் செல்லும் நடைமுறை உதாரணங்களைச் சேகரித்து வைக்கிறது. ஒரு முன்-செயலாக்க ஹூக் (pre-execution hook), முன்மொழியப்பட்ட ஷெல் கட்டளையை (shell command) அழிவுகரமான செயல்பாடுகளின் பட்டியலுடன் ஒப்பிட்டுச் சரிபார்க்கலாம். ஒரு பதில்-பின்বর্তী ஹூக் (post-response hook), உருவாக்கப்பட்ட குறியீட்டில் (code) உங்கள் லின்டரை (linter) இயக்கலாம், ஒரு திட்டப் பதிவில் (project log) முடிவைச் சேர்க்கலாம் அல்லது வெளியீடுகள் உங்கள் ஸ்கீமாவுடன் (schema) பொருந்துகின்றனவா என்பதைச் சரிபார்க்கலாம். நீங்கள் அடிப்படை ஹூக்குகளைக் கூட இணைத்துவிட்டால், நீங்கள் Claude-ஐக் கண்காணிப்பதை நிறுத்திவிட்டு, அதை ஒருங்கிணைக்கத் (orchestrate) தொடங்கிவிடுவீர்கள். இந்தத் தொகுப்பில் உள்ள ஹூக் வழிகாட்டிகள் ஒரு சிறந்த தொடக்கப்புள்ளி, ஏனெனில் இதன் தானியங்கி செயல்பாடுகள் (automation) மிக விரைவாகப் பலன் தரும்.
ஸ்லாஷ் கட்டளைகள் (Slash Commands): மீண்டும் மீண்டும் செய்யப்படும் வேலைகளுக்கான சுருக்கமான வழிமுறை
ஸ்லாஷ் கட்டளைகள் நீண்ட ப்ராம்ப்ட் முறைகளை (prompt patterns) ஒற்றைத் தூண்டுதல்களாக (single triggers) சுருக்குகின்றன. இந்தத் தொகுப்பு Git, சோதனை (testing) மற்றும் ஆவணமாக்கல் (documentation) பணிப்பாய்வுகளுக்கான கட்டளைகளைப் பட்டியலிடுகிறது. /git என்று தட்டச்சு செய்தால், உங்கள் திட்டத்தின் conventional-commit விதிகளின்படி, உண்மையான மாற்றங்களிலிருந்து (diff) உருவாக்கப்பட்ட ஒரு கமிட் செய்தியைப் பெறலாம். உங்கள் உண்மையான fixtures-களை இறக்குமதி செய்து, உங்கள் பாணியைப் பின்பற்றும் யூனிட்-டெஸ்ட் கட்டமைப்பை (unit-test scaffolding) உருவாக்க /test என்பதை அழுத்தவும். சரியான தலைப்புகள் மற்றும் குறுக்கு-குறிப்புகளுடன் (cross-references) Markdown கோப்புகளை உருவாக்க /docs-ஐப் பயன்படுத்தவும். இவை வெறும் பொழுதுபோக்குத் தந்திரங்கள் அல்ல. துல்லியமான ப்ராம்ப்ட் வாசகங்களை நினைவில் வைத்துக்கொள்ள நீங்கள் தற்போது செலவிடும் மன ஆற்றலை இவை மீட்டெடுக்கின்றன.
ஆய்வு செய்யத் தகுதியான ஒரு CLAUDE.md நூலகம்
CLAUDE.md கோப்பு என்பது தொடர்ச்சியான திட்டச் சூழலுக்கான (persistent project context) Claude Code-ன் வழிமுறையாகும், இருப்பினும் பெரும்பாலான பயனர்கள் இதைத் தன்னிச்சையான நினைவூட்டல்கள் நிறைந்த ஒரு ஸ்டிக்கி நோட் (sticky note) போலக் கருதுகின்றனர். இந்தத் தொகுப்பு Python, Rust, Go மற்றும் TypeScript ஆகியவற்றிற்கான உயர்தர உதாரணங்களைக் கொண்டுள்ளது. அவற்றைப் படிப்பது ஒரு அனுபவம் வாய்ந்த டெவலப்பரின் பார்வையில் பார்ப்பது போன்றது. கட்டடக்கலை முடிவுகள் (architecture decisions), லின்டிங் விதிகள் (linting rules), சோதனைத் தத்துவங்கள் (testing philosophies) மற்றும் சார்பு முறைகளை (dependency patterns) எவ்வாறு தெளிவாகக் கூறுவது என்பதையும், அது எவ்வாறு உண்மையில் Claude-ன் நடத்தையை மாற்றியமைக்கிறது என்பதையும் நீங்கள் காண்பீர்கள். புதிதாக ஒன்றை எழுதி, மூன்று வாரங்களுக்குப் பிறகு உங்கள் அறிவுறுத்தல்கள் தெளிவற்றவை என்பதைக் கண்டறிவதை விட, இந்த நூலகத்திலிருந்து ஒரு செயல்படும் டெம்ப்ளேட்டைத் (template) தேர்ந்தெடுத்து அதைத் தழுவிக்கொள்வது சிறந்தது.
மூழ்கிவிடாமல் இதை எவ்வாறு அணுகுவது
நீங்கள் செய்யக்கூடிய மிக மோசமான விஷயம், இந்தத் தொகுப்பை ஒரு ஷாப்பிங் பட்டியலைப் போலக் கருதி, ஒரு மழைக்கால ஞாயிற்றுக்கிழமையில் அனைத்தையும் நிறுவுவதுதான். அந்த அளவுக்கு இந்தச் சூழல் (ecosystem) விரிவானது. முதலில் இந்தத் தொகுப்பை (repo) 'star' செய்யுங்கள், அப்போதுதான் புதுப்பிப்புகள் உங்கள் ஃபிடில் (feed) தோன்றும். பின்னர் ஒரு முக்கியமான சிக்கலைக் (pain point) கண்டறியுங்கள். டோக்கன் செலவுகள் அதிகரிப்பது...