ഡീബഗ്ഗിംഗും മൂലകാരണ വിശകലനവും

നേട്ടങ്ങൾ:

• ഒരു ബഗിനെ പുനരുൽപ്പാദിപ്പിക്കാവുന്ന ഏറ്റവും ചെറിയ സംഭവത്തിലേക്ക് കുറയ്ക്കാനും പൂർണ്ണ തെളിവോടെ AI ലേക്ക് നീക്കാനുമുള്ള കഴിവ്
• ഏറ്റവും വിലകുറഞ്ഞ നിയന്ത്രണം ഉപയോഗിച്ച് തെളിവുകൾ അടിസ്ഥാനമാക്കിയുള്ള അനുമാനങ്ങൾ പരീക്ഷിക്കാനും മൂലകാരണം കണ്ടെത്താനുമുള്ള കഴിവ്
• മൂലകാരണം പരിഹരിക്കാനുള്ള കഴിവ്, ലക്ഷണം പാച്ച് ചെയ്യുന്നതിനുപകരം ഒരു റിഗ്രഷൻ ടെസ്റ്റ് ഉപയോഗിച്ച് സുരക്ഷിതമാക്കുക

ഒരു സോഫ്റ്റ്‌വെയർ അപ്രതീക്ഷിതമായി പ്രവർത്തിക്കുന്നത് എന്തുകൊണ്ടാണെന്ന് കണ്ടെത്തി അത് പരിഹരിക്കുന്ന പ്രക്രിയയാണ് ഡീബഗ്ഗിംഗ്. ഒരു ഡെവലപ്പർ ഏറ്റവും കൂടുതൽ സമയം ചെലവഴിക്കുകയും ഏറ്റവും ക്ഷീണിതനാകുകയും ചെയ്യുന്ന ജോലിയാണിത്; കാരണം, മിക്കപ്പോഴും തെറ്റ് ദൃശ്യമാകുന്നിടത്തല്ല, മറിച്ച് കുറച്ച് ചുവടുകൾ പിന്നിൽ മറഞ്ഞിരിക്കുന്നു. AI ഈ ഗവേഷണത്തെ ത്വരിതപ്പെടുത്തുന്ന ഒരു ചിന്താശക്തിയുള്ള പങ്കാളിയാണ് - എന്നാൽ നിങ്ങൾ അതിന് ശരിയായ തെളിവുകൾ നൽകിയാൽ മാത്രം. AI ഏറ്റവും കൂടുതൽ ഹാലുസിനേഷനുകൾ ഉണ്ടാക്കുന്ന മേഖലയാണ് തെളിവുകളില്ലാതെ ഡീബഗ്ഗിംഗ് ചെയ്യുന്നത്.

ഈ യൂണിറ്റിൽ, പിശക് സൃഷ്ടിക്കുന്നത് മുതൽ മൂലകാരണത്തിലെത്തുന്നത് വരെ ഞങ്ങൾ ഒരു അച്ചടക്കത്തോടെയുള്ള ഒരു ഒഴുക്ക് സ്ഥാപിക്കുന്നു: ലക്ഷണം വ്യക്തമാക്കൽ, തെളിവ് ശേഖരിക്കൽ (പിശക് സന്ദേശം, സ്റ്റാക്ക് ട്രെയ്സ്, ലോഗ്, എൻട്രി), ഒരു സിദ്ധാന്തം സൃഷ്ടിക്കൽ, അനുമാനം പരിശോധിക്കൽ, പരിഹരിക്കൽ സാധൂകരിക്കൽ. AI ഓരോ ഘട്ടത്തിലും സഹായിക്കുന്നു; എന്നാൽ ബഗ് യഥാർത്ഥത്തിൽ ഇല്ലാതായി എന്ന് കണ്ടാണ് "നിശ്ചിത" തീരുമാനം എടുക്കുന്നത്.

എന്തുകൊണ്ടാണ് തെളിവുകൾ എല്ലാം?

