പరిచയം: നിങ്ങളുടെ വേബ് കോൺഫിഗറേഷനുകളെക്കുറിച്ച് കോഡിന് പറ്റല്ല
വലിയ ലാംഗ്വേജ് മോഡലുകളും കോഡും സംബന്ധിച്ചുള്ള കാര്യമാണ് ഇത്: അവ അതിസ്പ Springs ഉദ്യമപൂർവ്വം ആത്മവിശ്വാസത്തോടെ പ്രവർത്തിച്ച് നിങ്ങളുടെ പ്രോഗ്രാം കംപൈൽ ആകുമോ അല്ലയെന്ന് ആലോചിക്കാറില്ല. Claude Haiku 4.5 sizin സമസ്യ പരിഹരിക്കാൻ പൈതൺ സ്ക്രിപ്റ്റ് എഴുതും, കൂടാതെ അത് വിനോദത്തിനായി രണ്ട് കോഡുകളും നിർമ്മിക്കും. ഇതിൽ പ്രധാന തന്ത്രം—ഒരു മാത്രം പ്രാധാന്യം ഉള്ള തന്ത്രം—Claude Haiku 4.5-നെ സത്യമാനമായ കോഡ് പ്രത്യക്ഷപ്പെടുത്തുന്നതിന് യഥാർത്ഥ പ്രോംപ്റ്റ് നൽകാൻ പഠിക്കുന്നതിലാണ്, അതായത് 'വൈബ്സ്'ക്കായുള്ള ഒഴിവ് കൂടാതെ യാഥാർത്ഥ്യത്തിനുള്ള മാക്സ്ിംം സ്ഥലമുണ്ടാക്കണം. നിങ്ങൾക്ക് കോഡ് പോലെ കേൾക്കുന്ന പ്രോസും വേണ്ട, കോഡ് പോലെ പ്രവർത്തിക്കുന്ന കോഡും വേണം. ഇത്രെ വ്യത്യാസമുണ്ട്.
പേപ്പിള് പ്രോംപ്റ്റിംഗിനെ ഹെറമതമുള്ള മന്ത്രവാദ മാണിയാക്കാറുണ്ട്—സരിയായ വാക്ക് ഉച്ചരിപ്പിച്ചാൽ പർഫക്റ്റ് ആപ്പ് കിട്ടും എന്നു കരുതുന്നു. അത് cargo kult ചിന്തയാണ്. കോഡ് ഒരു കരാറാണ്. Claude Haiku-യിൽ കൃത്യതയ്ക്കായി നിങ്ങൾക്കു വ്യക്തമായ കരാർ എഴുതണം. “ഒരു വെബ് ആപ്പ് നിർമ്മിക്കുക” എന്ന് പറയുക കരാർ അല്ല. “Python 3.12-ൽ JSON സ്വീകരിക്കുന്ന, Pydantic v2-இൽ സ്കീമ വാലിഡേറ്റ് ചെയ്ത്, സ്കീമ പിശകുകളിൽ 422 വലിക്കുന്നു, പ്രത്യേക പയ്ലോഡ് ഫോർമാറ്റിൽ മറുപടി നൽകുന്ന FastAPI എൻഡ്പോയിന്റ് ഉണ്ടാക്കുക” എന്ന് പറയുക ഒരു കരാരാണ്. അതാണ് Claude Haiku 4.5-നു കൃത്യമായ കോഡ് പ്രത്യക്ഷപ്പെടുത്താൻ പ്രോംപ്റ്റ് ചെയ്യാനുള്ള വഴി: നിങ്ങൾ കരാർ ഉറപ്പാക്കുക.
ഇത് എന്താണ് (മറ്റ് എന്തല്ല)
- ഇത് Claude Haiku 4.5 നിന്നും വിശ്വാസയോഗ്യമായ, ടെസ്റ്റുചെയ്ത കോഡ് എങ്ങനെ നേടാമെന്നുള്ള ഗൈഡ് ആണ്.
- ഇത് “AI ഡെവലപ്പർമാരെ മാറ്റിമറിയുന്നു” എന്ന പ്രചാരണ പ്രസംഗമല്ല. ഉപകരണങ്ങൾ ചിന്തയെ മാറ്റുന്നില്ല.
- പ്രായോഗിക പ്രോംപ്റ്റുകൾ, ഘടനകൾ, ഗാർഡ്രെയിലുകൾ: മജിക്കിനായി ആവശ്യമായ നോമീനലും വാരിയേഷനുകളുമായ ഭാഗങ്ങൾയെയാണ് ഇത് കേന്ദ്രീകരിക്കുന്നത്.
നിങ്ങൾക്ക് പ്രവർത്തിക്കുന്ന കോഡ് വേണമെങ്കിൽ, Claude-ക്ക് “പ്രവർത്തിക്കുന്നു” എന്ന് പൊതു, ടെസ്റ്റുചെയ്യാവുന്ന വ്യാഖ്യാനം നൽകണം. കൃത്യമായ കോഡ് ജനറേഷനായി കൃത്യത plain, testable വാക്കുകളിൽ നിർവചിക്കണം. അതാ കളി മുഴുവനും.
കൃത്യത ഒരു അഭിഭാഷകനായി, കവിയല്ലാതെ നിർവചിക്കൂ
“കൃത്യ” കോഡ് “സാധ്യത പോലെയാണ്” എന്നു തോന്നുന്ന കോഡല്ല. കൃത്യതയാണ്:
- സിന്റാക്റ്റിക് സാധുത: കോഡ് compile ആവുകയോ интерപ്രേറ്റർക്ക് കീഴിൽ പ്രവർത്തിക്കുകയോ ചെയ്യണം.
- സെമാന്റിക് തീർച്ചയ്ക്ക്: സ്പെക്കനുസരിച്ച് പ്രവർത്തിക്കുന്നു.
- ഡിറ്റർമിനിസ്റ്റിക് പെരുമാറ്റം: ഒരേ ഇൻപുട്ടിനും ഒരേ ഔട്ട്പുട്ടും, നിശ്ചിത പിശകുപരിധികളിൽ.
- വർഷൻ കorrectness: ശരിയായ SDKകൾ, API വേർഷനുകൾ, ഭാഷാ ഫീച്ചറുകൾ ഉപയോഗിക്കുന്നു.
Claude നിങ്ങൾ ചോദിക്കുന്നതുതന്നെ തരുന്നൂ. “ഒരു ഫംഗ്ഷൻ ലിസ്റ്റ് സോർട്ടുചെയ്യുക” എന്നു ചോദിച്ചാൽ ഒരു ഫംഗ്ഷൻ ലഭിക്കും. എന്നാൽ “Timsort semantics ഉപയോഗിച്ച് O(1) അധിക സ്പേസിൽ സ്റ്റെബിൾ ഇൻ-പ്ലേസ് സോർട്ട്” എന്നത് മറ്റൊരു വാഗ്ദാനമാണ്. കൃത്യമായ കോഡ് ജനറേഷനായി Claude Haiku 4.5-നെ പ്രോംപ്റ്റ് ചെയ്യുന്നത് ഈ വാഗ്ദാനങ്ങൾ പ്രോംപ്റ്റിലേക്കു എഴുതികൊടുക്കുന്നതിൽ ആരംഭിക്കണം.
കരുതേണ്ട സർവ്വം പ്രോംപ്റ്റ്, അപ്ഗ്രേഡ് ചെയ്തേശം
ചെറിയത്: “ടാസ്കുകൾക്കായി Node API എഴുതുക.”
മികവുറ്റത്: “Node 20 Express 4 API എഴുതുക, /tasks എന്ന POST റൂട്ടോടുകൂടി, ഫീൽഡുകൾ {title: string, dueDate: ISO 8601} വാലിഡേറ്റ് ചെയ്യണം, സൃഷ്ടിച്ച ഒബ്ജക്റ്റ് 201-ഓടു മറുപടി നൽകിയ്, പിശക് വിവരങ്ങളുമായി 400 റസ്പോൺസ് നൽകണം.”
ശ്രദ്ധവായി: “Node 20 Express 4 സർവറിന്റെ ഒറ്റ /tasks POST എൻഡ്പോയിന്റ് നിർമിക്കുക. ആവശ്യങ്ങൾ: 1) [email protected] ഉപയോഗിച്ച് ബോഡിയുടെ വാലിഡേഷൻ; 2) ഫീൽഡുകൾ: title (non-empty string, പരമാവധി 140), dueDate (ISO 8601 ഭാവി തീയതി); 3) വിജയത്തിൽ: {id: ULID, title, dueDate} ഉള്ള 201; 4) അസാധുവായപ്പോൾ: {error: 'VALIDATION', details: array} ഉള്ള 400; 5) ഡാറ്റാബേസ് വേണ്ട, in-memory Map; 6) ജെസ്റ്റ് 29 ടെസ്റ്റ് ഫയൽ ഉൾപ്പെടുത്തുക, സാധുവും അസാധുവും (empty title, പാസ്റ് തീയതി) ഉൾക്കൊള്ളുന്നു; 7) npm സ്ക്രിപ്റ്റുകൾ test, dev ലേക്ക് നൽകുക; 8) ESM ഉപയോഗിക്കുക; 9) അധിക അഭിപ്രായം വേണ്ട.” ഭാഷ വേർഷൻ, ലൈബ്രറികൾ, നിയന്ത്രണങ്ങൾ, ഔട്ട്പുട്ടുകൾ, പിശക് മാനേജ്മെന്റ്, ടെസ്റ്റുകൾ, പാക്കേജ് ഘടന എന്നിവ നോക്കുക. നിങ്ങൾ അസ്യൂരന്റി നീക്കം ചെയ്തിട്ടുണ്ട്. Claude-യുടെ ജോലി ആവശ്യകതകൾ നിറയ്ക്കുന്നതാണ്, കോഡ് എഴുതുക അല്ല.
സ്കാഫോൾഡിംഗ് പാറ്റേൺ: സിസ്റ്റം, സ്പെക്, ടെസ്റ്റുകൾ, പിന്നെ കോഡ്
Claude Haiku 4.5-ൽ കൃത്യതയുള്ള കോഡ് നിർമ്മിക്കാൻ നിങ്ങൾ ആവശ്യമുള്ള runway നൽകണം:
- സിസ്റ്റം ഫ്രെയിമിംഗ് (ചുരുങ്ങിയ നിയന്ത്രണം)
- നിങ്ങൾ: “നീ പ്രൊഡക്ഷൻ ക്വാളിറ്റി ടൈപ്സ്ക്രിപ്റ്റ് Node 20-ലെ കോഡ് എഴുതുകയാണ്. ഞങ്ങൾക്ക് filenames ഉള്ള കോഡ് ബ്ലോക്സ് മാത്രമേ ഔട്ട്പുട്ട് തരൂ.”
- കാരണം: ടോൺ നിയന്ത്രിക്കാനും ഫോർമാറ്റ് നിയന്ത്രിക്കാനും. ഭാഗ്യത്തിന് വിട്ടുതരരുത്.
- ഭാഷാ പതിപ്പുകൾ, പാക്കേജ് തിരഞ്ഞെടുപ്പുകൾ, പിശക് വരുന്ന രീതികൾ, I/O ഫോർമാറ്റുകൾ, പെർഫോമൻസ് പരിധികൾ, സുരക്ഷാ നിയന്ത്രണങ്ങൾ ഉൾപ്പെടുത്തുക.
- Claude-നു ആദ്യം യൂണിറ്റ് ടെസ്റ്റുകൾ എഴുതാൻ പറ. ടെസ്റ്റുകൾ “കൃത്യത” അർത്ഥമാക്കുന്നത് അന്തസ്സായി നിർവ്വചിക്കുന്നു. ടെസ്റ്റിന്നു സേവിക്കാത്ത കോഡിന് സജീവ് ലക്ഷ്യം ഇല്ല.
- ടെസ്റ്റുകൾ കഴിഞ്ഞതിനു ശേഷം മാത്രം. ഇത് തകർന്നില്ലെങ്കിൽ, TDD പോലെയാണ്, പക്ഷേ ബോർ ചെയ്യാതെ ബോയിലറ്പ്ലേറ്റ് എഴുതുന്ന റോബോട്ടിനൊപ്പം.
- “ടെസ്റ്റുകൾ പരാജയപ്പെട്ടാൽ അല്ലെങ്കിൽ ഇംപോർട്ടുകൾ സ്പെക് ഇല്ലാതെ പോയാൽ, പരാജയപ്പെട്ട ഭാഗങ്ങൾ മാത്രം പുതുക്കുക. മുഴുവൻ പ്രോജക്റ്റ് വീണ്ടും എഴുതരുത്.”
Claude-യ്ക്ക് കോൺടെക്സ്റ്റും റെയിൽസ് ഉണ്ടെങ്കിൽ അത് മികച്ച പ്രവർത്തനം കാഴ്ചവയ്ക്കുന്നു. റെയിൽസ് നൽകുക.
വർഷൻ പിനിംഗ് оп്ഷണൽ അല്ല
Claude-യുടെ ട്രെയ്നിങ് ഡാറ്റ പഴയതും പുതിയതുമായ ഡോക്യുമെന്റുകൾ പൂരിപ്പിച്ചിരിക്കുന്നു. അതായത് വൃത്തിയുള്ള അഭിപ്രായങ്ങൾക്ക് എതിർ. “Use React Router” അർത്ഥം വ്യക്തമല്ല. “[email protected] ഡാറ്റ റൂട്ടറുകളോടെ ഉപയോഗിക്കുക” ദിശാനിർദ്ദേശമാണ്. ഡിഫോൾട് വിശ്വസിക്കരുത്: - ഭാഷകൾ: Python 3.12, Node 20, Go 1.22, Java 21 പോലുള്ള നിങ്ങൾ യഥാർത്ഥത്തിൽ പ്രവർത്തിക്കുന്ന പതിപ്പുകൾ പിന് നിർവചിക്കുക.
- ഫ്രെയിംവർക്കുകൾ: സുപ്രധാന വേർഷനുകൾ, ബ്രേക്കിംഗ് ചേഞ്ച് ഫ്ളാഗുകൾ വ്യക്തമാക്കുക.
- ക്ലൗഡ് SDK-കൾ: പതിപ്പുകൾ പിന് നിർവചിക്കുക; aws-sdk v2 വ്യത്യസ്തം v3-ൽ.
- ലിന്റേഴ്സ്/ഫോർമാറ്റേഴ്സ്: റൂൾസ് വ്യക്തമാക്കുക, 'സ്റ്റൈൽ പിംഗ്-പോങ്' ഒഴിവാക്കാൻ.
പിന് ചെയ്യാത്ത പക്ഷം, അഞ്ച് വർഷ ക്ലാസിക് ബ്ലോഗ് പോസ്റ്റുകളുടെ മിശ്രിതം കിട്ടും. കൃത്യമായ കോഡ് നിർമ്മാണം പഴയ ചിത്രങ്ങളോട് പൊരുത്തപ്പെടുന്നില്ല.
സ്കീമാ ആദ്യം, എപ്പോഴും
“ഉപഭോക്തൃ പ്രൊഫൈൽ” ഘടനകൾ ചോദിക്കരുത്. സ്കീമകൾ പ്രോംപ്റ്റിൽ നിർവചിച്ചു, വാലിഡേഷൻ ആവശ്യപ്പെടുക:
- JSON Schema അല്ലെങ്കിൽ Zod/Yup ടൈപ്പുകൾ JS/TS-ൽ
- Python-ൽ Pydantic മോഡലുകൾ
- സർവീസുകൾക്കായി Protobuf അല്ലെങ്കിൽ Avro
പിന്നീട് Claude-നെ സ്കീമകൾ API ഇൻപുട്ടുകൾ, ഡാറ്റാബേസ് എഴുത്തുകൾ, മെസ്സേജ് ക്യൂകൾ അതിർത്തികളിൽ പാലിക്കാൻ പറയുക. വ്യക്തമായ പിശക് പയ്ലോഡുകളും കോഡുകളും ആവശ്യപ്പെടുക. കൃത്യത സ്കീമകൾക്ക് പ്രിയങ്കരമാണ്, അസുഖവുമല്ല.
എത് കാണാൻ കഴിയണം, അല്ലെങ്കിൽ അത് യാഥാർത്ഥ്യമാണെന്ന പ്രത്യക്ഷപ്പെടരുത്
Claude-നെ ലോഗിംഗും മെട്രിക്ക്സും ട്രേസുകളും ആവശ്യമായ സ്ഥലങ്ങളിൽ ചേർക്കാൻ പറയും, ആവശ്യമില്ലാത്ത സ്ഥലത്ത് ശാന്തമാക്കാനും. നല്ല ഒരു പ്രോംപ്റ്റിൽ ഉൾപ്പെടുന്നു:
- ലോഗിംഗ് നയം: ലെവലുകൾ, PII-യുടെ റെഡാക്ഷൻ, ഘടന (ദയവായി JSON ലോഗുകൾ)
- മെട്രിക്ക്സ്: ഓരോ അഭ്യർത്ഥനയ്ക്കും സമയം, പിശക് എണ്ണങ്ങൾ
- ഹെൽത്ത് എൻഡ്പോയിന്റുകൾ: ആശ്രിത വിഭാഗങ്ങൾ പ്രവർത്തനക്ഷമമാണെന്ന് തെളിയിക്കുന്ന /healthz
Claude ആവശ്യപ്പെടുന്നതുതന്നെ ചേർക്കും. വേണ്ടെങ്കിൽ മാത്രം ലഭിക്കുന്നത് print സ്റ്റേറ്റ്മെന്റുകളായിരിക്കും - ഭാഗ്യവാനുകൾക്ക് മാത്രം.
ടെസ്റ്റ്-ഫസ്റ്റ് പ്രോംപ്റ്റുകൾ “എന്നെ വിശ്വസിക്കൂ” എന്നതിനേക്കാൾ മികവുറ്റതാണ്
Claude Haiku 4.5-ൻ accurate കോഡ് ജനറേഷനായി പ്രോംപ്റ്റ് ചെയ്യാനുള്ള നല്ല ഒരു മാർഗം ടെസ്റ്റുകളെ സത്യമാനമായി മടക്കുക എന്നതാണ്. ഉദാഹരണം:
“normalize_email(s) എന്ന function-നു pytest ടെസ്റ്റുകൾ എഴുതി:
- ലോകൽ, ഡൊമെയിൻ ഭാഗങ്ങൾ lower case ചെയ്യുന്നു;
- local ഭാഗത്ത് മാത്രം gmail.com-ൽ ഡോട്ടുകൾ നീക്കം ചെയ്യുന്നു;
- gmail.com-ൽ മാത്രം subaddress (+tag) നീക്കം ചെയ്യുന്നു;
- ഒന്നിലധികം @ ഇല്ലാത്ത, സ്പേസുള്ള ഇൻപുട്ടുകൾ നിരസിക്കുന്നു;
- യുണിക്കോഡ് ഡൊമെയ്ൻ പണികോഡ് കാത്തുവെക്കുന്നു.
എഡ്ജ് കേസ് കവർ ചെയ്യുക. ടെസ്റ്റുകൾ എഴുതിയ ശേഷം ഫംഗ്ഷൻ നടപ്പാക്കുക.
Claude പലപ്പോഴും നിങ്ങൾ നൽകിയ ടെസ്റ്റ് തകർത്തുതാങ്ങേണ്ടതായി വരുമ്പോൾ കൂടുതൽ നല്ല കോഡ് എഴുതും. എഴുതുന്നില്ലെങ്കിൽ, അത് ഒരു കൃത്യമായ പരാജയമാണ്, 'വൈബ്സ്' കിട്ടിയ വാദമല്ല.
പറയരുത് ഹല്യൂസിനേഷനുകൾ മൂലം
തന്നിയുടെ ഹല്യൂസിനേഷൻ പൂർണമായും ഒഴിവാക്കാൻ കഴിയില്ല, പക്ഷേ അതിനെ പരിധികളിലാക്കി പിടിക്കാൻ കഴിയും:
- സ്രോതസ്സുകൾ ഉള്ളപ്പോൾ മാത്രമേ സൈറ്റേഷനുകൾ അല്ലെങ്കിൽ URL ആവശ്യപ്പെടൂ. SDK മാർഗങ്ങൾക്കായി ഡോക് ലിങ്കുകൾ ആവശ്യപ്പെടുക, കോഡ് അതോടെ പൊരുത്തപ്പെടണം.
- പ്രൈവറ്റ് API-കൾക്കായി സ്പെക് പ്രോംപ്റ്റിൽ പകർത്തുക. Claude നിങ്ങളുടെ ഇന്റേണൽ എൻഡ്പോയിന്റുകൾ അറിയുമെന്ന് പ്രതീക്ഷിക്കരുത്.
- കോൾഫസിംഗ് API-കളുള്ള ലൈബ്രറികളിൽ ഔദ്യോഗിക ഡോക്സ് നിന്നു ഉദാഹരണം ഉൾപ്പെടുവിച്ച് Claude അവ പാലിക്കാൻ ഉറപ്പാക്കുക.
കൃത്യമായ കോഡ് കേവലം കൃത്യമായ റഫറൻസുകളാ ആണ്. Claude-ക്ക് റഫറൻസുകൾ നൽകുക.
സ്റ്റൈൽ ഗൈഡുകൾ: ഏറ്റവും അസുഖകരവും ഏറ്റവും ഫലപ്രദവുമായ ഒന്നു
Claude എൻകോടിംഗും സ്റ്റൈലും തരംതിരിക്കുന്നു. അത് churn കാണിച്ചേക്കാം. നിങ്ങളുടെ സ്റ്റൈൽ ഗൈഡ് പകർത്തുക. താഴെ പറയുന്നവ നിർദ്ദേശിക്കുക:
- ഫോർമാറ്റിംഗ് (Prettier, Black, gofmt ഡിഫോൾട്ട്)
- പിശക് കൈകാര്യം ചെയ്യൽ മാതൃകകൾ
പറഞ്ഞിട്ടില്ലാത്ത തിരഞ്ഞെടുപ്പുകൾക്കായി ലഘു കാരണകുറിപ്പ് ആവശ്യപ്പെടുക. ഭാവിയിലെ നിങ്ങൾ നന്ദി പറയും, ഇപ്പോഴത്തെ Claude കുറവ് 'ഫിക്സ്-അപ്പ്' PR-കൾ ഉണ്ടാക്കും.
ലോങ്ക് പ്രോംപ്റ്റുകൾ, ഷോർട്ട് ഔട്ട്പുട്ടുകൾ
Claude Haiku 4.5-ൻ കൃത്യമായ കോഡ് ജനറേറ്റു ചെയ്യാൻ വേണം എന്ന് ഒരെന്തെന്നാൽ പ്രോംപ്റ്റിൽ നിങ്ങളുടെ വാക്കുകൾ ചെലവിടാൻ; ഔട്ട്പുട്ടിൽ കുറവായി വിവരിക്കാൻ. നിങ്ങൾക്ക് വേണമെന്ന്:
- പ്രോംപ്റ്റിൽ പരമാവധി നിയന്ത്രണങ്ങൾ
- ഔട്ട്പുട്ടിൽ ഒഴിച്ചുപറി വിവരണം കുറഞ്ഞിരിക്കുക
അവയ്ക്ക് വിശദീകരണങ്ങളും തീരുമാനം ഒഴിവാക്കാൻ പറയും, filenames ഉള്ള കോഡ് ബ്ലോക്കുകൾ മാത്രം നൽകാൻ നിർദേശിക്കുക. വിശദീകരണങ്ങൾ വേണെങ്കിൽ കൂട്ടത്തവണ左旗ിക്കാം. പ്രൊസ് കോഡും ചേർക്കുന്നത് പിഴവ് വരാനുണ്ട്. മോണോകിൾ, ടോപ്പ് ഹാറ്റ് ധരിച്ച രീതിയിലെ പിശകിൽ നിന്നും തോന്നും.
പരിഷ്കരണം: തീരെ വേഗത്തിലുള്ള ലൂപ്പ്
വിശ്വസനീയമായ കോഡിലേക്ക് വേഗത്തിലുള്ള വഴി ആദ്യത്തവണ ശരിയായി ചെയ്യുക അല്ല. ചെറിയ, തിരുത്തൽ ലൂപ്പുകളാണ്:
- ടെസ്റ്റുകളും കോഡും ജനറേറ്റ് ചെയ്യുക.
- ലൊക്കൽ ഓടിക്കുക. പരാജയപ്പെട്ട ടെസ്റ്റ് ഔട്ട്പുട്ടുകളും കോംപൈലയർ പിശകുകളും Claude-ന് ഒരുപോദത്തിൽ പകർത്തുക.
- നിർദേശിക്കുക: “അവസാനപ്പെട്ട പരാജയ ഭാഗങ്ങളിൽ മാത്രം മാറ്റം വരുത്തുക; ഫംഗ്ഷൻ സിഗ്നേച്ചറുകൾ മാറ്റരുത് എക്സ്പെക്ടഡ് ടെസ്റ്റ് പരാജയമല്ലെങ്കിൽ.”
- വെളുത്ത വരെ ആവർത്തിക്കുക.
Claude തകർന്ന ഭാഗങ്ങളെപ്പറ്റി നಿಖരമായി പറഞ്ഞാൽ ഡിഫ്സ് പ്രയോഗിക്കാൻ നന്നായി കഴിയും. പരാജയ ലോഗുകൾ പരിഷ്ക്കരിക്കാതെ പകർത്തുക. ലോഗുകളാണ് സത്യം.
സുരക്ഷ ഒരു ഫീച്ചറാണ്, പോസ്റ്റ്സ്ക്രിപ്റ്റിംഗ് അല്ല
മോഡലുകൾ പബ്ലിക് കോഡിൽ നിന്നാണ് പരിശീലനം (മികച്ച, മോശം, ശാപ Boundaries), അതിനാൽ സുരക്ഷ പ്രമുഖ ആവശ്യകത ആക്കണം:
- eval, shell=True, stringly-typed SQL വ്യക്തമാക്കാതെ നിരസിക്കുക
- പാരമടറൈസ്ഡ് ക്വെറികൾ, CSRF സംരക്ഷണം, റേറ്റ് ലിമിറ്റിങ്ങ് ആവശ്യപ്പെടുക
- ഡിപെൻഡൻസി പിനിംഗ് കൂടാതെ ലോക്ക്ഫയൽ ആവശ്യപ്പെടുക
- സീക്രറ്റുകൾ പരിസ്ഥിതി വേരിയബിള്സ് അല്ലെങ്കിൽ സീക്രറ്റ് മാനേജറിലൂടെ കൈകാര്യം ചെയ്യണമെന്ന് ആവശ്യപ്പെടുക
സുരക്ഷ-ഡിഫോൾട്ട് പ്രോംപ്റ്റ് സുരക്ഷിത കോഡ് നൽകും. 'നമ്മൾ പിന്നീട് പാട്ഷ് ചെയ്യും' പ്രോംപ്റ്റ് തലക്കെട്ടുകൾക്കാണ് വഴിവെക്കുന്നത്.
പെർഫോമൻസ്: “ഫാസ്റ്റ്” എന്താണെന്ന് പറയൂ
“ഫാസ്റ്റാക്കുക” എന്നത് “ഏതുതന്നെയാണ്” എന്നർത്ഥമാക്കുന്നു. പകരം, മാനദണ്ഡങ്ങൾ വ്യക്തമാക്കുക:
- ലാറ്റൻസി ലക്ഷ്യങ്ങൾ (p95 < 50ms in-memory, p95 < 300ms DB ഓപ്പുകളിൽ)
- മെമ്മറി പരിധികൾ (RSS <150MB)
- സമയം സങ്കീർണമാകൽ (O(n log n), അല്ലെങ്കിൽ O(n^2) അല്ല)
Claude നിങ്ങൾ നൽകിയ ബഡ്ജറ്റിനനുസരിച്ചു algorithms തിരഞ്ഞെടുക്കും. ബഡ്ജറ്റ് നൽകി.
ഡോക്യുമെന്റേഷൻ: ഇനി വെറും വിചിത്രനല്ല, പുതിയ ഒരു ആളെ ഓൺബോർഡുചെയ്യാൻ മതിയും
Claude-ന് README ആവശ്യപ്പെടുക, ഇത്തരമാകണം:
- സജ്ജീകരണ നിർദ്ദേശങ്ങൾ പൂർണ്ണ പതിപ്പുകളിൽ
- ടെസ്റ്റ്, ലിൻട്, ടൈപ്പ്ചെക്ക്, റൺ കമാൻഡുകൾ
- ഉദാഹരണ അഭ്യർത്ഥനകളും മറുപടികളും
- പരിധികളും അറിയപ്പെടുന്ന ട്രേഡ്-ഓഫ്സും
“കൃത്യമായ കോഡ്” കൃത്യമായ ഡോക്യുമെന്റേഷനുമാണ്. അവ ഡെലിവറിബിൾസ് ആണ്.
പ്രായോഗിക പ്രോംപ്റ്റ് ടെംപ്ലേറ്റുകൾ നിങ്ങൾക്കായി
ടെംപ്ലേറ്റ്: ബാക്ക്എൻഡ് എൻഡ്പോയിന്റ്
സിസ്റ്റം: നിങ്ങൾ ശ്രദ്ധാപൂർവ്വം Python 3.12 എഞ്ചിനീയറാണ്. filenames ഉള്ള കോഡ് ബ്ലോക്കുകൾ മാത്രം ഔട്ട്പുട്ട് ചെയ്യുക.
ഉപയോക്താവ്:
- FastAPI 0.111 ആപ്പിൽ POST /convert എൻഡ്പോയിന്റ് നിര്മിക്കുക.
- രേഖ: {amount: Decimal as string, from: 'USD'|'EUR', to: same}.
- pydantic v2-ഉം ഉപയോഗിച്ച് വാലിഡേറ്റ് ചെയ്യുക; സ്കീമ പിശകുകളിൽ 422 ഷേപ്പ് റിട്ടേൺ ചെയ്യുക.
- പലിശ ചെയ്ത റെറ്റ്സുകളോടെ (USD:1, EUR:1.1) പ്യോർ ഫങ്ഷൻ convert(amount, from, to) ഉപയോഗിക്കുക.
- 200 സ്റ്റാറ്റസ്കോടോടെ {amount: string, currency: string} റിട്ടേൺ ചെയ്യുക.
- സാധുവും അസാധുവും (ഭ്രാന്ത് ഡെസിമൽ, അപരിചിത കോഡ്), എഡ്ജ് (0) ഉൾപ്പെടുന്ന pytest ടെസ്റ്റുകൾ ഉൾപ്പെടുത്തുക.
- പിന്നെ pyproject.toml, depended പിന് ചെയ്തിട്ടുള്ളതും ruff, mypy config ഉം നൽകുക.
- നെറ്റ്വർക്ക് കോൾ വേണ്ട, വിശദീകരണം വേണ്ട.
ടെംപ്ലേറ്റ്: CLI ഉപകരണം
സിസ്റ്റം: Go 1.22 ൽ കോഡ് എഴുതുന്നു. filenames ഉള്ള bloocks മാത്രം ഔട്ട്പുട്ട് ചെയ്യുക.
ഉപയോക്താവ്:
- stdin വായിച്ചു URL-സേഫ് സ്ലഗുകൾ പ്രിന്റ് ചെയ്യുന്ന slugify CLI സൃഷ്ടിക്കുക.
- നിയമങ്ങൾ: lowercase, ASCII-മാത്രം, ഹൈഫ് സെപ്പറേറ്ററുകൾ, വെവ് സ്പെയിസ്, പങ്ചുവേഷൻ നീക്കം ചെയ്യുക.
- main.go, slugify_test.go ഉൾപ്പെടുന്ന ടേബിൾ ടെസ്റ്റുകൾ നൽകുക.
- Go stdlib മാത്രം ഉപയോഗിക്കുക.
- Makefile - ടെസ്റ്റ്, ബിൽഡ് ടാർഗെറ്റുകൾ ഉൾക്കൊള്ളുക.
ടെംപ്ലേറ്റ്: ഫ്രണ്ട്എൻഡ് കണ്ട്രോൾ
സിസ്റ്റം: React 18 + TypeScript ലക്ഷ്യമിട്ട് പ്രാക്ടിക്കൽ React എഞ്ചിനിയറായി പ്രവർത്തിക്കുന്നു.
ഉപയോക്താവ്:
- <DebouncedInput> ഘടകം നടപ്പിലാക്കുക.
- Props: value: string, onChange(value): void, delay=300.
- useRef/useEffect ഉപയോഗിക്കുക; മൂന്നാം പക്ഷ ഹുക്ക് ഉപയോഗിക്കരുത്.
- vitest ടെസ്റ്റുകൾ ഫേക്ക് ടൈമറുകളോടെ ഉൾക്കൊള്ളിക്കുക.
- Storybook-ലെ മിനിമൽ സ്റ്റോറി നൽകുക.
വർഷനുകൾ pin ചെയ്തും പെരുമാറ്റം നിർവചിച്ചും ടെസ്റ്റുകൾ ആവശ്യപ്പെട്ടും ഇത്തരം ടെംപ്ലേറ്റുകൾ Claude Haiku 4.5-ൽ കൃത്യമായ കോഡ് ഗെനറേഷനായി പ്രോംപ്റ്റം നൽകുന്നതിന്റെ ഉദാഹരണങ്ങളാണ്.
ബുദ്ധിമുന്നാവാതെ പറയുക: “ഓപ്റ്റിമൈസ് ചെയ്യരുത്” എന്ന് എപ്പോഴും പറഞ്ഞാൽ എങ്ങനെ?
പരിമിത പ്രീമച്ച്യൂർ മൈക്രോ-ഓപ്റ്റിമൈസേഷനുകൾക്കു വേണ്ടിയില്ലെങ്കിൽ പറയൂ:
- “പഠിപ്പിക്കാൻ കഴിയുംതിലും കൂടുതൽ ക്ലീവർ ആലോചന വേണ്ടേ; ടെസ്റ്റുകൾ ആവശ്യപ്പെട്ടില്ലെങ്കിൽ ബിറ്റ്-ട്വിഡ്ലിംഗ് വേണ്ട.”
- “ഖ്യാതാവിൽ recursion ഒഴിവാക്കണം, iterative തരം ഹൃസ്വമാകാം.”
- “മെറ്റാപ്രോഗ്രാമിംഗ് വേണ്ട; explicit > implicit.”
Claude ഇംപ്രസ് ചെയ്യാൻ ഇഷ്ടപ്പെടും. അനുവദിക്കരുത്. ടെസ്റ്റുകൾ തുടരു, വായനാസൗഹൃദമാക്കുക. അത് മികവാണ്.
Sider.AI ജോലി പ്രവാഹത്തിൽ, യാഥാർത്ഥ്യത്തിൽ സഹായിക്കുന്നത് പ്രോംപ്റ്റുകളെ റാൻഡം ചാറ്റ് ടാബുകളിൽ ജഗ്ല് ചെയ്യുന്നത് ഉൽപ്പാദക പ്രീതി പോലെ കാണുന്നത് ഞാൻ കണ്ടിട്ടുണ്ട്. കോഡ് കോൺടെക്സ്റ്റ് മനസിലാക്കുന്ന ഒരു വർക്ക്സ്പേസ് ഉപയോഗിക്കുക. Sider.AI ഉദാഹരണമാണ്: നിങ്ങളുടെ സ്പെക്, കോഡ്, ഡിഫ്സ്, ടെസ്റ്റ് ലോക്കുകൾ എല്ലാം കാഴ്ചയിൽ വച്ച്, “പിശകു പകർത്തുക, ലൈനു തിരുത്തുക” എന്ന പ്രക്രിയ രാത്രിയിൽ കർശനമാക്കി കേന്ദ്രീകരിക്കുന്നു. മാജികല്ല; ഇത് ബോറടിക്കുന്ന സ്കാഫോൾഡിംഗ് ആണ്, ആയതിനാൽ പ്ലോട്ട് നഷ്ടപ്പെടുന്നത് തടയുന്നു. നിങ്ങളുടെ ഉപകരണത്തിന് കരാർ, ടെസ്റ്റുകൾ, കോഡ് ഒരേ സംഭാഷണത്തിൽ സൂക്ഷിക്കാൻ കഴിയുന്നുവെങ്കിൽ - കോൺഫറ്റി പടർത്താതെ നിസ്സാരമായി - അതുപയോഗിക്കൂ. Sider അത് ചെയ്യുന്നു. Claude-യെ ഒരു ഹയൂമൻ കൂട്ടുകാരനായി, ഒരു ഓറക്കിളല്ലാതെ, എങ്ങനെ പിശകുകൾ ഡീബഗ് ചെയ്യാം
- പറഞ്ഞുപോയ ടെസ്റ്റ് ഔട്ട്പുട്ട് പകർത്തുക. സംഗ്രഹിക്കരുത്.
- ഡിഫ് ആവശ്യപ്പെടുക: “ഫയൽ X-ന്റെ യുണിഫൈഡ് ഡിഫ് മാത്രമേ മറുപടി നൽകൂ.”
- റൺടൈം പിശകുകൾക്ക്, ഏറ്റവും ചെറിയ പുനരാവൃത സ്നിപ്പെറ്റ് ചേർത്ത് വിശദീകരണവും പാച്ചും ആവശ്യപ്പെടുക.
- ലൈബ്രറി പിശകുകൾക്കായി അനുയോജ്യമായ ഡോക്സ് പി.സ്ട്ട് ചെയ്ത് ചോദിക്കുക: “ഈ API ആ പതിപ്പിന് ശരിയോ? വേണ്ടെങ്കിൽ, കോഡ് പുതുക്കൂ, ശരിയായ ഡോക്സ് കാണിക്കൂ.”
ലക്ഷ്യം Claude നിൽക്കി തെളിവോടെ വാദിക്കാൻ ഇടം നൽകുക. നിങ്ങൾ തെളിവുകൾ കൊണ്ടുവരുക.
പിശക് ഫലം والتിനും പ്രതിരോധിക്കാൻ:
- “latest” API വലയം: “latest” ഉപയോഗിക്കരുത്. പതിപ്പ് X.Y വച്ച് തുടരണം.
- ശൂന്യ ടെസ്റ്റ് ഫയൽ: ടെസ്റ്റുകൾ ആവശ്യപ്പെടാതിരുന്നെങ്കിൽ, ലഭിക്കില്ല.
- ഒന്ന്-ഷോട്ട് തെറ്റായ കരുതൽ: രണ്ട് അല്ലെങ്കിൽ മൂന്നു ചെറിയ പരിഷ്ക്കരണങ്ങൾ നല്ലതാണ്. അത് വലിയ പ്രോംപ്റ്റുകളേക്കാൾ വേഗതയുള്ളതാണ്.
- പരിവർത്തിത പിശക് നയം: സ്റ്റാറ്റസ് കോഡുകൾ, പയ്ലോഡുകൾ നിർവ്വചിക്കുക. “പിശക് റിട്ടേൺ ചെയ്യുക” എന്നത് സാരം ഇല്ലാത്തത്.
- അുപയോഗിക്കാതിരിക്കുന്ന ഡിപ്പൻഡൻസി: നിങ്ങളുടെ നിയന്ത്രണത്തിൽ ഇല്ലാത്ത ഒരു സേവനം ആശ്രയിച്ചാൽ, സ്റ്റബ് നൽകാൻ ആവശ്യപ്പെടുക. ഫെയ്ക്കുകൾ പിടിക്കൂ.
നിങ്ങളുടെ പ്രോംപ്റ്റ് ചെക്ക്ലിസ്റ്റ് (നിങ്ങളുടെ കംപ്യൂട്ടറിനടുത്തു ഒട്ടിക്കുക)
- ഭാഷയും റൺടൈം പതിപ്പും പിന് നിർവചിച്ചു
- ലൈബ്രറി പതിപ്പുകൾ പിന് നിർവചിച്ചു
- പിശക് മാനേജ്മെന്റ് നിർവചിച്ചു (കോഡുകൾ, രൂപങ്ങൾ)
- ആദ്യം ടെസ്റ്റുകൾ, പിന്നെ കോഡ്
- സുരക്ഷ വ്യവസ്ഥകൾ വ്യക്തമായി നിർവചിച്ചു
- പെർഫോമൻസ് ബഡ്ജറ്റ് വ്യക്തമാക്കി
- സ്റ്റൈൽ, ഘടന നിർദ്ദിഷ്ടമാക്കി
- ഔട്ട്പുട്ട് ഫോർമാറ്റ് നിയന്ത്രിച്ചു (ഫയൽനേമുകൾ, കോഡ് ബ്ലോക്കുകൾ, ഡിഫുകൾ)
- ടെക്സ്റ്റുകളോടെയുള്ള ചെറിയ പരിഷ്ക്കരണ ലൂപ്പ്
ഈ മുഴുവൻ പത്തു ഘടകങ്ങളും പാലിച്ചാൽ, Claude Haiku 4.5 സാധാരണയായി സൂര്യപ്രകാശത്തെയും രക്ഷപെട്ട് കൃത്യമായ കോഡ് ജനറേറ്റ് ചെയ്യും.
ഒരു പ്രവർത്തിത ഉദാഹരണം: अस्पष्टത്തിൽ നിന്ന് സ്ഥിരീകരിതത്തിലേക്ക്
അസ്പഷ്ട പ്രോംപ്റ്റ്: “സുരക്ഷിതമായി CSV പാഴ്സ് ചെയ്യുന്ന ഫങ്ഷൻ എഴുതുക.”
ഫലം: സാധ്യതയുള്ളത് ശരിയാണ്, സാധ്യതയുള്ളത് തെറ്റ്, ഉറപ്പുള്ളത് ടെസ്റ്റുചെയ്തിട്ടില്ല.
നിശ്ചിത പ്രോംപ്റ്റ്:
“നീ Python 3.12-ൽ എഴുതുന്നു. filenames ഉള്ള കോഡ് ബ്ലോക്കുകൾ മാത്രം ഔട്ട്പുട്ട് ചെയ്യുക.
csvsafe/init.py, csvsafe/reader.py എന്നിവയിൽ read_rows(path: Path) -> list[dict[str,str]] ഫങ്ഷൻ ഉണ്ടാക്കുക. ആവശ്യങ്ങൾ: csv.DictReader ഉപയോഗിക്കുക, newline='' encoding='utf-8' വയ്ക്കുക; നൾ ബൈറ്റുകൾ അനുവദിക്കരുത്; 10MB-ൽ മുകളിൽ ഫയലുകൾ നിരസിക്കുക; കോളം എണ്ണം 100-ൽ പരിധിയിടുക; BOM നീക്കം ചെയ്യുക; ശൂന്യ സെല്ലുകൾ ശൂന്യ സ്ട്രിംഗുകളായി കൈകാര്യം ചെയ്യുക; തെറ്റുകൾ ValueError ഉം സവിശേഷ സന്ദേശ കോഡുകളുമായായി ഉയർത്തുക {FILE_TOO_LARGE, NULL_BYTE, TOO_MANY_COLUMNS}. pytest ഉപയോഗിച്ച് tests/test_reader.py-ൽ ഹാപ്പി പാത്ത്, നൾ ബൈറ്റ്, 11MB ഫയൽ, 101 കോളം, BOM കൈകാര്യം എന്നിവ ടെസ്റ്റുകൾ നൽകുക. pyproject.toml പിനോടുകൂടിയ ഡിപ്പൻഡൻസികൾ നിരൂപണവും black config ഉൾപ്പെടുത്തുക.”
നിങ്ങൾക്ക് കോഡ്, ടെസ്റ്റുകൾ, എഡ്ജ് ക്യാച്ചിങ്ങ് എല്ലാം ലഭിക്കും. പിന്നീട് ടെസ്റ്റുകൾ ഓടിച്ച് പിശകുകൾ പകർത്തി കുറവുള്ള ഡിഫുകൾ ഉപയോഗിച്ച് ആവർത്തിച്ച് പുരോഗതി ഉണ്ടാക്കാം. അതാണ് യഥാർത്ഥത്തിൽ കൃത്യമായ കോഡ് ജനറേഷൻ.
“സൃഷ്ടിപരമായത്” പോലുള്ള മാർക്കറ്റിംഗ് വാക്കുകളും മറ്റ് വാക്കുകളും
എനിക്ക് “സൃഷ്ടിപരമായ” കോഡ് വേണ്ട. എനിക്ക് ശരിയുള്ള കോഡ് വേണം. സൃഷ്ടിപരത്വം നിങ്ങളുടെ പൂച്ചയ്ക്ക് പേരിടുന്നതിനായിരിക്കും. Claude-നായി പ്രോംപ്റ്റിങ് സമയത്ത്, ശരിയായ നിയന്ത്രണങ്ങൾ കൊണ്ട് സ്വാഭാവികമായി സൃഷ്ടിപരത്വം ഉണ്ടാകും. ശരിയായ ടെസ്റ്റുകളും വ്യക്തമായ സ്പെസ്സുകളും സൂക്തമാക്കിയ പരിഹാരങ്ങൾ നൽകും. തെറ്റായ പ്രോംപ്റ്റ് “ഇമോജികളോട് പുനരാവിഷ്ക്കৃত ബേസ്64” പോലെയുള്ള ഫലമാണ്. അതിനെ പ്രാപ്തമാക്കരുത്.
അറിയപ്പെടാത്ത രഹസ്യം
Claude Haiku 4.5-ന് കൃത്യമായ കോഡ് ജനറേഷനായി പ്രോംപ്റ്റ് നൽകാനുള്ള വഴി സാദാരണമാണ്: നിങ്ങളുടെ ആവശ്യങ്ങൾ എഴുതുക, പതിപ്പുകൾ pin ചെയ്യുക, സ്കീമകൾ നിർവചിക്കുക, ടെസ്റ്റുകൾ ആവശ്യപ്പെടുക, യഥാർത്ഥ പരാജയം ഉൾപ്പെടുത്തി ആവർത്തിക്കുക. അത്ര മാത്രം. യാതൊരു മായാജാലവും ഇല്ല. ഒരൊരു എംഎൽ മോഡലും മാറ്റിയകഴിയാത്ത എഞ്ചിനീയറിംഗ് കഠിനാധ്വാനം മാത്രം.
അതും ഒരു കോടതിയിലെ തിരിഞ്ഞു കാണിച്ചുള്ള ടെസ്റ്റെന്റ് ചോദ്യോത്തരം പോലെയാണ്: കൃത്യമായ കോഡ്, കൃത്യമായ പ്രോംപ്റ്റുകളും. മോഡൽ ഒരു ജൂനിയർ എഞ്ചിനീയറായിരിക്കും, വ്യക്തമാക്കിയ ആവശ്യങ്ങൾക്കാണ് ഏർപ്പെടുന്നത്, ഒഴിഞ്ഞ നിർദ്ദേശങ്ങൾക്കല്ല. കരാർ നൽകൂ. ടെസ്റ്റുകൾ കടത്തിക്കാണിക്കൂ. പിന്നെ അവനെ വിശ്വസിക്കാം. ഒരു പ്രവചനകാരനായി അല്ല, ഒരു ഉപകരണമായി.
സംഗ്രഹം: സാദ്ധ്യം കുറച്ച്, വാറണ്ടി കൂടുതലായി
മാജിക്ക് വേണമെങ്കിൽ മാജിക് ഷോവിലേക്ക് പോവുക. compile ചെയ്യുകയും പ്രവർത്തിക്കുകയും ചെയ്യുന്ന സോഫ്റ്റ്വെയർ വേണെങ്കിൽ വാറന്റി പോലെയുള്ള പ്രോംപ്റ്റുകൾ എഴുതുക. Claude Haiku 4.5-ന് കൃത്യമായ കോഡ് ജനറേറ്റു ചെയ്യാൻ സുഖപ്രദമായ ഫ്ലോവരി പദവാക്യങ്ങളും രഹസ്യ കീവർഡുകളും വേണ്ട. നിയന്ത്രണങ്ങൾ, ടെസ്റ്റുകൾ, പതിപ്പുകൾ, ഫീഡ്ബാക്ക് ലൂപ്പുകൾ വേണം. ആ നാലു കാര്യങ്ങൾ ചെയ്യുക; പ്രവർത്തിക്കുന്ന കോഡ് ലഭിക്കും. അവ ഒഴിവാക്കിയാൽ നിങ്ങള് എഴുതിയ കാഴ്ച അലങ്കൃതവും കെട്ടിപ്പടുക്കപ്പെട്ട കഥയായിരിക്കും.
കോഡിന് നിങ്ങളുടെ വികാരങ്ങളെക്കുറിച്ച് താൽപ്പര്യമില്ല. ഭാഗ്യവശാൽ, ടെസ്റ്റുകൾക്കും താൽപ്പര്യമില്ല.
പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾ (FAQ)
Q1: കൃത്യമായ കോഡ് generation-ന് Claude Haiku 4.5-നെ എങ്ങനെ ലളിതമായി പ്രോംപ്റ്റ് ചെയ്യാം?
ഇതിനെ ഒരു കരാറായി കണക്കാക്കുക: പതിപ്പുകൾ ഉറപ്പിക്കുക (pin versions), സ്കീമകൾ നിർവചിക്കുക, പിഴവുകളുടെ ഫോർമാറ്റുകൾ വ്യക്തമാക്കുക, ആദ്യം ടെസ്റ്റുകൾ ആവശ്യപ്പെടുക. പരിമിതികൾ എത്രത്തോളം വ്യക്തമാക്കുന്നോ അത്രത്തോളം കോഡ് കൃത്യമായിരിക്കും.
Q2: Claude കോഡ് എഴുതുമ്പോൾ ഉണ്ടാകുന്ന മിഥ്യാബോധം (hallucinations) എങ്ങനെ കുറയ്ക്കാം?
വിശ്വസനീയമായ ഡോക്യുമെന്റേഷനുകളോ സ്പെസിഫിക്കേഷനുകളോ നൽകുക, കൃത്യമായ API-കൾ പാലിക്കാൻ ആവശ്യപ്പെടുക. സ്വകാര്യ എൻഡ്പോയിന്റുകൾക്കായി (private endpoints), നിങ്ങളുടെ സ്വന്തം സ്പെസിഫിക്കേഷൻ ഉൾപ്പെടുത്തുക - അത് ഊഹിക്കുമെന്ന് പ്രതീക്ഷിക്കരുത്.
Q3: Claude-നോട് ടെസ്റ്റുകൾ ചോദിക്കണോ അതോ സ്വയം എഴുതണോ?
ആദ്യം ടെസ്റ്റുകൾ നിർമ്മിക്കാൻ Claude-നോട് ആവശ്യപ്പെടുക, തുടർന്ന് അവ തൃപ്തിപ്പെടുത്തുന്ന കോഡ് നടപ്പിലാക്കുക. വിശേഷണങ്ങളെക്കാൾ നന്നായി ടെസ്റ്റുകൾ കൃത്യത നിർവചിക്കുകയും മോഡലിനെ സത്യസന്ധമായി നിലനിർത്തുകയും ചെയ്യുന്നു.
Q4: പ്രോംപ്റ്റുകളിൽ version pinning എത്രത്തോളം കൃത്യമായിരിക്കണം?
വളരെ കൃത്യമായിരിക്കണം: language runtime, framework major/minor, SDK പതിപ്പുകൾ എന്നിവയെല്ലാം. “Latest” എന്നത് പരസ്പരവിരുദ്ധമായ രീതികളെ ക്ഷണിക്കുന്നു; കൃത്യത സ്ഥിരമായ ലക്ഷ്യങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു.
Q5: കൃത്യമായ കോഡിനായുള്ള പ്രോംപ്റ്റിംഗിൽ Sider.AI-യുടെ പങ്ക് എന്താണ്?
Sider.AI ഉപയോഗിച്ച് സ്പെസിഫിക്കേഷനുകൾ, കോഡ്, ഡിഫുകൾ, ടെസ്റ്റ് ലോഗുകൾ എന്നിവ ഒരേ ലൂപ്പിൽ സൂക്ഷിക്കുക. ഇത് മാന്ത്രികമൊന്നും ചെയ്യുന്നില്ല - Claude-യുടെ തിരുത്തലുകൾ നിങ്ങളുടെ യഥാർത്ഥ പരാജയങ്ങളെ പിന്തുടരുന്നതിന് ആവശ്യമായ സാഹചര്യം ഇത് സംരക്ഷിക്കുന്നു എന്ന് മാത്രം. 
