How do I start building a lightweight coding agent with Claude 4.5?

Define a tiny toolset (read, write, search, run), write a strict system prompt, and implement an Observe → Plan → Act → Reflect loop. Keep context small and feed real logs and diffs—Claude 4.5 performs best when the task is narrow and the feedback is concrete.

Do I need a vector database or memory layer for a Claude 4.5 coding agent?

No. For most tasks, short-term memory plus search_code is enough. Add long-term memory only if you repeatedly revisit the same repo and can prove it saves tokens without making the agent dumber.

What guardrails are essential for a Claude 4.5 coding agent?

Whitelist writable paths, cap diff sizes, restrict commands, and log every action. These simple limits keep the agent predictable and make rollbacks boring—in a good way.

Can a lightweight agent handle multi-file refactors?

Yes, if you split the work into small steps and keep the loop tight. Claude 4.5 can manage refactors, but you guide scope; otherwise you’ll get one giant, brittle diff you won’t want to review.

Where does [Sider.AI](https://sider.ai) fit with a Claude 4.5 coding agent?

[Sider.AI](https://sider.ai) is useful as a tidy workspace: conversations, diffs, and commands in one place, without forcing a heavyweight agent framework. Use it to run your loop, not to reinvent it.

கிளவுட் 4.5 உடன் எளிய கோடிங் ஏஜென்டை உருவாக்குங்கள் - அதிகப்படியான அம்சங்கள் இல்லாமல்

அறிமுகம்: அனைவரும் விரும்பும் ஏஜென்ட், ஆனால் ஆரவாரமின்றி

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

Claude 4.5ஐப் பயன்படுத்தி எடையற்ற குறியீட்டு ஏஜென்டை உருவாக்குவது—ஆச்சரியகரமாக—நேர்மையானது. எப்போது ஒரு உலகளாவிய மென்பொருள் பணியாளருக்கான கனவைப் பின்தொடர்வதை நிறுத்திவிட்டு, குறியீட்டைப் படித்து, திட்டமிட்டு, திருத்தி, இயக்கி, மீண்டும் செய்யும் ஒரு கருவியை உருவாக்குகிறீர்களோ அப்போது இது சாத்தியமாகும். இதில், “AI டெவலப்பர்களை மாற்றுகிறது” என்ற போதனை இல்லை. சிக்கலான Rube Goldberg பைப்லைன்கள் தேவையில்லை. வெளிப்படையான விஷயங்களைச் செய்யும் ஒரு இறுக்கமான லூப் மட்டுமே போதும்.

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

குறைந்தபட்ச ஏஜென்ட்களுக்கு Claude 4.5 ஏன் வேலை செய்கிறது

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

கவனித்தல்: தற்போதைய கோப்புகள், பிழைப் பதிவுகள் மற்றும் சோதனைகளைப் படிக்கவும்.

திட்டமிடல்: நியாயத்துடன் கூடிய குறிப்பிட்ட மாற்றங்களை முன்மொழியவும்.

செயல்படுதல்: கோப்புகளைப் பேட்ச் செய்யவும், கட்டளைகளை இயக்கவும்.

பிரதிபலித்தல்: வெளியீட்டை மதிப்பிடவும், மீண்டும் செய்யவும் அல்லது நிறுத்தவும்.

எந்த ரெப்போவிலும் இதை இணைத்து ஒரு மதியத்தில் பயனடையலாம். அதை ஒரு “AI தளமாக” மாற்றும் ஆசையை எதிர்ப்பதே இதிலுள்ள தந்திரம். ஏஜென்டை எடையற்றதாக வைத்திருந்தால், Claude 4.5 உங்களுக்கு இடையூறு இல்லாமல் கடினமான வேலையைச் செய்கிறது.

எடையற்ற கட்டமைப்பு: ஐந்து பாகங்கள், எந்த நாடகமும் இல்லை

உங்களுக்குத் தேவையான முழுமையான ஸ்டேக் இங்கே:

கோர் லூப்: Claude 4.5ஐ அழைத்து அதன் கருவி-பயன்பாட்டு செய்திகளை விளக்கும் ஒரு செயல்முறை.

கருவிகள்: ஒரு சிறிய தொகுப்பு—read_file, write_file, list_dir, run_tests (அல்லது run_cmd), search_code.

சூழல் பில்டர்: ரெப்போ மெட்டாடேட்டா மற்றும் சமீபத்திய வேறுபாடுகளுடன் ஒரு குறுகிய, கூர்மையான ப்ராம்ப்ட்டை அசெம்பிள் செய்யவும்.

குறுகிய கால நினைவகம்: ஒரு ரோலிங் உரையாடல் சாளரம் மற்றும் திட்டம் மற்றும் கட்டுப்பாடுகளுக்கான வெளிப்படையான ஸ்கிராட்ச்பேட்.

காட் ரெயில்கள்: டோக்கன், நேரம் மற்றும் கோப்பு எழுதும் வரம்புகள்; ட்ரை-ரன் முறை; மற்றும் ரோல் பேக் ஸ்னாப்ஷாட்கள்.

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

சதியை இழக்காமல் ஏஜென்டை எப்படி உருவாக்குவது

படி 1: ஒப்பந்தத்தை வரையறுக்கவும்—ப்ராம்ப்ட் மற்றும் கருவிகள்

உங்கள் ஏஜென்ட் மாடலுடனான அதன் ஒப்பந்தத்தைப் போலவே நன்றாக இருக்கும். சிஸ்டம் ப்ராம்ப்ட்டை சுருக்கமாகவும், கண்டிப்பானதாகவும், இடைவிடாத நடைமுறைத்தன்மையுடனும் வைத்திருங்கள்.

சுருக்கப்பட்ட சிஸ்டம் ப்ராம்ப்ட்:

நீங்கள் ஒரு குறியீட்டு ஏஜென்ட். ஒரு பயனர் பணியை நிறைவேற்ற ரெப்போவில் சிறிய, சரியான மாற்றங்களைச் செய்வதே உங்கள் வேலை.

மறைக்கப்பட்ட ஸ்கிராட்ச்பேடில் உரக்கச் சிந்தியுங்கள்; திட்டங்களையும் வேறுபாடுகளையும் மட்டும் பயனருக்கு வெளிப்படுத்துங்கள்.

குறைந்தபட்ச வேறுபாடுகள், வேலை செய்யும் சோதனைகள் மற்றும் படிப்படியான முன்னேற்றத்திற்கு முன்னுரிமை கொடுங்கள்.

சந்தேகம் இருந்தால், ஒரு பரிசோதனையை முன்மொழிந்து இயக்கவும்.

கோப்புகள் அல்லது கட்டளைகளை ஒருபோதும் புனைய வேண்டாம்—எடிட் செய்வதற்கு முன் பட்டியலிட்டுப் படிக்கவும்.

கருவி ஸ்கீமா (அதிகமாகச் சிந்திக்க வேண்டாம்):

list_dir(பாதை)

read_file(பாதை, ஆஃப்செட்?, நீளம்?)

write_file(பாதை, உள்ளடக்கம், create_if_missing=false)

run_cmd(கட்டளை, காலக்கெடு=60, cwd=repo_root)

search_code(வினவல், பாதை=repo_root, அதிகபட்ச_முடிவுகள்=50)

விருப்பத்தேர்வு நல்ல விஷயங்கள்: கைகள் இல்லாமல் ரோல் பேக் செய்ய வேண்டுமானால், git_diff மற்றும் git_revert(sha) பயன்படுத்தலாம். நீங்கள் ஒரு வெக்டர் ஸ்டோரைத் தவிர்க்கலாம்; பெரும்பாலான பயனுள்ள பணிகள் வேலை செய்யும் நினைவகத்தில் உள்ள ஒரு சில கோப்புகள் மற்றும் விரைவான தேடலைச் சார்ந்து இருக்கும்.

படி 2: சூழலை மெல்லியதாக வைத்திருங்கள்

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

ரெப்போ சுருக்கம்: ஒரு பத்தி README டைஜெஸ்ட்; நுழைவுப் புள்ளிகள்; சோதனை ரன்னர் கட்டளை.

செயலில் உள்ள கோப்புகள்: ஏஜென்ட் தொட திட்டமிட்டுள்ள கோப்புகள் மட்டும்—தேவைக்கேற்ப அவற்றைச் சிறிய பகுதிகளாகப் படிக்கவும்.

பணி: பயனர் இலக்கு, தெளிவாகக் கூறப்பட்டுள்ளது: “tests/foo_test.pyஇல் FooTest.test_bar சோதனையைச் சரிசெய்யவும்.”

கட்டுப்பாடுகள்: ரன்டைம் வரம்புகள், கோப்பு எழுதும் வெள்ளை பட்டியல், ஸ்டைல் விதிகள் மற்றும் பொருந்தினால் செமாண்டிக் பதிப்பு எதிர்பார்ப்புகள்.

சமீபத்திய வரலாறு: கடைசி இரண்டு வேறுபாடுகள் மற்றும் அவற்றின் சோதனை முடிவுகள். வேறு எதுவும் தேவையில்லை.

search_code மற்றும் read_file மூலம் தேவைப்படும்போது கூடுதல் சூழலைப் பெற Claude 4.5 முற்றிலும் திறமையானது. நிலப்பரப்பை அல்ல, வரைபடத்தைக் கொடுங்கள்.

படி 3: லூப் (கவனி → திட்டம் → செயல்படுத்து → பிரதிபலி)

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

திட்டம்: Claude ஒரு திட்டத்தை முன்மொழியுங்கள்:

தோல்விக்கான கருதுகோள்

ஆய்வு செய்ய அல்லது எடிட் செய்ய வேண்டிய கோப்புகள்

முயற்சிக்க வேண்டிய குறைந்தபட்ச வேறுபாடுகள்

சரிபார்க்க ஒரு சோதனை கட்டளை

செயல்படுத்து: write_file மூலம் முன்மொழியப்பட்ட வேறுபாட்டைப் பயன்படுத்தவும். வேறுபாட்டை அப்படியே காட்டுங்கள். சோதனைகளை இயக்கவும்.

பிரதிபலி: stdout/stderr மீண்டும் உள்ளிடவும். Claudeஐக் கேட்கவும்: தொடரவா, ரோல் பேக் செய்யவா அல்லது நிறுத்தவா? திட்டம் மாறினால், உண்மையான வெளியீட்டைக் குறிக்கும் ஒரு வாக்கிய நியாயப்படுத்தல் தேவை.

வெளியேறு: சோதனைகள் தேர்ச்சி பெற்றவுடன் நிறுத்தவும், அல்லது N மறு செய்கைகளுக்குப் பிறகு, எது முதலில் வருகிறதோ அது.

இது புகழ்பெற்ற ஜோடி நிரலாக்கம் ஆகும், இதில் நீங்கள் உண்மையில் ஜோடியை நேர்மையாக வைத்திருக்கிறீர்கள்.

படி 4: உங்கள் வார இறுதியைக் காப்பாற்றும் காட் ரெயில்கள்

எழுதுவதற்கான வெள்ளை பட்டியல்: src/, lib/ அல்லது வெளிப்படையாக அங்கீகரிக்கப்பட்ட பாதைகளுக்குள் மட்டும் எழுதுவதற்கு அனுமதி கொடுங்கள்.

வேறுபாட்டு அளவு வரம்பு: ஒரு படிக்கு 200-500 வரிகளுக்கு எடிட்களை வரையறுக்கவும். அதிகமாக இருந்தால், துணைப் படிகளாகப் பிரிக்கவும்.

கட்டளை அனுமதி பட்டியல்: சோதனை ரன்னர்கள், லின்டர்கள் மற்றும் சில டெவ் ஸ்கிரிப்ட்கள். நெட்வொர்க்கைத் தடை செய்யவும். உங்களுக்கு மறுஉருவாக்கம் தேவை, கட்டுப்பாடில்லாத curl அல்ல.

காலக்கெடு மற்றும் மறுமுயற்சிகள்: குறுகிய காலக்கெடு, ஒரு மறுமுயற்சி அதிகபட்சம்—முடிவில்லாத மறு இயக்க லூப்கள்தான் ஏஜென்ட்கள் இறக்கும் இடங்கள்.

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

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

படி 5: உண்மையில் பயனுள்ள நினைவகம்

குறுகிய கால நினைவகம் 80% சிக்கலைத் தீர்க்கிறது. வைத்திருக்க வேண்டியவை:

தற்போதைய கருதுகோள் மற்றும் திட்டத்திற்கான ஸ்கிராட்ச்பேட்.

இந்த செஷனில் தொடப்பட்ட கோப்புகளின் பட்டியல்.

கடைசி இரண்டு கட்டளை வெளியீடுகள்.

Claude 4.5ஐத் தெளிவாகக் காரணம் காட்ட இது போதுமானது. நீண்ட கால நினைவகம்—பணிப் பதிவுகள், உட்பொதிவுகள்—திரும்பத் திரும்ப வரும் கோட் பேஸ்களுக்கு உதவியாக இருக்கும், ஆனால் அதை விருப்பத்தேர்வு இனிப்பாகக் கருதுங்கள். உங்கள் ஏஜென்ட் 500MB வெக்டர் இன்டெக்ஸ் இல்லாமல் ஒரு சோதனையைச் சரிசெய்ய முடியாவிட்டால், அது ஒரு ஏஜென்ட் அல்ல—அது ஒரு சார்பு.

குறைந்தபட்ச அமலாக்க ஸ்கெட்ச்

போலி குறியீடு அடிப்படையில், நீங்கள் இந்த ஏஜென்டை ஒரு சில நூறு வரிகளில் செயல்படுத்தலாம்:

initialize: ரெப்போ மெட்டாடேட்டா, கட்டுப்பாடுகள் மற்றும் மாதிரி கிளையண்ட்டை ஏற்றவும்

loop(task):

observe: தோல்வியுற்ற சோதனைகள், கோப்புகள், பதிவுகளைப் படிக்கவும்

plan = model.propose_plan(context)

while not done and steps < MAX:

diff = model.propose_patch(plan)

show(diff); maybe approve

write_file(diff)

out = run_cmd(plan.test_cmd)

reflect = model.evaluate(out)

if reflect == pass: done = true

else if reflect == rollback: git_revert(last_commit)

else: plan = model.revise_plan(out)

விடுபட்ட பாகங்களை நீங்கள் கவனிப்பீர்கள்: ஏஜென்ட்களை நிர்வகிக்கும் ஏஜென்ட்கள் இல்லை, “பிரதிநிதிகள்” இல்லை, தனி “திட்டமிடுபவர் மாதிரி” மற்றும் “செயல்படுத்துபவர் மாதிரி” இல்லை. Claude 4.5 ஒரு Rube Goldberg சாதனத்தால் அதை நாசப்படுத்தாவிட்டால் இரண்டு வேலைகளையும் நன்றாகச் செய்ய முடியும்.

ப்ராம்ட்டிங் அதிகமாக முயற்சி செய்யாது

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

இலக்கு: சரியான குறியீட்டு பணி மற்றும் வெற்றி அளவுகோலைச் சொல்லவும்.

சூழல்: திட்ட அமைப்பு, நுழைவு புள்ளிகள் மற்றும் சோதனை கட்டளை.

கட்டுப்பாடுகள்: எழுதுவதற்கான வெள்ளை பட்டியல், வேறுபாட்டு அளவு வரம்பு, நெட்வொர்க் இல்லை.

ஸ்டைல் விருப்பத்தேர்வுகள்: மொழி பதிப்பு, ஃபார்மட்டர், லின்டர் விதிகள்.

செயல்முறை: கவனி → திட்டம் → செயல்படுத்து → பிரதிபலி; வேறுபாடுகளைக் காட்டு; சோதனைகளை இயக்கவும்; N படிகள் வரை மீண்டும் செய்யவும்; சோதனைகள் தேர்ச்சி பெற்றவுடன் நிறுத்தவும்.

இந்த அமைப்புடன், Claude 4.5க்கு 100-வரிசை ரோல்-பிளே ஸ்கேனரியோ தேவையில்லை. அது வேலை செய்கிறது.

நடைமுறை உதாரணம்: தோல்வியுற்ற சோதனையைச் சரிசெய்யவும்

tests/time_test.pyஇல் parse_time("09:00") 32400க்கு பதிலாக 5400ஐத் திருப்பித் தருவதால் ஒரு சோதனை தோல்வியடைகிறது என்று வைத்துக்கொள்வோம். ஏஜென்ட்டின் லூப் இப்படி இருக்க வேண்டும்:

கவனி: time.py மற்றும் time_test.pyஐப் படிக்கவும்; pytest -k parse_timeஐ இயக்கவும்.

திட்டம்: கருதுகோள்—வினாடிகள் vs நிமிடங்கள் கணித பிழை; parse_timeஐ எடிட் செய்ய முன்மொழியவும்; யூனிட் எட்ஜ் கேஸைச் சேர்க்கவும்.

செயல்படுத்து: parse_timeஐ பேட்ச் செய்யவும், முன்னணி-பூஜ்ஜிய மணிநேரங்களுக்கு ஒரு சோதனையைச் சேர்க்கவும்; சோதனைகளை இயக்கவும்.

பிரதிபலி: சோதனைகள் இன்னும் தோல்வியடைந்தால், பிழையைப் படித்து, கணிதம் அல்லது ரெஜெக்ஸை சரிசெய்து, மீண்டும் இயக்கவும்.

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

எங்கு எடையற்றது தேவையற்றதைத் தோற்கடிக்கிறது

லேடென்சி: ஒரு மாதிரி, ஒரு லூப், ஆர்கெஸ்ட்ரேஷன் மேல்நிலை இல்லை.

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

கட்டுப்பாடு: காட் ரெயில்கள் சேதத்தை உள்ளூரில் வைத்திருக்கின்றன. ஏஜென்ட் உங்கள் உள்கட்டமைப்பிற்குள் செல்ல முடியாது.

செலவு: குறைவான அழைப்புகள், குறைவான சூழல், கணிக்கக்கூடிய டோக்கன்கள்.

UX: நீங்கள் அதைப் புரிந்துகொள்கிறீர்கள். உங்கள் சக ஊழியர்கள் அதைப் புரிந்துகொள்கிறார்கள். உங்கள் எதிர்கால சுயத்திற்கு உங்களை வெறுக்காது.

மேலும் வர்த்தகங்கள்:

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

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

நிலைத்தன்மை: ஒரு பெரிய நினைவக அடுக்கு இல்லாமல், தொலைதூர வரலாற்றை வடிவமைப்பின் மூலம் மறந்துவிடும். அது ஒரு பிழையாக மாறும் வரை அது ஒரு அம்சம்.

குறியீட்டு ஏஜென்ட்களுக்கான Claude 4.5இன் இனிமையான இடம்

Claude 4.5 இதில் சிறந்து விளங்குகிறது:

வேறுபாடுகள் மற்றும் பதிவுகளைப் பற்றிப் படிப்பது மற்றும் காரணம் காட்டுவது.

ஒத்திசைவான, குறைந்தபட்ச குறியீடு மாற்றங்களை உருவாக்குதல்.

கட்டுப்பாடுகளைப் பின்பற்றுதல் மற்றும் நிச்சயமற்ற தன்மையைப் பற்றி வெளிப்படையாக இருப்பது.

இது இதில் சிறப்பாக இல்லை:

படிக்க முடியாத API நடத்தையை யூகிப்பது.

கனமான கருவி நடனம் (இங்கே தேவையில்லை).

ஒரு மனிதன் படிகளுக்கு வழிகாட்டாமல் நீண்ட பல கோப்பு மறுசீரமைப்புகள்.

கடைசி புள்ளி முக்கியமானது. வலுவான முடிவுகளைப் பெறுவதற்கான சிறந்த வழி ஏஜென்டைப் பெரிதாக்குவது அல்ல—பணியைச் சிறியதாக்குவதுதான். ஸ்கோப்பிங்கிற்கு உங்கள் மூளையைப் பயன்படுத்துங்கள், மேலும் அந்த ஸ்கோப்பிற்குள் செயல்படுத்துவதற்கு Claude 4.5ஐப் பயன்படுத்தவும்.

IDE ஒருங்கிணைப்பில் ஒரு வார்த்தை

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

லூப்பைத் தொடங்க/நிறுத்த கட்டளைகள்.

பிளவு காட்சியில் வேறுபாடுகளைக் காட்டு.

எழுதுவதற்கான ஒப்புதல் ப்ராம்ப்ட் (விருப்பமானது ஆனால் புத்திசாலித்தனமானது).

நீங்கள் பின்னர் ஒருங்கிணைக்கலாம். முதலில், அதை வேலை செய்ய வைக்கவும்.

Sider.AI, குறைவாகப் பயன்படுத்தினால், உண்மையில் உதவுகிறது

ஸ்காஃபோல்டிங்கை மீண்டும் கண்டுபிடிக்காமல் இந்த வகையான லூப்பை இயக்க ஒரு நடைமுறை சூழலை நீங்கள் விரும்பினால், Sider.AI உண்மையில் வேலை செய்கிறது—குறைந்தபட்சம் எதற்கு நன்றாக இருக்கிறதோ அதை நீங்கள் பயன்படுத்தும்போது. இது உரையாடல் மற்றும் வேறுபாடுகளை ஒழுங்காக வைத்திருக்கிறது, கட்டளைகளை இயக்க உங்களை அனுமதிக்கிறது, மேலும் சில பிரமாண்டமான “தன்னாட்சி ஏஜென்ட் கட்டமைப்பை” உங்களுக்குத் திணிக்காது. குறுகிய ப்ராம்ட்கள், இறுக்கமான லூப்கள், தெரியும் வேறுபாடுகள் போன்ற உங்கள் சொந்த விதிகளை வைத்திருப்பதே இதிலுள்ள தந்திரம். Sider வழியிலிருந்து விலகிச் செல்கிறது, இது இருக்க வேண்டியதை விட அரிதானது.

பொதுவான ஆபத்துகள் (மற்றும் முட்டாள்தனமாக இருப்பதைத் தவிர்ப்பது எப்படி)

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

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

புனையப்பட்ட கோப்புகள்: புதிய பாதையில் ஏதேனும் write_file செய்வதற்கு முன் list_dir மற்றும் read_file தேவை.

முடிவில்லாத மறு இயக்க லூப்கள்: படிகளை வரையறுக்கவும். ஒவ்வொரு புதிய கருதுகோளுக்கும் நியாயப்படுத்தலைக் கோரவும்.

ஒரு பெரிய வேறுபாடு: மாற்றங்களைப் பிரிக்கவும். சிறிய வேறுபாடுகள் வேகமாகத் தோல்வியடைகின்றன, மேலும் காரணம் காட்டுவது எளிதானது.

பாதுகாப்பின்றி பாதுகாப்பு மற்றும் பாதுகாப்பு

உள்ளூர் செயல்பாடு: ஒரு சாண்ட்பாக்ஸ் செய்யப்பட்ட டைரக்டரியில் இயக்கவும். இயல்பாக நெட்வொர்க் இல்லை.

சார்பு தனிமைப்படுத்தல்: உள்ளூர் வென்வ் அல்லது கொள்கலனைப் பயன்படுத்தவும். பதிப்புகளைப் பின் செய்யவும்.

ரகசியங்கள்: ஏஜென்ட்டுக்கு அவை தேவையில்லை. ஒரு கட்டளைக்கு டோக்கன் தேவைப்பட்டால், நிறுத்திவிட்டு கேட்கவும்.

தணிக்கை: ஒவ்வொரு திட்டம், வேறுபாடு மற்றும் கட்டளையையும் ஒரு பதிவில் தொடர்ந்து வைக்கவும்.

இது வேலை செய்கிறது என்பதை எப்படி அறிவது

முன்னணி நேரம் குறைகிறது: ஒரு மணி நேரம் எடுத்த பிழை திருத்தங்கள் இப்போது பத்து நிமிடங்கள் ஆகும்.

குறைவான கை தவறு தவறுகள்: வேறுபாடுகள் சிறியதாகின்றன, சோதனைகள் அதிகப் பசுமையாகின்றன.

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

சக ஊழியர்கள் அதைப் பயன்படுத்துகிறார்கள்: ஒரு கூட்டமில்லாமல் மற்றவர்கள் அதை ஏற்றுக்கொள்வதுதான் வெற்றியின் வரையறை.

கவனமாக அளவிடுதல்

நீங்கள் உண்மையில் அளவிட வேண்டும் என்றால், ஒழுக்கத்துடன் செய்யுங்கள்:

சமாந்திர மூளைகள் அல்ல, சமாந்திர துணைப்பணிகள்: வேலையைப் பிரிக்கவும், தனி டைரக்டரிகளில் பல எடையற்ற லூப்களை இயக்கவும், பசுமையாக இருக்கும்போது இணைக்கவும்.

நினைவுக் குறிப்பு, மூளை கொட்டுதல் அல்ல: வெற்றிகரமான பேட்ச்கள் மற்றும் அறிகுறிகள்-சரிசெய்யும் மேப்பிங்குகளைச் சேமிக்கவும். அறுவை சிகிச்சை முறையில் மீட்டெடுக்கவும்.

சீரான “பெரிய” பாஸ்கள்: மறுசீரமைப்புகளுக்கு மனிதனால் வழிநடத்தப்படும் செஷனை ஒதுக்குங்கள்; ஏஜென்ட் உதவுகிறது, வழிநடத்துவதில்லை.

குறைந்தபட்ச குறிப்பு அமலாக்கம் (வரைபடம்)

நகரத் தொடங்குவதற்கான பைதான் போன்ற போலி குறியீடு:

class LightweightAgent:

def init(self, repo_root, model):

self.root = repo_root

self.model = model

self.history = [] # கடைசி இரண்டு வேறுபாடுகள் மற்றும் சோதனை வெளியீடுகள்

def context(self, task):

return {

"task": task,

"repo": summarize_repo(self.root),

"constraints": {"write_whitelist": ["src/", "tests/"], "max_diff_lines": 300, "no_network": True},

"history": self.history[-2:],

}

def step(self, task):

plan = self.model("propose_plan", self.context(task))

diff = self.model("propose_patch", {"plan": plan})

approve(diff)

apply_diff(diff)

out = run_cmd(plan.test_cmd)

eval = self.model("evaluate", {"output": out, "plan": plan})

self.history.append({"diff": diff, "out": tail(out)})

return eval

மனித அளவிலான முடிவு

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

முடிவு: வெற்றி பெறும் சலிப்பான குறுக்குவழி

Claude 4.5 உடன் எடையற்ற குறியீட்டு ஏஜென்ட்க்கான உங்கள் சரிபார்ப்புப் பட்டியல் இங்கே:

ஒரு லூப், ஒரு மாதிரி, சிறிய கருவிகள்.

இறுக்கமான சூழல்: பணி, ஒரு சில கோப்புகள், கடைசி வெளியீடுகள்.

குறைந்தபட்ச வேறுபாடுகள், அடிக்கடி சோதனைகள், கடின வரம்புகள்.

உள்ளூர், சாண்ட்பாக்ஸ் செய்யப்பட்ட செயல்பாடு; நெட்வொர்க் இல்லை.

விருப்பத்தேர்வு எடிட்டர் இனிப்பு; ஒருபோதும் தேவையில்லை.

நீங்கள் கூர்ந்து பார்த்தால், இது நல்ல மென்பொருள் பொறியியல் போல் சந்தேகத்திற்கு இடமின்றித் தெரிகிறது, இன்னும் வேகமாக. அதுதான் பஞ்ச் லைன். இங்கே நீங்கள் செய்யக்கூடிய புத்திசாலித்தனமான விஷயம் “தன்னாட்சியை”த் துரத்துவது அல்ல—ஒழுக்கத்தை குறியீடாக்குவதுதான். ஏஜென்டிடம் நீங்கள் குறைவாகக் கேட்டால், அதிகமாகப் பெறுவீர்கள்.

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

Q1: Claude 4.5 உடன் எடையற்ற குறியீட்டு ஏஜென்டை உருவாக்குவதை நான் எப்படித் தொடங்குவது? ஒரு சிறிய கருவித்தொகுப்பை வரையறுக்கவும் (படித்தல், எழுதுதல், தேடுதல், இயக்குதல்), கடுமையான சிஸ்டம் ப்ராம்ப்ட்டை எழுதவும், மேலும் கவனி → திட்டம் → செயல்படுத்து → பிரதிபலி லூப்பை செயல்படுத்தவும். சூழலைச் சிறியதாக வைத்து, உண்மையான பதிவுகள் மற்றும் வேறுபாடுகளை ஊட்டவும்—Claude 4.5 பணி குறுகியதாகவும், பின்னூட்டம் உறுதியானதாகவும் இருக்கும்போது சிறப்பாகச் செயல்படுகிறது.

Q2: Claude 4.5 குறியீட்டு ஏஜென்டுக்கு வெக்டர் டேட்டாபேஸ் அல்லது மெமரி லேயர் தேவையா? இல்லை. பெரும்பாலான பணிகளுக்கு, குறுகிய கால நினைவகம் மற்றும் search_code போதுமானது. ஒரே ரெப்போவை நீங்கள் மீண்டும் மீண்டும் பார்வையிட்டு, ஏஜென்டை முட்டாளாக்காமல் டோக்கன்களைச் சேமிக்கிறது என்பதை நிரூபிக்க முடிந்தால் மட்டும் நீண்ட கால நினைவகத்தைச் சேர்க்கவும்.

Q3: Claude 4.5 குறியீட்டு ஏஜென்டுக்கு என்ன காட் ரெயில்கள் அவசியம்? எழுதக்கூடிய பாதைகளை வெள்ளைப்பட்டியலிடுங்கள், வேறுபாட்டு அளவுகளை வரையறுக்கவும், கட்டளைகளைக் கட்டுப்படுத்தவும், ஒவ்வொரு செயலையும் பதிவு செய்யவும். இந்த எளிய வரம்புகள் ஏஜென்டை கணிக்கக்கூடியதாக வைத்திருக்கின்றன, மேலும் ரோல் பேக்குகளை சலிப்பானதாக ஆக்குகின்றன—ஒரு நல்ல வழியில்.

Q4: எடையற்ற ஏஜென்ட்டால் பல கோப்பு மறுசீரமைப்புகளைக் கையாள முடியுமா? முடியும், வேலையைச் சிறிய படிகளாகப் பிரித்து லூப்பை இறுக்கமாக வைத்திருந்தால். Claude 4.5 மறுசீரமைப்புகளை நிர்வகிக்க முடியும், ஆனால் நீங்கள் ஸ்கோப்பை வழிநடத்துகிறீர்கள்; இல்லையெனில் நீங்கள் மதிப்பாய்வு செய்ய விரும்பாத ஒரு பெரிய, உடையக்கூடிய வேறுபாட்டைப் பெறுவீர்கள்.

Q5: Claude 4.5 குறியீட்டு ஏஜென்ட்டுடன் Sider.AI எங்கே பொருந்துகிறது? Sider.AI ஒரு ஒழுங்கான பணியிடமாக பயனுள்ளதாக இருக்கிறது: உரையாடல்கள், வேறுபாடுகள் மற்றும் கட்டளைகள் ஒரே இடத்தில், கனமான ஏஜென்ட் கட்டமைப்பைத் திணிக்காமல். உங்கள் லூப்பை இயக்க அதைப் பயன்படுத்தவும், அதை மீண்டும் கண்டுபிடிக்க வேண்டாம்.