നിങ്ങൾ ചെയ്യുന്നതുപോലെ ഒരു LLM പിശക് കാണുന്നില്ല; നിങ്ങൾ അവനോട് എന്താണ് പറയുന്നതെന്ന് അവന് മാത്രമേ അറിയൂ. "ആപ്ലിക്കേഷൻ ക്രാഷുകൾ" പോലെയുള്ള ഒരു വാചകം മോഡലിന് മിക്കവാറും വിവരങ്ങളൊന്നും നൽകുന്നില്ല, കൂടാതെ മോഡൽ ഒരു പ്രവചനത്തിലൂടെ വിടവ് നികത്തുന്നു - അതായത്, ഒരു ഭ്രമാത്മകത. അതാകട്ടെ, പൂർണ്ണമായ പിശക് സന്ദേശം, സ്റ്റാക്ക് ട്രെയ്‌സ് - ഏത് ഫംഗ്‌ഷൻ്റെ ഒരു തകരാർ സംഭവിച്ച പിശക്, പിശക് ട്രിഗർ ചെയ്‌ത ഇൻപുട്ട്, എന്താണ് പ്രതീക്ഷിച്ചത് മുതലായവ. നിരീക്ഷിച്ച പെരുമാറ്റം അനുസരിച്ച്, മോഡലിന് യഥാർത്ഥ സാധ്യതകളെ റാങ്ക് ചെയ്യാൻ കഴിയും.

ഡീബഗ്ഗിംഗിൽ, ഒരു ഡിറ്റക്ടീവിൻ്റെ സഹായിയായി AI-യെ കരുതുക: നിങ്ങൾ കൂടുതൽ തെളിവുകൾ അവതരിപ്പിക്കുമ്പോൾ, അത് സൃഷ്ടിക്കുന്ന അനുമാനം കൂടുതൽ കൃത്യതയുള്ളതാണ്. തെളിവുകളൊന്നുമില്ലെങ്കിൽ, അസിസ്റ്റൻ്റ് ഊഹിക്കുക മാത്രമേ ചെയ്യൂ, നിങ്ങളെ തെറ്റായ പാതയിലേക്ക് നയിച്ചേക്കാം.

നുറുങ്ങ്: ഒരു ബഗ് AI-ലേക്ക് പോർട്ട് ചെയ്യുന്നതിന് മുമ്പ്, അത് പുനർനിർമ്മിക്കാവുന്ന ഏറ്റവും ചെറിയ ഉദാഹരണത്തിലേക്ക് ചുരുക്കുക. പിശക് ട്രിഗർ ചെയ്യുന്ന ഏറ്റവും ചെറിയ കോഡും ഇൻപുട്ടും നിങ്ങൾക്കും മോഡലിനും കാര്യങ്ങൾ സമൂലമായി എളുപ്പമാക്കുന്നു; മിക്കപ്പോഴും ഈ കുറയ്ക്കൽ സമയത്ത് നിങ്ങൾ സ്വയം കാരണം കണ്ടെത്തുന്നു.

ഘട്ടം ഘട്ടമായി: റൂട്ട് കോസ് അനാലിസിസ് ഫ്ലോ

1. ലക്ഷണം വ്യക്തമാക്കുക. "എന്താണ് സംഭവിക്കുന്നത്, എന്താണ് സംഭവിക്കുമെന്ന് നിങ്ങൾ പ്രതീക്ഷിച്ചത്?" രണ്ടും ഒരു വാചകത്തിൽ എഴുതുക.
2. തെളിവുകൾ ശേഖരിക്കുക. പൂർണ്ണമായ പിശക് സന്ദേശം, സ്റ്റാക്ക് ട്രെയ്സ്, പ്രസക്തമായ ലോഗ് ലൈനുകൾ, ട്രിഗറിംഗ് എൻട്രി, പതിപ്പ് വിവരങ്ങൾ.
3. സിദ്ധാന്തം സൃഷ്ടിക്കുക. AI-ൽ നിന്ന് "ഈ ലക്ഷണത്തെ വിശദീകരിക്കുന്ന 3 സാധ്യമായ കാരണങ്ങൾ, ഓരോന്നിനും ഞാൻ എങ്ങനെ പരിശോധിക്കും?" ചോദിക്കുക.
4. വിലകുറഞ്ഞ സിദ്ധാന്തം ആദ്യം പരിശോധിക്കുക. ഒരു ലോഗ് ചേർക്കുക, ഒരു മൂല്യം പ്രിൻ്റ് ചെയ്യുക, ഒരു ടെസ്റ്റ് പ്രവർത്തിപ്പിക്കുക. തെളിവുകൾ അനുമാനത്തെ സ്ഥിരീകരിക്കുന്നുണ്ടോ?
5. രോഗലക്ഷണമല്ല, മൂലകാരണം പരിഹരിക്കുക. ഒരു പാച്ച് ഉപയോഗിച്ച് ലക്ഷണത്തെ നിശബ്ദമാക്കുന്നതിന് പകരം, മൂലകാരണം പരിഹരിക്കുക.
6. റിഗ്രഷൻ ടെസ്റ്റിംഗ് സാധൂകരിക്കുകയും ചേർക്കുകയും ചെയ്യുക. പിശക് അപ്രത്യക്ഷമാകുന്നത് കാണുക; എന്നിട്ട് ആ പിശക് പിടിക്കുന്ന ഒരു ടെസ്റ്റ് എഴുതുക, അങ്ങനെ അത് തിരികെ വരില്ല.

