നിങ്ങൾ ആഗ്രഹിച്ചത് ഒടുവിൽ ഇതാ! Ralph TUI, വിഷ്വലൈസ്ഡ് Ralph Loop

# നിങ്ങൾ ആഗ്രഹിച്ചത് ഒടുവിൽ ഇതാ! Ralph TUI, വിഷ്വലൈസ്ഡ് Ralph Loop ഞാൻ മുമ്പ് **ralph-loop** നെക്കുറിച്ച് ഒരു ട്യൂട്ടോറിയൽ എഴുതിയിരുന്നു. പല സുഹൃത്തുക്കളും ഇത് ചെയ്തുനോക്കിയ ശേഷം നൽകിയ പ്രതികരണം ഏതാണ്ട് ഒന്നുതന്നെയായിരുന്നു: **സംഗതി ഉഷാറാണ്, Claude Code ഒടുവിൽ ദീർഘനേരം പ്രവർത്തിപ്പിക്കാൻ സാധിക്കുന്നു.** പക്ഷേ ചില സമയങ്ങളിൽ ഇത് അനങ്ങാതെ നിൽക്കുന്നതായി തോന്നുമ്പോൾ ഒരു ആശങ്ക തോന്നാറുണ്ട്: "ഇത് ശരിക്കും മുന്നോട്ട് പോകുകയാണോ, അതോ അവിടെത്തന്നെ കറങ്ങിക്കൊണ്ടിരിക്കുകയാണോ?" അതുകൊണ്ടാണ് ഞാൻ ഈയിടെയായി **ralph-tui** യെക്കുറിച്ച് പഠിക്കാൻ തുടങ്ങിയത്.  **ralph-tui Claude Code-മായി നിർബന്ധമായി ബന്ധിപ്പിക്കുന്നില്ല. ഇത് ralph loop- ൻ്റെ പ്രധാന ആശയം പിന്തുടരുകയും വികസിപ്പിക്കുകയും ചെയ്യുന്നു. കൂടാതെ ടാസ്‌ക് എക്സിക്യൂഷനും പ്രോസസ്സ് വിഷ്വലൈസേഷനും സാധ്യമാക്കുന്നു, ഇത് വലിയ മോഡലുകൾ ദീർഘനേരം പ്രവർത്തിപ്പിക്കാനുള്ള ബുദ്ധിമുട്ട് കുറയ്ക്കുന്നു.** നിങ്ങൾക്ക് മറ്റ് ഏജൻ്റുകളെയും മോഡലുകളെയും ബന്ധിപ്പിക്കാൻ കഴിയും, തദ്ദേശീയമായവ, വിലകുറഞ്ഞവ, ദീർഘകാലം പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്നവ എന്നിങ്ങനെയുളളവ ഉപയോഗിക്കാം. ralph-tui ഉള്ളതുകൊണ്ട്, സാധാരണക്കാരെ സംബന്ധിച്ചിടത്തോളം, മാനുവൽ ഗിയറിൽ നിന്ന് ഓട്ടോമാറ്റിക് ഗിയറിലേക്കും ക്രൂയിസ് കൺട്രോളിലേക്കും മാറുന്നത് പോലെയാണ്. ## ഇത് ശരിക്കും എന്താണ്? ralph-tui-യെ നിങ്ങൾക്ക് ഒരു "**AI കോഡിംഗ് ഏജൻ്റിൻ്റെ ലൂപ്പ് ഓർക്കസ്ട്രേറ്റർ**" ആയി കണക്കാക്കാം. ഇത് "പ്രവർത്തിപ്പിക്കാൻ കഴിയുക" എന്നതിലുപരി "**നിങ്ങൾക്ക് കാണാനും നിയന്ത്രിക്കാനും വീണ്ടെടുക്കാനും കഴിയുക**" എന്നതിനാണ് പ്രാധാന്യം നൽകുന്നത്. ഇതിൻ്റെ അടിസ്ഥാന പ്രവർത്തനരീതി ലളിതമാണ്: - നിങ്ങൾ ഇതിന് ഒരുപാട് ടാസ്‌ക്കുകൾ നൽകുന്നു (PRD-യിൽ നിന്നോ മറ്റ് ടാസ്‌ക് സിസ്റ്റങ്ങളിൽ നിന്നോ ആകാം) - അതിൽ ഏറ്റവും മുൻഗണനയുള്ള ഒന്ന് തിരഞ്ഞെടുക്കുന്നു - പ്രോംപ്റ്റ് കൂട്ടിച്ചേർക്കുന്നു - ഏജൻ്റിനെ പ്രവർത്തിപ്പിക്കാൻ തുടങ്ങുന്നു - ഈ ടാസ്‌ക് പൂർത്തിയായെന്ന് വിലയിരുത്തുന്നു - സ്റ്റാറ്റസ് എഴുതി ചേർക്കുന്നു - അടുത്ത റൗണ്ട് തുടരുന്നു പ്രധാനമായി, ഇതെല്ലാം നിങ്ങൾക്ക് ടെർമിനലിൽ കാണാൻ കഴിയും, കൂടാതെ എപ്പോൾ വേണമെങ്കിലും നിർത്താനും ഏറ്റെടുക്കാനും സാധിക്കും. ഇതിൻ്റെ ഔദ്യോഗിക നിർവചനം വളരെ ലളിതമാണ്: ഒരു ഇൻ്ററാക്ടീവ് TUI ഉള്ള ഏജൻ്റ് ലൂപ്പ് ഓർക്കസ്ട്രേറ്റർ, ഇത് TUI / ഹെഡ്‌ലെസ്സ് / റിമോട്ട് എന്നിവയെ പിന്തുണയ്ക്കുന്നു. ## എന്തുകൊണ്ടാണ് ഇത് "ദീർഘകാലം പ്രവർത്തിപ്പിക്കാൻ" കൂടുതൽ അനുയോജ്യമാണെന്ന് ഞാൻ പറയുന്നത്? ഒരു സ്ക്രിപ്റ്റ് ലൂപ്പ് പ്രവർത്തിപ്പിക്കുമ്പോൾ ഉണ്ടാകുന്ന ഏറ്റവും വലിയ പ്രശ്നം, അത് എവിടെയെത്തി എന്ന് അറിയാൻ കഴിയുന്നില്ല എന്നതാണ്. ലോഗുകൾ വളരെ വേഗത്തിൽ സ്ക്രീനിൽ കാണിക്കുന്നു, ഫാൻ നല്ല രീതിയിൽ കറങ്ങുന്നുണ്ടാകും, പക്ഷേ നിങ്ങളുടെ മനസ്സിന് ഒരു ഉറപ്പുമുണ്ടാവില്ല: - ഇത് ഒരേ ബഗ് വീണ്ടും വീണ്ടും പരിഹരിക്കുകയാണോ? - ഇത് ഒരേ കോഡ് വീണ്ടും മാറ്റിയെഴുതുകയാണോ? - ഇത് പൂർത്തിയായിട്ടും പുറത്തുകടക്കാത്തതാണോ? - ഇത് ഏതെങ്കിലും ടെസ്റ്റിൽ കുടുങ്ങി ഡെഡ്‌ലോക്ക് ആയതാണോ?  ralph-tui ഇതിന് നൽകുന്ന പരിഹാരം വളരെ "എൻജിനീയറിംഗ്" രീതിയിലുള്ളതാണ്: - ഇതിന് സെഷൻ എന്നൊരു ആശയം ഉണ്ട്, അതിലൂടെ സ്റ്റാറ്റസ് ഡിസ്കിൽ സേവ് ചെയ്യാനാവും (.ralph-tui/session.json) - ക്രാഷ് ആയാൽ റിക്കവർ ചെയ്ത് റൺ ചെയ്യാൻ സാധിക്കും (crash recovery) - ലോക്ക് മെക്കാനിസം ഉണ്ട്, ഇത് ഒന്നിലധികം ഇൻസ്റ്റൻസുകൾ ഒരേസമയം തുറന്ന് ഡയറക്ടറി കുഴപ്പത്തിലാക്കുന്നത് തടയുന്നു - CI-യിൽ ഹെഡ്‌ലെസ്സ് ആയി റൺ ചെയ്യാനും റിമോട്ട് ലിസണർ ഓപ്പൺ ചെയ്ത് ലോക്കൽ TUI ഉപയോഗിച്ച് കണക്ട് ചെയ്യാനും സാധിക്കും ഒറ്റവാചകത്തിൽ പറഞ്ഞാൽ: **ഇത് കോഡ് എഴുതാൻ അറിയുന്ന ഒരു തൊഴിലാളിയെ നിങ്ങൾ നിയന്ത്രിക്കുന്നതുപോലെയാണ്, അല്ലാതെ ഒരു സ്ക്രിപ്റ്റ് തകരാറിലാകുന്നത് നോക്കിനിൽക്കുന്ന പോലെയല്ല.** ## എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാം ralph-tui Bun/TypeScript എക്കോസിസ്റ്റത്തിലാണ് നിർമ്മിച്ചിരിക്കുന്നത്, അതുകൊണ്ട് ഇൻസ്റ്റാൾ ചെയ്യാൻ എളുപ്പമാണ്. ഔദ്യോഗിക ഇൻസ്റ്റലേഷൻ പേജിൽ ഇതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ നൽകിയിട്ടുണ്ട്. ആദ്യം നിങ്ങളുടെ മെഷീനിൽ bun ഉണ്ടെന്ന് ഉറപ്പാക്കുക: `bun --version` അതിനുശേഷം ralph-tui ഇൻസ്റ്റാൾ ചെയ്യുക (ഞാനിവിടെ ഒരു സാധാരണ ഇൻസ്റ്റലേഷൻ രീതി നൽകാം, കൂടുതൽ വിവരങ്ങൾക്കായി ഔദ്യോഗിക ഇൻസ്റ്റലേഷൻ പേജ് റഫർ ചെയ്യുക): `bun add -g ralph-tui` ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം ഒന്ന് പരിശോധിക്കുക: `ralph-tui --help` നിങ്ങൾ Node ഉപയോഗിക്കുന്ന ഒരാളാണെങ്കിൽ bun ഉപയോഗിക്കാൻ താല്പര്യമില്ലെങ്കിൽ ഇങ്ങനെ ചെയ്യാം: `npm i -g ralph-tui` ## വലിയ കാര്യങ്ങൾ ചെയ്യുന്നതിന് മുമ്പ്, ഒരു ചെറിയ ലൂപ്പ് പ്രവർത്തിപ്പിക്കുക ആദ്യമായി ഉപയോഗിക്കുമ്പോൾ, വലിയ പ്രൊജക്ടുകൾ ഒന്നും ചെയ്യാൻ ശ്രമിക്കാതെ, ഒരു ചെറിയ ടാസ്‌ക് പൂർത്തിയാക്കാൻ ശ്രമിക്കുക. ### ഇനിഷ്യലൈസേഷൻ ഏതെങ്കിലും ഒരു ഡയറക്ടറി തുറക്കുക: `mkdir ralph-tui-demo && cd ralph-tui-demo ralph-tui setup` ഇത് ഒരു ഇൻ്ററാക്ടീവ് ഗൈഡൻസ് ഫ്ലോയിലേക്ക് പ്രവേശിക്കും, ലളിതമായി പറഞ്ഞാൽ "ralph-tui നിങ്ങളുടെ റിപ്പോസിറ്ററിയിൽ ഇൻസ്റ്റാൾ ചെയ്യുക" എന്നതാണ് ഇതിൻ്റെ ലക്ഷ്യം. ഇത് താഴെ പറയുന്ന കാര്യങ്ങൾ ചെയ്യും: - നിങ്ങളുടെ മെഷീനിൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള ഏജൻ്റുമാരെ സ്വയം കണ്ടെത്തുന്നു (ഉദാഹരണത്തിന് Claude Code, OpenCode തുടങ്ങിയവ) - പ്രോജക്റ്റിൽ ഒരു കോൺഫിഗറേഷൻ ഫയൽ ഉണ്ടാക്കുന്നു: .ralph-tui/config.toml - PRD ജനറേഷൻ / ടാസ്‌ക് ട്രാൻസ്ഫോർമേഷൻ എന്നിവയുമായി ബന്ധപ്പെട്ട സ്കില്ലുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു (പിന്നീട് നിങ്ങൾ സ്വയം ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതില്ല) എൻ്റെ വ്യക്തിപരമായ നിർദ്ദേശം: ആദ്യമായി മടി കാണിക്കരുത്, **setup തീർച്ചയായും പ്രവർത്തിപ്പിക്കുക**. ### പ്രോജക്റ്റ് PRD ഉണ്ടാക്കുക setup പ്രവർത്തിപ്പിച്ച ശേഷം, അടുത്ത ഘട്ടം ഔദ്യോഗിക ട്യൂട്ടോറിയലിലെ പ്രധാനപ്പെട്ടതും ഒരു ഡെമോ ആയി എഴുതാൻ ഏറ്റവും അനുയോജ്യമായതുമായ ഭാഗമാണ്: **create-prd**. `ralph-tui create-prd --chat` എന്ന കമാൻഡ് ഒരു സംഭാഷണ പ്രക്രിയയിലേക്ക് പ്രവേശിക്കുന്നു, ഒരു പ്രോഡക്റ്റ് മാനേജരെപ്പോലെ ഇത് നിങ്ങളുടെ ആവശ്യകതകൾ, ലക്ഷ്യങ്ങൾ, അതിരുകൾ, സ്വീകാര്യതാ മാനദണ്ഡങ്ങൾ എന്നിവയെക്കുറിച്ച് ചോദിച്ചറിയുന്നു. ചോദിച്ച ശേഷം, ഇത് പ്രോജക്റ്റിൽ നേരിട്ട് രണ്ട് കാര്യങ്ങൾ നൽകുന്നു (ഇതാണ് പ്രധാന കാര്യം): - ഒരു PRD markdown ഫയൽ: ./tasks/prd-feature.md - നേരിട്ട് പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന ഒരു ടാസ്‌ക് ഫയൽ: ./prd.json ഈ ഘട്ടത്തിൽ, നിങ്ങൾ ശരിക്കും ralph-tui-യുടെ "സ്റ്റാൻഡേർഡ് ക്ലോസ്ഡ് ലൂപ്പിലേക്ക്" പ്രവേശിക്കുന്നു: **ആവശ്യം (PRD) → ടാസ്‌ക് (prd.json) → എക്സിക്യൂഷൻ (run)** ### പ്രവർത്തിപ്പിക്കുക prd.json ഉണ്ടെങ്കിൽ, പിന്നെ run ചെയ്യുന്നത് സ്വാഭാവികമാണ്: `ralph-tui run --prd ./prd.json` TUI പ്രവർത്തിക്കുന്നത് നിങ്ങൾക്ക് കാണാം, ഇത് ഒരു ലൂപ്പ് പോലെ പ്രവർത്തിക്കുന്നു: ടാസ്‌ക് തിരഞ്ഞെടുക്കുക → പ്രവർത്തിപ്പിക്കുക → പൂർത്തിയായെന്ന് വിലയിരുത്തുക → സ്റ്റാറ്റസ് എഴുതുക → അവസാനിക്കുക അല്ലെങ്കിൽ അടുത്ത റൗണ്ട്. ആദ്യമായി പ്രവർത്തിപ്പിക്കുമ്പോൾ, ഒരു പരിധി നിശ്ചയിക്കാൻ ഞാൻ ശക്തമായി നിർദ്ദേശിക്കുന്നു, ആദ്യം ഇതിനെ ഒരു കൂട്ടിലിടുക: `ralph-tui run --prd ./prd.json --iterations 5` പ്രവർത്തിപ്പിച്ച ശേഷം മാറ്റങ്ങൾ പരിശോധിക്കുക, ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുക, PRD-യും ടാസ്‌ക്കും പ്രതീക്ഷിച്ചതുപോലെയാണോ എന്ന് നോക്കുക. ഈ ലിങ്ക് ശരിയാണെന്ന് ഉറപ്പാക്കിയ ശേഷം, iterations തുറക്കുക, തുടർന്ന് headless/remote എന്നിവ ഉപയോഗിക്കുക, ഇതാണ് ശരിയായ രീതി. ഈ സമയം നിങ്ങൾക്ക് ഉറപ്പിക്കാൻ കഴിയും: **ഈ ലൂപ്പ് ശരിക്കും പ്രവർത്തിക്കുന്നു.** ## മോഡൽ / ഏജൻ്റ് എങ്ങനെ തിരഞ്ഞെടുക്കാം? പണം ലാഭിക്കുന്നതിനെക്കുറിച്ച് സത്യം പറയണം പലരും ഏറ്റവും കൂടുതൽ ശ്രദ്ധിക്കുന്നത് ഇതാണ്: "എനിക്ക് Claude Code ഉപയോഗിക്കാതിരിക്കാൻ കഴിയുമോ? വിലകുറഞ്ഞ മോഡലുകൾ ഉപയോഗിക്കാൻ കഴിയുമോ?" ഉത്തരം: **കഴിയും.** ralph-tui ഏജൻ്റും മോഡലും വ്യക്തമാക്കാൻ നിങ്ങളെ പിന്തുണയ്ക്കുന്നു (ഔദ്യോഗിക run ഡോക്യുമെൻ്റിൽ ഉദാഹരണങ്ങളുണ്ട്). ഉദാഹരണത്തിന് Claude Opus ഉപയോഗിച്ച്: `ralph-tui run --prd ./prd.json --agent claude --model opus` എന്നാൽ സത്യം പറഞ്ഞാൽ, "ടെസ്റ്റുകൾ ചേർക്കുക, lint ശരിയാക്കുക" തുടങ്ങിയ ജോലികൾ ചെയ്യാൻ ഞാൻ Opus ഉപയോഗിക്കില്ല, അത് വളരെ ചെലവേറിയതാണ്. എൻ്റെ രീതി ഒരു തരംതിരിവാണ്: - **വിലകുറഞ്ഞ മോഡലുകൾ**: ധാരാളം ആവർത്തിച്ചുള്ള ജോലികൾ ചെയ്യുന്നു (ടെസ്റ്റുകൾ ചേർക്കുക, കമൻ്റുകൾ ചേർക്കുക, ഫോർമാറ്റ് ശരിയാക്കുക, അതിരുകൾ ചേർക്കുക) - **വിലകൂടിയ മോഡലുകൾ**: പ്രധാനപ്പെട്ട ഘട്ടങ്ങളിൽ മാത്രം ഉപയോഗിക്കുന്നു (ആർക്കിടെക്ചർ ക്രമീകരണം, ബുദ്ധിമുട്ടുള്ള ബഗുകൾ, പ്രധാന ലോജിക്) നിങ്ങൾ ഒരു സാധാരണ ഡെവലപ്പർ ആണെങ്കിൽ, ഈ ആശയം കൂടുതൽ പ്രധാനമാണ്. കാരണം നിങ്ങൾക്ക് വലിയ കമ്പനിയുടെ ബഡ്ജറ്റ് ഇല്ല, നിങ്ങൾക്ക് ചെലവ് നിയന്ത്രിക്കാൻ കഴിയണം, എങ്കിൽ മാത്രമേ കൂടുതൽ കാലം പ്രവർത്തിപ്പിക്കാൻ കഴിയൂ. ## കൂടുതൽ എളുപ്പത്തിൽ ചെയ്യണോ? "PRD എഴുതുന്നത്" ഏജൻ്റിനെ ഏൽപ്പിക്കുക ralph-tui-ൽ എനിക്കിഷ്ടപ്പെട്ട ഒരു ഡിസൈൻ ഉണ്ട്: ഇത് സ്കില്ലുകളെ പിന്തുണയ്ക്കുന്നു (ലളിതമായി പറഞ്ഞാൽ, ഏജൻ്റിൻ്റെ ഒരു എക്സ്റ്റൻഷൻ കമാൻഡ്). ഔദ്യോഗികമായി ഇൻസ്റ്റാൾ ചെയ്യാൻ add-skill ഉപയോഗിക്കാം: `bunx add-skill subsy/ralph-tui --all` അല്ലെങ്കിൽ ഒരു പ്രത്യേക ഏജൻ്റിലേക്ക് ഇൻസ്റ്റാൾ ചെയ്യാം, ഉദാഹരണത്തിന് claude-code: `bunx add-skill subsy/ralph-tui -a claude-code -g -y` ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, നിങ്ങൾക്ക് ഏജൻ്റ് സംഭാഷണത്തിൽ slash command ഉപയോഗിക്കാം: `/ralph-tui-prd /ralph-tui-create-json /ralph-tui-create-beads` ഇത് നിങ്ങളുടെ IDE-യിൽ ഒരു പ്ലഗിൻ ഇൻസ്റ്റാൾ ചെയ്തത് പോലെയാണ്, പക്ഷേ ഈ പ്ലഗിൻ ഏജൻ്റിന് വേണ്ടിയുള്ളതാണ്. ഇതിൻ്റെ പ്രാധാന്യം "ആവശ്യകതകൾ സ്വയം മാറ്റിയെഴുതുന്ന" സമയം കുറയ്ക്കുക എന്നതാണ്, ഇത് ആവശ്യം → ടാസ്‌ക് → എക്സിക്യൂഷൻ എന്നിവ ഒരുപോലെയാക്കുന്നു. ## എപ്പോഴാണ് ഇത് ഉപയോഗിക്കേണ്ടത്? എപ്പോൾ ഉപയോഗിക്കാതിരിക്കണം? എനിക്ക് "എന്തും AI ഉപയോഗിച്ച് ചെയ്യാൻ കഴിയും" എന്ന തരത്തിലുള്ള ആഖ്യാനം അത്ര ഇഷ്ടമല്ല, അത് ആളുകളെ തെറ്റിദ്ധരിപ്പിക്കാൻ എളുപ്പമാണ്. ഒരു ഉപകരണം ഒരു ഉപകരണം മാത്രമാണ്, അത് ഒരു സാഹചര്യത്തിന് അനുയോജ്യമാകുമ്പോൾ മാത്രമേ വിലമതിക്കുന്നുള്ളൂ. ### ralph-tui ഉപയോഗിക്കാൻ അനുയോജ്യമായ സാഹചര്യങ്ങൾ നിങ്ങൾക്ക് ഇതുപോലുള്ള ജോലികൾ ഒരുപാടുണ്ടെങ്കിൽ: - ടെസ്റ്റിംഗ് പൂർത്തിയാക്കുക (പ്രത്യേകിച്ച് പഴയ പ്രോജക്റ്റുകൾ) - lint / format ശരിയാക്കുക - ചെറിയ ഘട്ടങ്ങളായുള്ള റീഫാക്ടറിംഗ് (ആവർത്തിച്ചുള്ള കോഡുകൾ ചേർക്കുക) - ബാച്ചുകളായി ടൈപ്പുകൾ ചേർക്കുക, അതിരുകൾ പൂർത്തിയാക്കുക - ആവശ്യകതകൾ വിഭജിച്ച് ടാസ്‌ക് ക്യൂ അനുസരിച്ച് പതുക്കെ മുന്നോട്ട് പോകുക ഈ ജോലികൾക്കെല്ലാം ഒരു പൊതുവായുണ്ട്: **കൂടുതൽ ടാസ്‌ക്കുകൾ, ഉയർന്ന ആവർത്തനം, സ്വീകരിക്കാൻ കഴിയുന്നത്, ആവർത്തിച്ച് മുന്നോട്ട് കൊണ്ടുപോകാൻ കഴിയുന്നത്.** ### ralph-tui ഉപയോഗിക്കാൻ അനുയോജ്യമല്ലാത്ത സാഹചര്യങ്ങൾ നിങ്ങൾ ഇത് ചെയ്യാനാണ് ഉദ്ദേശിക്കുന്നതെങ്കിൽ: - ഒറ്റത്തവണ വലിയ റീഫാക്ടറിംഗ്, സ്വീകാര്യമായ മാനദണ്ഡങ്ങൾ വ്യക്തമല്ലാത്തത് - ആവശ്യകതകൾ അവ്യക്തമാണ്, നിങ്ങളുടെ മനസ്സിലുള്ള കാര്യങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു - ടീമുകൾ തമ്മിൽ ധാരാളം ആശയവിനിമയം / സ്ഥിരീകരണം ആവശ്യമാണ് - നിങ്ങൾ ഒരു ഉൽപ്പന്നത്തെക്കുറിച്ച് വിലയിരുത്തൽ നടത്തേണ്ടതുണ്ട് ഇത്തരം ടാസ്‌ക്കുകളിൽ, agent loop ആശയക്കുഴപ്പം വർദ്ധിപ്പിക്കും. ## ralph-loop (ralph-claude-code) തമ്മിലുള്ള വ്യത്യാസം എന്താണ്? **ralph-claude-code** എന്നത് ഒരു "Claude Code-നുള്ള ഓട്ടോപൈലറ്റ് പോലെയാണ്": ഒരു സ്ക്രിപ്റ്റ് അത് പ്രവർത്തിപ്പിക്കുന്നു, ലൂപ്പ് പ്രവർത്തിപ്പിക്കുന്നു, എക്സിറ്റ് ഡിറ്റക്ഷൻ, റേറ്റ് ലിമിറ്റിംഗ്, സർക്യൂട്ട് ബ്രേക്കർ എന്നിവയെല്ലാം നിങ്ങൾക്കായി ബാക്കപ്പ് ചെയ്യുന്നു. നിങ്ങൾക്ക് വേണ്ടത് "വേഗത" ആണ്, അത് വളരെ വേഗത്തിൽ നടപ്പിലാക്കുന്നു. **ralph-tui** എന്നത് ഒരു "agent loop-നുള്ള എഞ്ചിനീയറിംഗ് കൺസോൾ പോലെയാണ്": ഇത് ഒരു പ്രത്യേക മോഡലുമായി ബന്ധിപ്പിക്കുന്നില്ല, ഒരു പ്രത്യേക ടാസ്‌ക് സിസ്റ്റവുമായി ബന്ധിപ്പിക്കുന്നില്ല. ഇത് "ദീർഘകാലം പ്രവർത്തിപ്പിക്കുക, നിരീക്ഷിക്കാൻ കഴിയുന്നത്, നിയന്ത്രിക്കാൻ കഴിയുന്നത്, വീണ്ടെടുക്കാൻ കഴിയുന്നത്, വിദൂരമായി പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്നത്" തുടങ്ങിയ എഞ്ചിനീയറിംഗ് പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ ശ്രമിക്കുന്നു. അതിനാൽ ഏതാണ് തിരഞ്ഞെടുക്കേണ്ടതെന്ന് നിങ്ങൾ എന്നോട് ചോദിച്ചാൽ? - നിങ്ങൾ ഒരു Claude Code ഉപയോക്താവാണ്, അത് വേഗത്തിൽ പ്രവർത്തിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നു → ralph-claude-code - നിങ്ങൾക്ക് വ്യത്യസ്ത മോഡലുകൾ കണക്ട് ചെയ്യണം, പണം ലാഭിക്കണം, loop-നെ ഒരു സേവനമായി പരിഗണിക്കണം → ralph-tui ## അവസാനമായി: നിങ്ങളുടെ റിപ്പോസിറ്ററിയെ ഒരു ലബോറട്ടറിയായി കണക്കാക്കാതിരിക്കുക ഞാൻ agent loop പ്രവർത്തിപ്പിക്കുമ്പോൾ ചില നിയമങ്ങൾ പാലിക്കാറുണ്ട്, അത് താഴെക്കൊടുക്കുന്നു, അത് നിങ്ങൾ പിന്തുടർന്നാൽ അപകടങ്ങൾ കുറയ്ക്കാം: - **ഒരു ബ്രാഞ്ചിൽ പ്രവർത്തിപ്പിക്കുക, മെയിനിൽ അപകടകരമായ കാര്യങ്ങൾ ചെയ്യാതിരിക്കുക.** - **ആദ്യമായി പ്രവർത്തിപ്പിക്കുമ്പോൾ --iterations ചേർക്കുക, അത് പ്രശ്നങ്ങളില്ലാതെ പ്രവർത്തിക്കുമെന്ന് ഉറപ്പാക്കുക.** - **ടാസ്‌ക് സ്വീകരിക്കാൻ കഴിയുന്നതായിരിക്കണം**: ഒന്നുകിൽ ടെസ്റ്റ് പ്രവർത്തിപ്പിക്കാൻ കഴിയണം, അല്ലെങ്കിൽ lint പ്രവർത്തിപ്പിക്കാൻ കഴിയണം, അല്ലെങ്കിൽ ഔട്ട്പുട്ട് ഫയലുകൾ താരതമ്യം ചെയ്യാൻ കഴിയണം. - **നിർത്താൻ പഠിക്കുക**: അത് കറങ്ങാൻ തുടങ്ങുന്നത് കണ്ടാൽ, കൂടുതൽ പണം കളയുന്നതിലും നല്ലത് താൽക്കാലികമായി നിർത്തുന്നതാണ്. - **ചെറിയ മോഡലുകൾ ഉപയോഗിച്ച് സാധാരണ ജോലികൾ ചെയ്യുക, വലിയ മോഡലുകൾ ഉപയോഗിച്ച് പ്രധാനപ്പെട്ട ജോലികൾ ചെയ്യുക**: ചിലവുകൾ പ്രവർത്തനത്തിലൂടെ ഉണ്ടാകുന്നതാണ്, അല്ലാതെ പ്രാർത്ഥനയിലൂടെ ഉണ്ടാകുന്നതല്ല.Project Address: https://github.com/subsy/ralph-tui