પરિચય: એજન્ટ જે સૌ કોઈ ઈચ્છે છે, પણ વધારે હાયપ વગર
કોડિંગ એજન્ટ વિશેની વાત એ છે કે મોટા ભાગના એજન્ટ તમારા બોસ, કૉ-પાઈલટ અને થેરાપિસ્ટ બનવાનો પ્રયાસ કરે છે—અને પછી કોડ લખવાનું ભુલાઇ જાય છે. તેમનું પ્લેબુક આ રીતે હોય છે: ડઝન vector stores ઉમેરો, orchestration પીક્સી ડસ્ટ ચપકાવો, બ્રાઉઝર બાંધી દો, અને દિવસ પૂરો. તે દેખાવવામાં સારું લાગે છે, પણ જયારે તમે શુક્રવારે બપોરે 4:52 વાગ્યે flaky integration ટેસ્ટ ઠીક કરવા કહો છો ત્યારે તે તૂટી જાય છે.
Claude 4.5 સાથે લાઇટવેઇટ કોડિંગ એજન્ટ બનાવવું—આશ્ચર્યજનક રીતે—સિયામાં સરળ છે જો તમે એક સર્વવ્યાપી સોફ્ટવેર બટલર બનાવવાની સપના પૂરી પાડવાનું બંધ કરો અને માત્ર એવું ટૂલ બનાવો કે જે કોડ વાંચે, યોજના બનાવે, એડિટ કરે, ચલાવે અને પુનરાવૃત્તિ કરે. ‘AI ડેવલોપર્સને બદલે’નાં ભાષણ વગર. કોઈ ર્યુબ ગોલ્ડબર્ગ પાઇપલાઇન્સ નહીં. ફક્ત સાદા અને અસરકારક લૂપ.
આ એક માર્ગદર્શિકા છે જે તમને પૂરુ પાડે છે કે સંપૂર્ણ AI ઓપરેશન્સ વિભાગને ખેંચ્યા વગર કેવી રીતે પહોંચવું. અમે Claude 4.5 ને મગજ તરીકે ઉપયોગ કરીશું, ફાઇલસિસ્ટમ અને શેલને હથિયાર તરીકે, અને એક નાનું મેમરી શૉર્ટ-ટર્મ ધ્યાન માટે. બસ એટલું. લાઇટવેઇટ એટલે કે તમે તેને એક બેઠકમાં સમજાવી શકો, સ્થાનિક રીતે ચલાવી શકો અને વિશ્વાસ સાથે ઉપયોગ કરી શકો જ્યાં દરેક પગલાં નિરીક્ષણ કરી શકાય છે. જો તમે તાજેતરમાં આ ક્ષેત્રમાં કશુંક ઉપયોગ કર્યો હોય, તો આ લગભગ વિપરિત છે.
શા માટે Claude 4.5 લઘુતમ એજન્ટ માટે સારો છે
Claude 4.5 એ એવા સ્વભાવ ધરાવે છે જે કોડ માટે યોગ્ય છે: સૂચનનુંરીતે ધ્યાન રાખનારો, ડિફ્સ વાંચવામાં બહુ સારું, અને તે ફ્રેમવર્ક કલ્પનામાં વધુ ઉત્સાહી નથી જેને તમે માંગ્યા નથી. આ મોડેલ સ્ટેપવાઇઝ તર્કમાં કુશળ છે, બિનજરૂરી લાંબો પ્રોમ્પ્ટ માંગ્યા વગર. આ સંયોજન—તર્ક અને restraint—તેને કોડિંગ એજન્ટ લૂપ માટે આદર્શ બનાવે છે:
- અહેવાલ લો: વર્તમાન ફાઇલો, error logs અને ટેસ્ટ વાંચો.
- યોજનાબદ્ધ કરો: કારણ સાથે ચોક્કસ ફેરફારો પ્રસ્તુત કરો.
- કામ કરો: ફાઈલ પૅચ કરો, કમાન્ડ ચલાવો.
- વિચાર કરો: આઉટપુટનું મૂલ્યાંકન કરો, પુનરાવૃત્તિ અથવા રોકાણ કરો.
તમે આને કોઈપણ રેપોઝિટરી પર લગાવી અને બપોર સુધી કિંમત મેળવી શકો. મુદ્દો એ છે કે “AI પ્લેટફોર્મ” બનાવવા માટેની લાલસા સામે પ્રતિરોધ કરો. જ્યારે તમે એજન્ટને લાઇટવેઇટ રાખશો ત્યારે Claude 4.5 ભારી કામ કરે છે અને તમારા રસ્તામાં નથી.
લાઇટવેઇટ આર્કિટેક્ચર: પાંચ તત્વો, કોઈ ડ્રામા નહીં
આ તમારી જરૂરિયાત સંપૂર્ણ સ્ટેક છે:
- કોર લૂપ: એક પ્રોસેસ જે Claude 4.5 ને કોલ કરે અને તેના ટૂલ-ઉપયોગ સંદેશાઓની વ્યાખ્યા કરે.
- ટૂલ્સ: નાની સેટ—read_file, write_file, list_dir, run_tests (અથવા run_cmd), search_code.
- સંદર્ભ બિલ્ડર: રેપોઝિટરી મેટાડેટા અને તાજેતરના ડિફ્સ સાથે ટૂંકું અને નુક્સાનકારક પ્રોમ્પ્ટ બનાવો.
- શોર્ટ-ટર્મ મેમોરી: ચલતી વાતચીત વિંડો અને યોજના અને મર્યાદાઓ માટે જાણકારી સ્ક્રેચપેડ.
- ગ્રાડરેલ્સ: ટોકન, સમય અને ફાઇલ લખાણ મર્યાદાઓ; ડ્રાય-રન મોડ; અને રોલબેક સ્નેપશોટ્સ.
એટલુજ છે. તમે તેને ટર્મિનલમાં હેડલેસ ચલાવી શકો, અથવા જરૂરી હોય તો સદૈવ ન્યૂનતમ UI થી ઘેરી શકો. આ સિસ્ટમ વ્યાપક કેમ કાર્યકારી છે તે બોરિંગ છે: દરેક ક્રિયા જોવાય છે અને ચકાસવામાં આવે છે. એજન્ટ ફેરફાર સૂચવે છે, ડિફ બતાવે છે, ટેસ્ટ ચલાવે છે, આઉટપુટ વાંચે છે અને ચાલુ રહે કે બંધ થાય તે નક્કી કરે છે. કોઈ રહસ્ય કે ગૂઢતાની જગ્યાએ નથી.
એજન્ટ કેવી રીતે બનાવવો (માટે ઉતરવું નહીં)
પગલું 1: કરાર નિર્ધારિત કરો—પ્રોમ્પ્ટ અને ટૂલ્સ
તમારો એજન્ટ એટલો જ સારો છે જેટલો એ મોડેલ સાથે કરાર છે. સિસ્ટમ પ્રોમ્પ્ટને ટૂંકા, કડક અને સતત વ્યવહારુ રાખો.
સિસ્ટમ પ્રોમ્પ્ટ, સંક્ષિપ્ત:
- તમે એક કોડિંગ એજન્ટ છો. તમારું કામ યુઝર ટાસ્કને પૂર્ણ કરવા માટે રેપોઝિટરીમાં નાના અને સાચા ફેરફારો કરવાનો છે.
- ગુપ્ત સ્ક્રેચપેડમાં ચિંતન કરો; ફક્ત યોજનાઓ અને ડિફ્સ યુઝરને બતાવો.
- ન્યૂનતમ ડિફ્સ, કામકાજ પરીક્ષણો, અને ક્રમશઃપ્રગતિને વરાળો.
- અનિશ્ચિતતા હોય ત્યારે અનુમાન કરો અને તે અમલમાં લાવો.
- ક્યારેય ફેબ્રિકેટેડ ફાઇલો અથવા કમાન્ડ ન બનાવો—એડિટ કરવા પહેલાં લિસ્ટ અને રીડ કરો.
ટૂલ સ્કીમા (જટિલ ન બનાવો):
- read_file(path, offset?, length?)
- write_file(path, content, create_if_missing=false)
- run_cmd(command, timeout=60, cwd=repo_root)
- search_code(query, path=repo_root, max_results=50)
વૈકલ્પિક સુવિધાઓ: git_diff અને git_revert(sha) હેન્ડ્સ-ફ્રી ર rollback માટે. તમે vector store દૂર કરી શકો, કારણ કે મોટા કામો સામાન્ય રીતે વર્કિંગ મેમોરીમાં થોડી ફાઇલો સાથે અને ઝડપી શોધ સાથે નિભરાયેલા હોય છે.
પગલું 2: સંદર્ભ સરળ રાખો
સંદર્ભ ભરવાની રીત એ એજન્ટ ડિઝાઇનનો cargo cult છે. તમારું સમગ્ર મોનોરેપો પ્રોમ્પ્ટમાં ન નાખો. તેના બદલે:
- રેપો સંક્ષેપ: એક પેરાગ્રાફ સાથે README ડાઈજેસ્ટ; એન્ટ્રી પોઇન્ટ્સ; ટેસ્ટ રનર કમાન્ડ.
- સક્રિય ફાઇલો: ફક્ત તે ફાઇલો જેને એજન્ટ સ્પર્શવા વિશે વિચારે—આવશ્યકતા મુજબ છટાં છટાં વાંચો.
- ટાસ્ક: યુઝરના લક્ષ્યને સ્પષ્ટ શબ્દોમાં રજૂ કરો: “Fix failing test FooTest.test_bar in tests/foo_test.py.”
- પરીબંધો: રનટાઇમ મર્યાદાઓ, ફાઇલ લખાણ વ્હાઇટલિસ્ટ, સ્ટાઇલ નિયમો, અને semver અપેક્ષાઓ જો લાગુ પડે.
- હમાણી હિસ્ટ્રી: છેલ્લાં બે ડિફ્સ અને તેમના ટેસ્ટ પરિણામો. બીજું કંઇ નહી.
Claude 4.5 શક્તિશાળી છે વધુ સંદર્ભ મેળવવા માટે search_code અને read_file દ્વારા. તેને નકશો આપો, વિસ્તાર નહીં.
પગલું 3: લૂપ (અહેવાલ → યોજના → કાર્ય → વિચાર)
- અહેવાલ: ડિરેક્ટરી લિસ્ટ કરો, ફેલ થયેલ ટેસ્ટ, કોડ અને error લોગ વાંચો. Claude ને વિનંતી કરો કે 2-3 મુદ્દાઓમાં નિષ્ફળતા લક્ષણોનું સારાંશ આપે.
- યોજનાબદ્ધ કરો: Claude થી આ માટે યોજના માંગો:
- તપાસવા અથવા એડિટ કરવા માટે ફાઇલો
- પ્રયત્ન માટે ન્યૂનતમ ડિફ્સ
- માન્યતા માટે એક ટેસ્ટ કમાન્ડ
- કામ કરો: write_file મારફતે સૂચવેલ ડિફ લાગુ કરો. ડિફ યોગ્ય રીતે બતાવો. ટેસ્ટ ચલાવો.
- વિચાર કરો: stdout/stderr પાછો આપો. Claude ને પૂછો: આગળ વધવું, રોલબેક કરવો કે રોકવું? જો યોજના બદલાય, તો એક વાર્તાવાર ઝલક આપવી કે જે હાલના આઉટપુટને સંદર્ભ બનાવે.
- બહાર નીકળો: જ્યારે ટેસ્ટો પાસ થાય, અથવા N વખતની પુનરાવૃત્તિ પછી, જે પહેલાં આવે.
આ એત્યવવહેનનો જોડાણ પ્રોગ્રામિંગ છે જ્યાં તમે સાથીદારી સાચી રાખો છો.
પગલું 4: સ્વામી માટે રક્ષા સ્થિતિઓ (Guardrails)
- લેખન માટે વ્હાઇટલિસ્ટ: ફક્ત src/, lib/ અથવા સ્પષ્ટ મંજૂર માર્ગો પર લખાણવાનુ મંજૂરી.
- ડિફ કદ મર્યાદા: દરેક પગલામાં 200–500 લાઈનો સુધી ફેરફાર. વધારે હોય તો ઉપપગલાંમાં વિભાજિત કરો.
- કમાન્ડ મંજૂરી યાદી: ટેસ્ટ રનર, લિન્ટર અને થોડી ડેવ સ્ક્રિપ્ટ્સ. નેટવર્ક પર પ્રતિબંધ. તમે પુનરુત્પાદ્યતા માંગો છો, વાઈલ્ડ વેસ્ટ ક્યૂરલ નહીં.
- ટાઇમઆઉટ અને પુનરાવૃત્તિ: ટૂંકા ટાઇમઆઉટ, એક પુનરાવૃત્તિ મહત્તમ—અનંત પુનરાવૃત્તિ લૂપ એજન્ટ માટે ઘાતક છે.
- ડ્રાય રન મોડ: સૂચવાયેલ ડિફ પ્રિન્ટ કરો પણ ન લખો. કોડ સમીક્ષા માટે ઉત્તમ.
Claude 4.5 નિયમોનું પાલન કરશે જો તમે તેને સ્પષ્ટ બનાવશો. નહીં તો આશ્ચર્ય ચિહ્ન ના રાખો જ્યારે તે તમારા રેપોને 2017 ના બ્લોગ પોસ્ટ અનુસાર ફરી સંકલિત કરવાનો પ્રયાસ કરે.
પગલું 5: ઉપયોગી મેમોરી
શોર્ટ-ટર્મ મેમોરી 80% સમસ્યા હલ કરે છે. રાખો:
- ચાલુ અનુમાન અને યોજનાનું સ્ક્રેચપેડ.
- આ સત્રમાં સ્પર્શેલ ફાઇલોની યાદી.
તે Claude 4.5 માટે સપાટી પર સત્યાપિત સાધન છે. લાંબુ ગોઠવણ સ્મૃતિ—ટાસ્ક લોગો, એમ્બેડિંગ્સ—ફરી આવતી રેપોઝીટરી માટે મદદરૂપ થાય છે, પણ તે વૈકલ્પિક છે. જો તમારું એજન્ટ 500MB વેક્ટર સૂચિકાથી વિના ટેસ્ટ ઠીક ન કરી શકે, તો એ એજન્ટ નથી—એ આદરક છે.
ન્યૂનતમ અમલનો ખાકો
સુધીકોડ રૂપમાં, તમારું એજન્ટ બે-સો લીનોમાં અમલમાં કરી શકો છો:
- ઇનિશિયલાઈઝ કરો: રેપો મેટાડેટા, મર્યાદાઓ અને મોડેલ ક્લાયન્ટ લોડ કરો
- અહેવાલ લો: નિષ્ફળ થયેલ ટેસ્ટ, ફાઇલો, લોગ વાંચો
- યોજના = મોડેલ.propose_plan(સંદર્ભ)
- જ્યારે ન થઈ હોય અને પગલાં MAX હેઠળ હોય:
- ડિફ = મોડેલ.propose_patch(યોજનાબદ્ધ)
- ડિફ બતાવો; શક્યતા અનુસાર મંજૂર કરો
- આઉટ = run_cmd(યોજનાબદ્ધ.test_cmd)
- વિચાર = મોડેલ.evaluate(આઉટ)
- જો વિચાર == પાસ હો તો: થયા = સાચું
- અથવા જો વિચાર == રોલબેક હોઈ તો: git_revert(છેલ્લા_commit)
- અન્યથા: યોજના = મોડેલ.revise_plan(આઉટ)
તમે ગેરહાજર ભાગો જોશો: એજન્ટ મેનેજ કરનારા એજન્ટ્સ નહીં, ‘Delegate’ નહીં, અલગ ‘યોજનાબદ્ધ મોડેલ’ અને ‘કાર્યાન્વય મોડેલ’ નહીં. Claude 4.5 બંને કામ સારું કરે છે જો તમે તેને ર્યુબ ગોલ્ડબર્ગ ઉપકરણ સાથે નુકસાન ન પહોંચાડો.
પ્રોમ્પ્ટ જે વધુ ખંઘાળતા નથી
ખરાબ પ્રોમ્પ્ટ ચતુર બનવાની કોશિશ કરે છે. સારા પ્રોમ્પ્ટ બોરિંગ અને વિશિષ્ટ હોય છે. હે તમારી મર્યાદિત સૂચનાઓનો સ્વચ્છ ઢાંચો:
- લક્ષ્ય: ચોક્કસ કોડિંગ ટાસ્ક અને સફળતા માપદંડ જણાવો.
- સંદર્ભ: પ્રોજેક્ટ રચના, એન્ટ્રી પોઈન્ટ અને ટેસ્ટ કમાન્ડ.
- મર્યાદાઓ: લેખન વ્હાઇટલિસ્ટ, ડિફ કદ મર્યાદા, નેટવર્ક નહી.
- શૈલી પસંદગીઓ: ભાષા સંસ્કરણ, ફોર્મેટર, લિન્ટર નિયમો.
- પ્રક્રિયા: અહેવાલ → યોજના → કાર્ય → વિચાર; ડિફ્સ બતાવો; ટેસ્ટ ચલાવો; N સુધી પુનરાવર્તન કરો; જ્યારે ટેસ્ટ પાસ થાય ત્યારે રોકો.
આ પદ્ધતિ સાથે Claude 4.5 ને 100 લાઇન રોલ પ્લે પરિસ્થિતિની જરૂર નથી. તે ફક્ત કાર્ય કરે છે.
પ્રાયોગિક ઉદાહરણ: નિષ્ફળ થયેલ ટેસ્ટ ઠીક કરો
ધારી લો કે tests/time_test.py માં એક ટેસ્ટ નિષ્ફળ થઈ રહી છે કારણ કે parse_time("09:00") 5400 બદલે 32400 આપે છે. એજન્ટ લૂપ આવું દેખાશે:
- અહેવાલ: time.py અને time_test.py વાંચો; pytest -k parse_time ચલાવો.
- યોજના: અનુમાન—સેકંડ અને મિનિટની ગણતિની ભૂલ; parse_time એડિટ કરો; યૂનિક્સ દ્વારના કેઝ ઉમેરો.
- કામ કરો: parse_time પેચ કરો, આઘાત દિવસોની પરિક્ષા ઉમેરો; ટેસ્ટ ચલાવો.
- વિચાર કરો: જો ટેસ્ટો હજુ ભૂલ આપે, તો error વાંચો, ગણિત અથવા રેગ્યુલર એક્સપ્રેશન સુધારો, ફરી ચલાવો.
ન્યૂનતમ સફળ પેચ બે લાઈનોનો ફેરફાર હોઈ શકે છે. એ જ છે બિંદુ. નાના ફેરફારો, ઝડપી ચક્રો, સાચી પ્રગતિ.
જ્યાં લાઇટવેઇટ કિચન સિંન્ક કરતા આગળ છે
- વિલંબ: એક મોડેલ, એક લૂપ, કોઈ ઓર્કેસ્ટ્રેશન બ્રધવાળો નહીં.
- પારદર્શિતા: દરેક પગલાં તપાસી શકાય તેવું છે. તમે તેને ડિફ કરી શકો, રિવર્ટ કરી શકો કે ફરી ચલાવી શકો.
- નિયંત્રણ: ગ્રાડરેલ્સ નુકસાનને સ્થાનિક રાખે છે. એજન્ટ તમારું ઈન્ફ્રાસ્ટ્રક્ચર છોડીને અકસ્માત નહી કરે.
- ખર્ચ: ઓછા કોલ્સ, ઓછા સંદર્ભો, આગળથી જાણી શકાય તેવા ટોકન.
- યૂઝર અનુભવ: તમે તેને સમજો છો. તમારી ટીમ સમજે છે. તમારું ભવિષ્ય પોતાને આદત બગાડતું ન કોશિષ કરશે.
અને સત્વરાઓ:
- વિસ્તૃતતા: લાઇટવેઇટ એજન્ટ પાંજ ભાષાનો મોનોરેપો એક જ વખતમાં રિફેક્ટર નથી કરી શકતો; અને તે પણ ન કરવો જોઈએ.
- પહલું: તે બહુ-સપ્તાહીય રોડમેપ ન બનાવે. તમે તેને ટાસ્ક આપો.
- સ્થિતિ: મોટા મેમોરી સ્તર વગર તે દૂરની ઇતિહાસ ભૂલી જાય છે. આ સુવિશેષતા છે જયારે તે બગ નથી.
Claude 4.5 માટે કોડિંગ એજન્ટનો યોગ્ય અંચલ
Claude 4.5 શુભ છે:
- ડિફ અને લોગ્સ વાંચવાનું અને સમજવાનું.
- સંયોજિત અને ન્યૂનતમ કોડ ફેરફારો તૈયાર કરવાનું.
- મર્યાદાઓ અનુસાર ચાલવાનું અને અનિશ્ચિતતાને સ્પષ્ટ રીતે બતાવવાનું.
તે ઓછું સારું છે:
- તે જે વાંચી શકતું નથી તે API વર્તન અનુમાનવવાનું.
- ભારે ટૂલ સંકલન (અહીં જરૂરી નથી).
- લાંબા બહુ-ફાઇલ રિફેક્ટર વગર માનવી માર્ગદર્શન.
આ છેલ્લું મહત્વપૂર્ણ છે. શ્રેષ્ઠ પરિણામ મેળવવાનો માર્ગ એજન્ટ મોટો કરવાનો નથી—પરંતુ ટાસ્ક નાનો કરવાનો છે. સ્કોપિંગ માટે તમારું મગજ અને અમલ માટે Claude 4.5 નો ઉપયોગ કરો.
IDE સંકલન પર એક શબ્દ
આને ન વાંધો IDE પેનમાં સોઢા વિકલ્પો સાથે સીધી રીતે બનાવવાનો. ટેર્મિનલ આધારિત લૂપ સાદા ટેક્સ્ટ ડિફ્સ સાથે વધારે વિશ્વસનીય અને ડીબગ કરવા માંડું છે. જો એડિટર સુગર જોઈએ તો તે મૂર્ખ બનાવો:
- ડિફ્સ સ્પ્લિટ વિલૂન માં બતાવો.
- લેખન માટે મંજૂરી પ્રોમ્પ્ટ (વૈકલ્પિક પણ સમજદારી).
તમે પછી સંકલિત કરી શકો. પહેલા તે કાર્યરત બનાવો.
Sider.AI, સંયમપૂર્વક ઉપયોગ કરવાથી મદદરૂપ થાય છે જો તમે આ પ્રકારની લૂપ ચલાવવાનું સારું વાતાવરણ શોધતા હો તો Sider.AI વ્યવહારુ છે—જ્યારે તમે તેને તેની સારી ક્ષમતાઓ માટે ઉપયોગ કરો. તે વાતચીત અને ડિફ્સ સગવડરૂપે રાખે છે, તમને કમાન્ડ ચલાવતા દે છે, અને તમને મોટો “સ્વચાલિત એજન્ટ ફ્રેમવર્ક” મજબૂર કરતો નથી. મુખ્ય વાત શું રીતે આપના નિયમો જાળવવા: ટૂંકા પ્રોમ્પ્ટ, તણાવેલી લૂપ્સ, દેખાવા શકાય તેવા ડિફ્સ. Sider રસ્તામાંથી દૂર રહે છે, જે ઓછું જ શક્ય છે. સામાન્ય પડકારો (અને ખોટો જણાય તેવો કેવી રીતે ટાળો)
- ઓવરસ્ટફ્ડ સંદર્ભ: જો તમારું પ્રોમ્પ્ટ રેન્સમ નોટ જેવું લાગે છે તો તે ખોટું કરી રહ્યા છો. જરૂર મુજબ ફાઇલો મેળવો.
- અકસ્મિક રિફેક્ટરિંગ: એજન્ટ મોડ્યુલોનું પુનઃઆયોજિત સૂચવે? પહેલા ટેસ્ટ પસાર કરાવો, પછી રિફેક્ટર કરો.
- કલ્પિત ફાઇલો: નવું માર્ગ લખવાનાં પહેલા list_dir અને read_file જરૂરી છે.
- અનંત રન લૂપ: પગલાં મર્યાદિત કરો. દરેક નવો અનુમાન માટે કારણ માંગો.
- એક જ મોટું ડિફ: બદલાવો વિભાજિત કરો. નાની ડિફઝ ઝડપથી નિષ્ફળ થાય છે અને સમજવામાં સરળ છે.
સુરક્ષા અને સલામતી વિના સંશય
- સ્થાનિક અમલ: એક સૅન્ડબોક્સ ડિરેક્ટરીમાં ચાલાવો. મૂળભૂત રીતે નેટવર્ક બંધ.
- આધારભૂત અલગાવ: લોકલ venv અથવા કન્ટેનર ઉપયોગ કરો. વર્ઝન પિન કરો.
- સિક્રેટ્સ: એજન્ટને જરૂર નથી. જો કમાન્ડ ટોકન માંગે તો રોકો અને પૂછો.
- ઓડિટિંગ: દરેક યોજના, ડિફ અને કમાન્ડ લોગમાં સંગ્રહો.
કેવી રીતે જાણવું કે તે કાર્યરત છે
- આગ રાશિ ઘટે: એક કલાક લાગતા બગફાળ એક દસ મિનિટમાં પૂરાં થાય.
- ચૂકાદયાળ ભૂલો ઓછી: ડિફ નાનાં થાય, ટેસ્ટ વધુ હરી થાય.
- તમે વિશ્વાસ કરો છો: તમે દરેક ક્રિયાને ધ્યાનથી ચકાસવું બંધ કરો કારણ કે તે તમારું નુકસાન નથી કરતું.
- સાથીદારો તેનો ઉપયોગ કરે છે: સફળતાનું માપ એ છે કે બીજાઓ તેને બેઠક વગર અપનાવે.
સાવચેતીથી સ્કેલિંગ વધારવી
જોઈએ તો શિસ્ત સાથે સ્કેલ કરો:
- પારલેલ સબટાસ્ક, પારલેલ મગજ નહીં: કામ વિભાજિત કરો, હજારો લૂપ અલગ ડિરેક્ટરીમાં ચલાવો અને જ્યારે tests ગુડ હોય ત્યારે મર્જ કરો.
- એપિસોડિક મેમોરી, ન કે બ્રેઇન ડમ્પ: સફળ પેચ અને નિર્જ જીવનસ્વરૂપ લક્ષણો સંગ્રહો. જરુરિયાત મુજબ મેળવો.
- સમયાંતરે ‘મોટા’ પાસ: રિફેક્ટર્સ માટે માનવ-આધારિત સત્ર સંગ્રહો; એજન્ટ સહાય કરે, ને નેતૃત્વ ન આપે.
ન્યૂનતમ રેફરન્સ અમલ (ખાકો)
Python જેવો સુધીકોડ શરૂઆત:
- def init(self, repo_root, model):
- self.history = [] # છેલ્લાં બે ડિફ અને ટેસ્ટ આઉટપુટ
- "repo": summarize_repo(self.root),
- "constraints": {"write_whitelist": ["src/", "tests/"], "max_diff_lines": 300, "no_network": True},
- "history": self.history[-2:],
- plan = self.model("propose_plan", self.context(task))
- diff = self.model("propose_patch", {"plan": plan})
- out = run_cmd(plan.test_cmd)
- eval = self.model("evaluate", {"output": out, "plan": plan})
- self.history.append({"diff": diff, "out": tail(out)})
એક માનવ-દરજાની સમાપ્તિ
ઉદ્યોગ સતત સ્વચાલિત ડેવલોપર એજન્ટની પ્રતીક્ષા કરે છે. ખરેખર જે જોઈએ એ એક સચ્ચો સહાયક છે કે જે વાંચે, યોજના બનાવે, એડિટ કરે, ચલાવે અને રોકે. Claude 4.5 આ માટે સારુ છે, જો તમે તેને આવા ફ્રેમવર્કની અંદર દબાવ્યો નહીં જેઓ પોતાને જ સમર્થન પુરૂ પાડવા માટે બને છે. લાઇટવેઇટ કોઈ સમજૂત નથી—તે જ લક્ષ્ય છે. લૂપ બનાવો, ગ્રાડરેલ્સ ઉમેરો અને ટૂલને એ કાર્ય કરાવવા દો કે જે ટૂલ સરસ રીતે કરે છે જ્યારે તમે તેને સરળ રાખો: કાર્યને નાનું બનાવવા.
સારાંશ: બોરિંગ કરી રીતે સીજલ્ટી મેળવો
Claude 4.5 સાથે લાઇટવેઇટ કોડિંગ એજન્ટ માટે તમારું ચેકલિસ્ટ:
- એક લૂપ, એક મોડેલ, નાનાં ટૂલ્સ.
- તણાવેલો સંદર્ભ: ટાસ્ક, કેટલીક ફાઇલો, છેલ્લાં આઉટપુટ્સ.
- ન્યૂનતમ ડિફ્સ, ઘણી વખત ટેસ્ટ, કડક મર્યાદાઓ.
- સ્થાનિક, સેન્ડબોક્સમાં અમલ; નેટવર્ક નહી.
- વૈકલ્પિક એડિટર સુગર; ક્યારેય જરૂરી નથી.
જો તમે ધ્યાનથી જુઓ, તો આ સારું સોફ્ટવેર એન્જિનિયરિંગ જેવું દેખાય છે, ફક્ત ઝડપી. અને એ જ છે મુદ્દો. અહીં સ્માર્ટ રીત ‘સ્વાયત્તતા’નની પાછળ દોડવું નથી—એશિક્ષિત શિસ્તનો સમાવેશ કરવો છે. જે ઓછું માંગશો એજન્ટ પાસેથી, તેટલું વધુ મળશે.
એફક્યુ
પ્રશ્ન 1: કેમ શરૂ કરવું લાઇટવેઇટ કોડીંગ એજન્ટ Claude 4.5 સાથે?
નાનું ટૂલસેટ (વાંચન, લખાણ, શોધ, ચલાવવું) નિર્ધારિત કરો, કડક સિસ્ટમ પ્રોમ્પ્ટ લખો અને Observe → Plan → Act → Reflect લૂપ અમલ કરો. સંદર્ભ નાનો રાખો અને વાસ્તવિક લોગ અને ડિફ્સ ખવડાવો—Claude 4.5 શ્રેષ્ઠ પ્રદર્શન કરે ત્યારે ટાસ્ક સૂક્ષ્મ હોય અને પ્રત્યુત્તર સ્પષ્ટ હોય.
પ્રશ્ન 2: શું Claude 4.5 એજન્ટ માટે vector ડેટાબેસ અથવા મેમરી લેવરની જરૂર પડે?
નહીં. વધુલાયક ટાસ્ક માટે, શોર્ટ-ટર્મ મેમરી અને search_code પૂરતાં છે. લાંબુ મેમરી માત્ર ત્યારે ઉમેરજો જ્યારે તમે વારંવાર એક જ રેપોઝitorios પર જાઓ અને તે ટોકન્સ બચાવે.
પ્રશ્ન 3: Claude 4.5 કોડીંગ એજન્ટ માટે કયા ગ્રાડરેલ્સ આવશ્યક છે?
લેખન માટે વ્હાઇટલિસ્ટ પાથ, ડિફ કદ મર્યાદા, કમાન્ડ પ્રતિબંધ, અને દરેક ક્રિયાનો લોગ જાળવો. આ મર્યાદાઓ એજન્ટને અનુમાનીય રાખે છે અનેRollbackને સરળ બનાવે છે.
પ્રશ્ન 4: શું લાઇટવેઇટ એજન્ટ બહુ ફાઇલીયારા રિફેક્ટર હેન્ડલ કરી શકે?
હા, જો તમે કામ નાના પગલાંમાં વિભાજિત કરો અને લૂપને તણાવેલ રાખો. Claude 4.5 રિફેક્ટર્સ મેનેજ કરી શકે છે, પરંતુ તમે સ્કોપ માર્ગદર્શન આપો; નહિ તો તમારું એક મોટું, નબળા ડિફ આવશે જે તમે જોવા ના ઇચ્છશો.
પ્રશ્ન 5: Claude 4.5 કોડીંગ એજન્ટ માટે Sider.AIની શું ભૂમિકા છે?
Sider.AI ઉપયોગી છે એક જ જગ્યા ખાતે વાતચીત, ડિફ્સ અને કમાન્ડ સાથે સગવડભર્યું વર્કસ્પેસ તરીકે, કોઈ ભારે એજન્ટ ફ્રેમવર્ક નહીં મજબૂર કરતાં. તેનો ઉપયોગ તમારી લૂપ ચલાવવા માટે કરો, નવી શોધ માટે નહીં. 