മൂന്ന് മിനി കേസുകൾ

കേസ് 1 - സ്റ്റാക്ക് ട്രെയ്സ് ശരിയായ ഫയലിലേക്ക് നയിച്ചു. ചില അഭ്യർത്ഥനകളിൽ ഒരു അപ്ലിക്കേഷൻ 500 പിശക് നൽകുന്നു. ഡെവലപ്പർ AI-ക്ക് മുഴുവൻ സ്റ്റാക്ക് ട്രെയ്‌സും ട്രിഗറിംഗ് അഭ്യർത്ഥനയും നൽകി; ഒരു തീയതി പാഴ്‌സിംഗ് ലെയറിലെ None മൂല്യമാണ് പിശകിന് കാരണമായതെന്ന് മോഡൽ അനുമാനിക്കുന്നു. ഡെവലപ്പർ ആ വരിയിലേക്ക് ഒരു ലോഗ് ചേർത്തു, അത് പരിശോധിച്ച് 15 മിനിറ്റിനുള്ളിൽ അത് പരിഹരിച്ചു; തെളിയിക്കപ്പെടാത്ത പരീക്ഷണങ്ങളുമായി കഴിഞ്ഞ ദിവസം 2 മണിക്കൂർ പാഴായി.

കേസ് 2 - ഹാലൂസിനേഷൻ തെറ്റായ ട്രാക്കിലേക്ക് നയിച്ചു. മറ്റൊരു ഡെവലപ്പർ "ഡാറ്റാബേസ് കണക്ഷൻ കുറയുന്നു" എന്ന് എഴുതി. യാതൊരു തെളിവുമില്ലാതെ ഒരു കണക്ഷൻ പൂൾ ക്രമീകരണം AI ആരോപിച്ചു; ഡവലപ്പർ ഈ ക്രമീകരണത്തിൽ 40 മിനിറ്റ് ചെലവഴിച്ചു. നെറ്റ്‌വർക്ക് വശത്ത് കാലഹരണപ്പെട്ടതാണ് യഥാർത്ഥ കാരണം, ലോഗുകൾ നോക്കിയാൽ മാത്രമേ അത് വെളിപ്പെടുത്തൂ. പാഠം: തെളിവുകളില്ലാതെ എടുത്ത ഒരു സിദ്ധാന്തം സാധ്യതയുള്ളതാണ്, വിശ്വസനീയമല്ല.

കേസ് 3 - ഫ്ലേക്കി പിശക് പിടികൂടി. ഇടയ്ക്കിടെ പരാജയപ്പെടുന്ന ഒരു പരീക്ഷ ഉണ്ടായിരുന്നു. AI-ക്ക് ടെസ്റ്റ് കോഡും പരാജയ സന്ദേശവും "ചിലപ്പോൾ അത് കടന്നുപോകും, ​​ചിലപ്പോൾ പരാജയപ്പെടും" എന്ന വിവരവും നൽകി; മോഡൽ ടെസ്റ്റുകളുടെ പങ്കിട്ട സമയം/ഓർഡർ ആശ്രിതത്വം സൂചിപ്പിച്ചു. സിസ്റ്റത്തിൻ്റെ പ്രാദേശിക സമയം അടിസ്ഥാനമാക്കിയാണ് പരിശോധനയെന്ന് അവലോകനം സ്ഥിരീകരിച്ചു. ക്ലോക്ക് നിശ്ചയിച്ചുകഴിഞ്ഞാൽ (പരിഹസിച്ചു), പരിശോധന സ്ഥിരമായി.

പകർത്താവുന്ന നാല് ടെംപ്ലേറ്റുകൾ

തെളിവ് അടിസ്ഥാനമാക്കിയുള്ള സിദ്ധാന്തം സൃഷ്ടിക്കൽ:

ഞാൻ ഒരു ബഗ് ഡീബഗ്ഗ് ചെയ്യുകയാണ്. തെളിവുകൾ ചുവടെ.- പ്രതീക്ഷിക്കുന്ന പെരുമാറ്റം: {{പ്രതീക്ഷിച്ച}}- നിരീക്ഷിച്ച പെരുമാറ്റം: {{നിരീക്ഷിച്ച}}- പിശക് സന്ദേശം / സ്റ്റാക്ക് ട്രെയ്സ്: {{trace}}- ട്രിഗർ ചെയ്യുന്ന ഇൻപുട്ട്: {{input}}- പരിസ്ഥിതി/പതിപ്പ്: {{version}}ഈ ലക്ഷണത്തെ വിശദീകരിക്കുന്ന 3 ഏറ്റവും സമാനമായ മൂലകാരണങ്ങൾ ലിസ്റ്റ് ചെയ്യുക. ഓരോന്നിനും: ഞാൻ എങ്ങനെ പരിശോധിക്കും (വിലകുറഞ്ഞ പരിശോധന) അത് ശരിയാണെങ്കിൽ അത് എങ്ങനെ പരിഹരിക്കും. തെളിവുകൾ അപര്യാപ്തമാണെങ്കിൽ, നിങ്ങൾക്ക് എന്ത് അധിക വിവരമാണ് വേണ്ടതെന്ന് എന്നോട് പറയുക.

സ്റ്റാക്ക് ട്രെയ്സ് വ്യാഖ്യാനിക്കുന്നു:

ഈ സ്റ്റാക്ക് ട്രെയ്സ് വായിക്കുക. ഏത് വരിയിൽ പിശക് ആരംഭിക്കുന്നത് (റൂട്ട്) ആയിരിക്കുമെന്നും ഏത് വരികൾ ശൃംഖലയുടെ തുടർച്ചകളാണെന്നും വേർതിരിക്കുക. ആദ്യം നോക്കാൻ 1-2 സ്ഥലങ്ങൾ നിർദ്ദേശിക്കുക. അനുബന്ധ കോഡ്:{{code}}ട്രേസ്:{{trace}}

ഏറ്റവും കുറഞ്ഞ റിപ്രോ കുറയ്ക്കൽ:

ചുവടെയുള്ള കോഡ് ഒരു പിശക് സൃഷ്ടിക്കുന്നു. ഇപ്പോഴും പിശക് ട്രിഗർ ചെയ്യുന്നതും എന്നാൽ അനാവശ്യമായ എന്തും നിരസിക്കുന്നതുമായ ഏറ്റവും ചെറിയ സംഭവത്തിലേക്ക് അതിനെ ചുരുക്കുക. നിങ്ങൾ നീക്കം ചെയ്യുന്ന ഓരോ ഭാഗവും പിശകിനെ ബാധിക്കില്ലെന്ന് കരുതരുത്, എന്നാൽ "നിങ്ങൾ ഇത് നീക്കം ചെയ്യുമ്പോൾ പിശക് അപ്രത്യക്ഷമായാൽ, അതിനാലാണ്" എന്ന് ഒരു കുറിപ്പ് ചേർക്കുക.{{code}}

തിരുത്തലിനു ശേഷമുള്ള മൂല്യനിർണ്ണയവും റിഗ്രഷൻ പരിശോധനയും:

മൂലകാരണം {{കാരണം}} ആണെന്ന് കരുതുക, ഞാൻ ഇനിപ്പറയുന്ന പരിഹാരം ചെയ്യുന്നു: {{fix}}.1) ഈ പരിഹാരം യഥാർത്ഥത്തിൽ രോഗലക്ഷണത്തെ പരിഹരിക്കുന്നുണ്ടോ, ഇതിന് എന്തെങ്കിലും പാർശ്വഫലങ്ങൾ ഉണ്ടാകുമോ?2) ഭാവിയിൽ ഈ ബഗ് പിടിപെടുന്ന ഒരു റിഗ്രഷൻ ടെസ്റ്റ് എഴുതുക.

ദുർബലമായ പ്രോംപ്റ്റ് / ശക്തമായ പ്രോംപ്റ്റ്

ദുർബലമായത്: "കോഡ് പ്രവർത്തിക്കുന്നില്ല, എന്തുകൊണ്ട്?"

ശക്തമായത്: "നോഡ് 20 / എക്സ്പ്രസ്. POST /ഓർഡറുകൾ ശരീരത്തിൽ ഒരു ശൂന്യമായ സ്ട്രിംഗ് ആയിരിക്കുമ്പോൾ 500 നൽകുന്നു; 400 തിരികെ നൽകണം. സ്റ്റാക്ക് ട്രെയ്സ്: ടൈപ്പ് പിശക്: നിർവചിക്കാത്തതിൻ്റെ പ്രോപ്പർട്ടികൾ വായിക്കാൻ കഴിയില്ല ('0' വായിക്കുന്നു) — പൂർണ്ണമായ ട്രെയ്സും അനുബന്ധ ഹാൻഡ്ലറും അറ്റാച്ച് ചെയ്തിട്ടുണ്ട്. കോഡ്]"

ശക്തമായ പതിപ്പ്; ഇത് പരിസ്ഥിതി, അവസാന പോയിൻ്റ്, ട്രിഗർ ഇൻപുട്ട്, കൃത്യമായ പിശക് തരം, പ്രതീക്ഷിക്കുന്ന സ്വഭാവം എന്നിവ നൽകുന്നു. മോഡലിന് ഇനി പ്രവചനങ്ങൾ നടത്താൻ കഴിയില്ല, പക്ഷേ വിശകലനം.

പടി

AI യുടെ സംഭാവന

നിങ്ങളുടെ നിയന്ത്രണം

തെളിവുകൾ ശേഖരിക്കുന്നു

എന്ത് തെളിവാണ് വേണ്ടത്, ഓർമ്മിപ്പിക്കുന്നു

ശരിക്കും തെളിവുകൾ ശേഖരിക്കുന്നു

അനുമാന തലമുറ

സാധ്യമായ കാരണങ്ങൾ പട്ടികപ്പെടുത്തുക

സന്ദർഭത്തിനനുസരിച്ച് മുൻഗണന നൽകുന്നു

അനുമാന പരിശോധന

ടെസ്റ്റ് രീതി ശുപാർശ ചെയ്യുന്നു

വ്യക്തിപരമായി പ്രവർത്തിക്കുകയും നിരീക്ഷിക്കുകയും ചെയ്യുന്നു

തിരുത്തൽ

പാച്ച് ശുപാർശ ചെയ്യുന്നു

ഇത് മൂലകാരണം പരിഹരിക്കുമോ? ഇത് സത്യമാണ്.

റിഗ്രഷൻ

ഒരു പരീക്ഷ എഴുതുന്നു

പരിശോധന തകർന്നുവെന്ന് സ്ഥിരീകരിക്കുന്നു

രോഗലക്ഷണമല്ല, മൂലകാരണം പരിഹരിക്കുന്നു

മിക്ക സമയത്തും AI രോഗലക്ഷണത്തെ പെട്ടെന്ന് നിശ്ശബ്ദമാക്കുന്ന ഒരു പാച്ച് നിർദ്ദേശിക്കും: ഒരു ശ്രമം/ക്യാച്ച് ചേർക്കുക, ഒരു ശൂന്യ പരിശോധന നടത്തുക, പിശക് വിഴുങ്ങുക. ഇത് ചിലപ്പോൾ ശരിയാണ്, പലപ്പോഴും അപകടകരമാണ്; കാരണം യഥാർത്ഥ കാരണം അതേപടി നിലനിൽക്കുകയും മറ്റൊരിടത്ത് നിന്ന് വീണ്ടും പൊട്ടിത്തെറിക്കുകയും ചെയ്യുന്നു. ഓരോ പരിഹാരത്തിലും, സ്വയം ചോദിക്കുക: "ഇത് പിശകിൻ്റെ കാരണം പരിഹരിക്കുമോ, അതോ അത് അദൃശ്യമാക്കുമോ?" നിങ്ങൾ മൂലകാരണം കണ്ടെത്തിക്കഴിഞ്ഞാൽ, പരിഹാരം സാധാരണയായി ചെറുതും കൂടുതൽ ശക്തവും ശാശ്വതവുമാണ്.

മുന്നറിയിപ്പ്: ഒരു അപവാദം നിശബ്ദമായി വിഴുങ്ങുന്നത് (ശൂന്യമായ ക്യാച്ച്) പിശക് പരിഹരിക്കില്ല; അത് കേവലം മറച്ചുവെക്കുകയും ഭാവിയിലെ രോഗനിർണയം അസാധ്യമാക്കുകയും ചെയ്യുന്നു. AI അത്തരമൊരു "പരിഹാരം" നിർദ്ദേശിക്കുകയാണെങ്കിൽ, മൂലകാരണം ചോദ്യം ചെയ്യാതെ അത് സ്വീകരിക്കരുത്.

സാധാരണ തെറ്റുകൾ

• തെളിവില്ലാതെ ചോദ്യങ്ങൾ ചോദിക്കുന്നു. അവ്യക്തമായ വാക്യങ്ങൾ മോഡലിനെ ഭ്രമാത്മകതയിലേക്ക് തള്ളിവിടുന്നു; പൂർണ്ണ പിശക്, ട്രെയ്സ്, ഇൻപുട്ട് എന്നിവ നൽകുക.
• ആദ്യ സിദ്ധാന്തം പൂട്ടിയിടുന്നു. AI-യുടെ ആദ്യ നിർദ്ദേശം ഏറ്റവും സാധ്യതയുള്ളതായിരിക്കില്ല; വിലകുറഞ്ഞ നിയന്ത്രിക്കാവുന്ന അനുമാനത്തിൽ നിന്ന് ആരംഭിക്കുക.
• ലക്ഷണം പാച്ച് ചെയ്യുകയും മൂലകാരണം കാണാതിരിക്കുകയും ചെയ്യുന്നു. നിശബ്‌ദമാക്കിയ പിശക് തിരികെ വരുന്നു.
• പരിശോധിച്ചുറപ്പിക്കാതെ ഫിക്സ് അടയ്ക്കുന്നു. പിശക് യഥാർത്ഥത്തിൽ അപ്രത്യക്ഷമാകുന്നത് ഉൽപ്പാദനം പോലെയുള്ള അവസ്ഥയിൽ കാണുക.
• റിഗ്രഷൻ ടെസ്റ്റുകൾ എഴുതുന്നില്ല. പരിശോധനകളൊന്നും ചേർത്തിട്ടില്ലെങ്കിൽ, അതേ പിശക് പിന്നീടുള്ള പതിപ്പുകളിൽ നിശബ്ദമായി മടങ്ങിവരും.

ചുരുക്കത്തിൽ

ഡീബഗ്ഗിംഗിൽ, AI-യുടെ ശക്തി നിങ്ങൾ നൽകുന്ന തെളിവുകൾക്ക് നേരിട്ട് ആനുപാതികമാണ്: പൂർണ്ണമായ പിശക് സന്ദേശം, സ്റ്റാക്ക് ട്രെയ്സ്, ട്രിഗറിംഗ് ഇൻപുട്ട്, പ്രതീക്ഷിക്കുന്ന പെരുമാറ്റം എന്നിവയില്ലാതെ മോഡൽ ഊഹിക്കുന്നു. അച്ചടക്കമുള്ള ഫ്ലോ-ലക്ഷണങ്ങൾ വ്യക്തമാക്കുക, തെളിവുകൾ ശേഖരിക്കുക, അനുമാനം സൃഷ്ടിക്കുക, വിലകുറഞ്ഞ നിയന്ത്രണത്തോടെ പരീക്ഷിക്കുക, മൂലകാരണം ശരിയാക്കുക, സ്ഥിരീകരിക്കുക, റിഗ്രഷൻ ടെസ്റ്റിംഗ് ചേർക്കുക - ബഗ് വേഗത്തിലും ശാശ്വതമായും അടയ്ക്കുന്നു. AI ഒരു ഹൈപ്പോതെസിസ് ജനറേറ്ററാണ്; ബഗ് യഥാർത്ഥത്തിൽ പരിഹരിച്ചുവെന്ന് തീരുമാനിക്കുന്നത് നിങ്ങളാണ്.

ആപ്ലിക്കേഷൻ ടാസ്ക്

നിങ്ങൾ അടുത്തിടെ നേരിട്ട ഒരു യഥാർത്ഥ ബഗ് തിരഞ്ഞെടുക്കുക (അല്ലെങ്കിൽ ഒരു ടെസ്റ്റ് ബഗ് പുനർനിർമ്മിക്കുക). ആദ്യം "മിനിമം റീപ്രൊഡക്ഷൻ" ഘട്ടം ചെയ്യുക; പിശക് ട്രിഗർ ചെയ്യുന്ന ഏറ്റവും ചെറിയ കോഡും ഇൻപുട്ടും നീക്കം ചെയ്യുക. "തെളിവ് അടിസ്ഥാനമാക്കിയുള്ള സിദ്ധാന്തം സൃഷ്ടിക്കൽ" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് AI-യിൽ നിന്ന് 3 സാധ്യമായ കാരണങ്ങളും ടെസ്റ്റിംഗ് രീതികളും നേടുക. വിലകുറഞ്ഞ സിദ്ധാന്തം സ്വയം പരീക്ഷിക്കുക, മൂലകാരണം കണ്ടെത്തുക, അത് പരിഹരിക്കുക, ഒടുവിൽ ഒരു റിഗ്രഷൻ ടെസ്റ്റ് എഴുതുക, അത് ഭാവിയിൽ ഈ ബഗ് പിടിക്കുകയും പരിശോധന യഥാർത്ഥത്തിൽ തകർന്നിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുകയും ചെയ്യും.

ചെക്ക്ലിസ്റ്റ്

• [ ] ഞാൻ പിശക് AI ലേക്ക് നീക്കുന്നതിന് മുമ്പ് ഏറ്റവും ചെറിയ പുനരുൽപ്പാദിപ്പിക്കാവുന്ന സാമ്പിളിലേക്ക് ചുരുക്കുന്നു.
• [ ] ഞാൻ പ്രോംപ്റ്റിലേക്ക് പൂർണ്ണ പിശക് സന്ദേശം, സ്റ്റാക്ക് ട്രെയ്സ്, ഇൻപുട്ട്, പ്രതീക്ഷിക്കുന്ന സ്വഭാവം എന്നിവ ചേർക്കുന്നു.
• [ ] ഞാൻ ഒരു അനുമാനത്തിൽ പൂട്ടിയിടാതെ, വിലകുറഞ്ഞ നിയന്ത്രിക്കാവുന്ന ഒന്നിൽ നിന്ന് ആരംഭിക്കുന്നു.
• [ ] രോഗലക്ഷണം പരിഹരിക്കുന്നതിനുപകരം മൂലകാരണം ഞാൻ പരിഹരിച്ചുവെന്ന് ഞാൻ സ്ഥിരീകരിക്കുന്നു.
• [ ] തിരുത്തൽ യഥാർത്ഥത്തിൽ ബഗ് പരിഹരിക്കുന്നതായി ഞാൻ നിരീക്ഷിക്കുന്നു.
• [ ] പരിഹരിച്ച ഓരോ ബഗിനും ഞാൻ ഒരു റിഗ്രഷൻ ടെസ്റ്റ് ചേർക്കുന്നു.