സോഫ്റ്റ്‌വെയർ ടീമുകൾക്കുള്ള ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ്: വർക്കിംഗ് മോഡലും പരിധികളും

നേട്ടങ്ങൾ:

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

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

ഈ യൂണിറ്റിൽ, ഞങ്ങൾ ആദ്യം ലളിതമായ ഭാഷയിൽ ഒരു കോഡിംഗ് അസിസ്റ്റൻ്റിൻ്റെ അടിസ്ഥാന സാങ്കേതികവിദ്യ വിശദീകരിക്കുന്നു; തുടർന്ന് ഞങ്ങൾ മോഡലിൻ്റെ ശക്തികളുടെയും ബലഹീനതകളുടെയും ഒരു മാനസിക ഭൂപടം സൃഷ്ടിക്കുന്നു; അവസാനമായി, മൊഡ്യൂളിലുടനീളം ഞങ്ങൾ ഉപയോഗിക്കുന്ന അടിസ്ഥാന പ്രവർത്തന അച്ചടക്കം ഞങ്ങൾ സ്ഥാപിക്കുന്നു: നിർദ്ദേശിക്കുക, നിർമ്മിക്കുക, സ്ഥിരീകരിക്കുക. ഈ മൂന്ന് പടികൾ അടുത്ത പതിനൊന്ന് യൂണിറ്റുകളുടെ നട്ടെല്ലാണ്.

ശ്രദ്ധിക്കുക: ഈ മൊഡ്യൂൾ ഒരു പൊതു പരിശീലനമാണ്. സുരക്ഷാ-നിർണ്ണായക സോഫ്‌റ്റ്‌വെയറിൽ (പേയ്‌മെൻ്റ് പ്രോസസ്സിംഗ്, ഹെൽത്ത്‌കെയർ, ആധികാരികത, നിർണായക ഇൻഫ്രാസ്ട്രക്ചർ) AI ഔട്ട്‌പുട്ട് ഒരു യോഗ്യതയുള്ള എഞ്ചിനീയറുടെ അവലോകനത്തിനും അംഗീകാരത്തിനും പകരമാകില്ല. AI ഒരു സഹായിയാണ്; ഒപ്പിട്ടവൻ എൻജിനീയറാണ്.

ഒരു കോഡിംഗ് അസിസ്റ്റൻ്റ് യഥാർത്ഥത്തിൽ എന്താണ് ചെയ്യുന്നത്?

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

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

ശക്തിയും ബലഹീനതയും മാപ്പ്

ശരിയായ ജോലികളിലേക്ക് AI-യെ നയിക്കാൻ, അത് എവിടെയാണ് തിളങ്ങുന്നതെന്നും എവിടെയാണ് ഇടറുന്നത് എന്നും അറിയേണ്ടത് ആവശ്യമാണ്. ഈ മാപ്പ് ഓർമ്മിക്കുന്നത് അടുത്ത ഓരോ ദൗത്യത്തിലും നിങ്ങളെ അത്ഭുതപ്പെടുത്തും, "ഞാൻ ഈ ജോലി AI-ക്ക് ഔട്ട്സോഴ്സ് ചെയ്യണോ അതോ സ്വയം ചെയ്യണോ?" നിമിഷങ്ങൾക്കുള്ളിൽ ചോദ്യത്തിന് ഉത്തരം നൽകാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

അതിൻ്റെ ശക്തികൾ ഇവയാണ്: ബോയിലർപ്ലേറ്റ് കോഡ് സൃഷ്ടിക്കൽ, ഒരു ഭാഷയിൽ നിന്ന് മറ്റൊന്നിലേക്ക് വിവർത്തനം ചെയ്യുക, ഒരു സാധാരണ പദപ്രയോഗം (regex) എഴുതുക, ഒരു ഫംഗ്ഷൻ വിവരിക്കുക, ഒരു ടെസ്റ്റ് അസ്ഥികൂടം സൃഷ്ടിക്കുക, ഒരു പിശക് സന്ദേശം വ്യാഖ്യാനിക്കുക, ഡോക്യുമെൻ്റേഷൻ തയ്യാറാക്കുക, വേരിയബിൾ/ഫംഗ്ഷൻ പേരുകൾ നിർദ്ദേശിക്കുക, മൈനർ റീഫാക്റ്ററിംഗുകൾ (കോഡിൻ്റെ സ്വഭാവം മാറ്റാതെ അതിൻ്റെ ഘടന മെച്ചപ്പെടുത്തുക).

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

ദൗത്യ തരം

AI യുടെ പങ്ക്

മനുഷ്യൻ്റെ പങ്ക്

ബോയിലർപ്ലേറ്റ്/അസ്ഥികൂടം നിർമ്മിക്കുക

ഡ്രാഫ്റ്റ് നിർമ്മിക്കുന്നു

പൊരുത്തപ്പെടുത്തലുകൾ, അവലോകനങ്ങൾ

കോഡ് വിവരണം

ഒരു ദ്രുത സംഗ്രഹം നൽകുന്നു

കോഡിലെ സുപ്രധാന ഭാഗം സ്ഥിരീകരിക്കുന്നു

എഴുത്ത് പരീക്ഷകൾ

കേസ് നിർദ്ദേശിക്കുന്നു

കവറേജും കൃത്യതയും സ്ഥിരീകരിക്കുന്നു

സുരക്ഷാ-നിർണ്ണായക യുക്തി

സഹായകരമായ ആശയം

തീരുമാനവും ഉത്തരവാദിത്തവും പൂർണ്ണമായും മനുഷ്യരിൽ നിക്ഷിപ്തമാണ്.

API/ലൈബ്രറി ഉപയോഗം

സാമ്പിൾ സൃഷ്ടിക്കുന്നു

നിലനിൽപ്പും പതിപ്പും സ്ഥിരീകരിക്കുന്നു

വാസ്തുവിദ്യാ തീരുമാനം

തരം ഓപ്ഷനുകൾ

സന്ദർഭം അറിഞ്ഞ് തിരഞ്ഞെടുത്ത് പ്രതിരോധിക്കുന്നു

ഘട്ടം ഘട്ടമായി: അടിസ്ഥാന പ്രവർത്തന ചക്രം

1. ചുമതല വ്യക്തമാക്കുക. നിങ്ങൾക്ക് ആവശ്യമുള്ളത് ഒരു വാചകത്തിൽ എഴുതാൻ കഴിയുന്നില്ലെങ്കിൽ, മോഡലിനും കഴിയില്ല. നേരത്തെയുള്ള അനിശ്ചിതത്വം ഇൻപുട്ടിലേക്ക് ഒഴുകുന്നു, അത് ഔട്ട്പുട്ടിൽ വളരും.
2. സന്ദർഭം നൽകുക. പ്രോംപ്റ്റിലേക്ക് പ്രസക്തമായ കോഡ്, പൂർണ്ണ പിശക് സന്ദേശം, ഭാഷ/ഫ്രെയിംവർക്ക് പതിപ്പ്, നിയന്ത്രണങ്ങൾ എന്നിവ ചേർക്കുക. "ഇത് പരിഹരിക്കുക" എന്ന് പറയരുത്, "Python 3.11, FastAPI 0.110; ഈ ഫംഗ്‌ഷൻ 500 പിശക് നൽകുന്നു, അഭ്യർത്ഥന ബോഡി ശൂന്യമാകുമ്പോൾ അത് പൊട്ടിത്തെറിക്കും".
3. ഇംപോസിഷൻ റോളും ഫോർമാറ്റും. "നിങ്ങൾ ഒരു മുതിർന്ന ഗോ ഡെവലപ്പറാണ്; കോഡും രണ്ട് വാക്യങ്ങളുടെ യുക്തിയും നൽകുക" എന്നതുപോലുള്ള ഒരു ചട്ടക്കൂട് ഔട്ട്‌പുട്ടിനെ കേന്ദ്രീകരിക്കുന്നു.
4. ചെറുത് ചോദിക്കുക. ഒരു ഭീമാകാരമായ അഭ്യർത്ഥനയെക്കാൾ അതിനെ ഘട്ടങ്ങളായി വിഭജിക്കുക; ഓരോ ഘട്ടവും വെവ്വേറെ പരിശോധിക്കുക. പ്രധാന മാറ്റങ്ങൾ അപകടസാധ്യതയുള്ളതാണ്, കാരണം അവ പരിശോധിക്കാൻ പ്രയാസമുള്ളതും പിശകുകൾ മറയ്ക്കാൻ സാധ്യതയുള്ളതുമാണ്.
5. സ്ഥിരീകരിക്കുക. ഇത് പ്രവർത്തിപ്പിക്കുക, പരിശോധിക്കുക, ദൃശ്യപരമായി വായിക്കുക. സ്ഥിരീകരിക്കാത്ത AI കോഡ് ഒരു "സ്കെച്ച്" ആണ്, ഒരു "സൊല്യൂഷൻ" അല്ല. സൈക്കിളിലെ ഏറ്റവും വിലമതിക്കാനാവാത്ത ഘട്ടമാണിത്.

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

കേസ് 1 - സമയ ലാഭം യഥാർത്ഥവും എന്നാൽ എളിമയുമാണ്. AI ഉപയോഗിച്ച് ഒരു ടീം പുതിയ CRUD (ക്രിയേറ്റ്-റീഡ്-അപ്‌ഡേറ്റ്-ഡിലീറ്റ്) എൻഡ്‌പോയിൻ്റുകൾ സ്‌കെലിറ്റനൈസ് ചെയ്‌തപ്പോൾ, ആദ്യത്തെ ഡ്രാഫ്റ്റ് സമയം ഏകദേശം 40 മിനിറ്റിൽ നിന്ന് 8 മിനിറ്റായി കുറഞ്ഞു. എന്നിരുന്നാലും, അവലോകനവും പരിശോധനയും ഉപയോഗിച്ച്, ആകെ സമയം 25 മിനിറ്റായിരുന്നു; അതിനാൽ യഥാർത്ഥ നേട്ടം 40 മുതൽ 25 വരെയാണ്, ഏകദേശം 38%. "ഞങ്ങൾ 10 മടങ്ങ് ത്വരിതപ്പെടുത്തി" എന്ന പ്രതീക്ഷയ്‌ക്ക് പകരം അളക്കുന്ന ഈ നിരക്ക് ഒരു സുസ്ഥിര നേട്ടമാണ്.

കേസ് 2 - ഹാലുസിനേഷൻ ചെലവേറിയതാണ്. ഒരു ഡെവലപ്പർ AI നിർദ്ദേശിച്ച requests.get_json() കോൾ മൂല്യനിർണ്ണയം കൂടാതെ ഉപയോഗിച്ചു; അത്തരമൊരു രീതി ഇല്ലായിരുന്നു (കൃത്യമായി response.json()). കോഡ് കംപൈൽ ചെയ്യാത്തപ്പോൾ 20 മിനിറ്റ് നഷ്ടമായി. ഒരു ലളിതമായ "ഈ രീതി ശരിക്കും നിലവിലുണ്ടോ?" പരിശോധന നഷ്ടം പുനഃസജ്ജമാക്കും.

കേസ് 3 - നല്ല സന്ദർഭം ഔട്ട്പുട്ട് ഇരട്ടിയാക്കുന്നു. അതേ ബഗിനായി, ഒരു ഡവലപ്പർ "എനിക്ക് ഒരു പിശക് സംഭവിക്കുന്നു" എന്ന് എഴുതി, മറ്റൊരാൾ പൂർണ്ണ സ്റ്റാക്ക് ട്രെയ്സ്, പതിപ്പ്, ഇൻപുട്ട് സാമ്പിൾ എന്നിവ ചേർത്തു. രണ്ടാമത്തേതിന് ആദ്യ ശ്രമത്തിൽ തന്നെ ശരിയായ പരിഹാരം ലഭിച്ചു; ആദ്യത്തേത് മൂന്ന് തിരിവുകൾ ചെലവഴിച്ചു. വ്യത്യാസം മോഡലിലല്ല, ഇൻപുട്ടിലാണ്.

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

ഒരു പൊതു-ഉദ്ദേശ്യ, ശക്തമായ സ്റ്റാർട്ടപ്പ് പ്രോംപ്റ്റ്:

റോൾ: നിങ്ങൾ പരിചയസമ്പന്നനായ {{language}} ഡെവലപ്പറാണ്. ടാസ്‌ക്: {{what_want}}സന്ദർഭം:- ചട്ടക്കൂട്/പതിപ്പ്: {{framework_and_version}}- നിയന്ത്രണങ്ങൾ: {{പ്രകടനം, ശൈലി, ആശ്രിതത്വ നിയമങ്ങൾ}}നിയമങ്ങൾ:- നിലവിലില്ലാത്ത ലൈബ്രറി/പ്രവർത്തനം ഉപയോഗിക്കരുത്; നിങ്ങൾക്ക് ഉറപ്പില്ലെങ്കിൽ, അത് "സ്ഥിരീകരിക്കുക" എന്ന് അടയാളപ്പെടുത്തുക. - ആദ്യം, ഒരു ചെറിയ പ്ലാൻ നൽകുക, പിന്നെ കോഡ്, പിന്നെ 2 ന്യായീകരണ വാക്യങ്ങൾ. - പരിശോധിക്കാവുന്ന, പ്രവർത്തന കോഡ് നിർമ്മിക്കുക.

അനിശ്ചിതത്വം തിരികെ മോഡലിലേക്ക് ഫിൽട്ടർ ചെയ്യാൻ:

ചുവടെയുള്ള ടാസ്‌ക് പരിഹരിക്കുന്നതിന് മുമ്പ്, നഷ്‌ടമായതോ അവ്യക്തമായതോ ആയ ചോദ്യങ്ങളായി നിങ്ങൾ കണ്ടെത്തുന്ന കുറഞ്ഞത് 3 പോയിൻ്റുകളെങ്കിലും ലിസ്റ്റ് ചെയ്യുക. ഞാൻ മറുപടി നൽകുന്നതിന് മുമ്പ് കോഡ് എഴുതരുത്. ടാസ്ക്: {{task}}

ഔട്ട്പുട്ട് സ്വയം പരിശോധിക്കുന്നതിന്:

നിങ്ങൾ ഇനിപ്പറയുന്ന കോഡ് നിർമ്മിച്ചു. ഇപ്പോൾ നിങ്ങളുടെ റോൾ മാറ്റി ഈ കോഡ് വിമർശിക്കുക:- പ്രവർത്തിക്കാത്ത 3 കേസുകൾ (എഡ്ജ് കേസുകൾ) ലിസ്റ്റ് ചെയ്യുക.- നിങ്ങൾക്ക് ഉണ്ടാക്കാൻ കഴിയുന്ന ഏതെങ്കിലും API-കൾ/പ്രവർത്തനങ്ങൾ ഉണ്ടോ? അടയാളപ്പെടുത്തുക.- തിരുത്തിയ പതിപ്പ് നൽകുക.കോഡ്:{{code}}

തീരുമാനത്തെ ഓപ്ഷനുകളായി വിഭജിക്കാൻ:

{{പ്രശ്നത്തിന്}} 2-3 പരിഹാര സമീപനങ്ങൾ നിർദ്ദേശിക്കുക. ഓരോന്നിനും: ഹ്രസ്വ വിവരണം, പ്ലസ്/മൈനസ്, എപ്പോൾ തിരഞ്ഞെടുക്കണം. പട്ടിക രൂപത്തിൽ നൽകുക. എനിക്കായി തിരഞ്ഞെടുക്കരുത്; ഓപ്ഷൻ വ്യക്തമാക്കുക.

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

ദുർബലമായത്: "ഈ കോഡിലെ ബഗ് പരിഹരിക്കുക." (ഏത് പിശക്? ഏത് ഭാഷ? എന്താണ് പ്രതീക്ഷിക്കുന്ന പെരുമാറ്റം?)

ശക്തമായത്: "Python 3.11 / FastAPI 0.110. അഭ്യർത്ഥന ബോഡി ശൂന്യമാകുമ്പോൾ ഇനിപ്പറയുന്ന എൻഡ്‌പോയിൻ്റ് KeyError ഉപയോഗിച്ച് 500 നൽകുന്നു; ശൂന്യമായ ബോഡിയിൽ 400-ഉം അർത്ഥവത്തായ സന്ദേശവും നൽകണമെന്ന് ഞാൻ ആഗ്രഹിക്കുന്നു. ആദ്യം കാരണം വിശദീകരിക്കുക, തുടർന്ന് ശരിയാക്കിയ ഫംഗ്‌ഷൻ നൽകുക, തുടർന്ന് ഈ സാഹചര്യത്തിനായി ഒരു ടെസ്റ്റ് എഴുതുക. [കോഡ്]"

ശക്തമായ പതിപ്പ്; ഇത് ഭാഷ, പതിപ്പ്, യഥാർത്ഥ പിശക്, പ്രതീക്ഷിക്കുന്ന സ്വഭാവം, ഔട്ട്പുട്ട് ഫോർമാറ്റ് എന്നിവ നൽകുന്നു. മോഡൽ ഇനി പ്രവചിക്കേണ്ടതില്ല.

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

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

നുറുങ്ങ്: എല്ലാ AI ഔട്ട്‌പുട്ടും "ഇതൊരു ഡ്രാഫ്റ്റാണ്" എന്ന് പരിഗണിക്കുക. ഈ ഒരൊറ്റ മാനസിക ശീലം മൊഡ്യൂളിലുടനീളം നിങ്ങൾ കാണുന്ന മിക്ക അപകടസാധ്യതകളെയും ഇല്ലാതാക്കുന്നു.

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

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

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

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

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

• LLM കോഡ് "മനസ്സിലാക്കുന്നു" എന്നല്ല, പാറ്റേണുകൾ നിർമ്മിക്കുന്നുവെന്ന് ഞാൻ മനസ്സിലാക്കി.
• [ ] ടോക്കൺ, സന്ദർഭ വിൻഡോ, പ്രോംപ്റ്റ് എന്നിവയുടെ ആശയങ്ങൾ എനിക്ക് ഒരു വാചകത്തിൽ വിശദീകരിക്കാൻ കഴിയും.
• AI ശക്തവും ദുർബ്ബലവുമായിരിക്കുന്ന തരത്തിലുള്ള ടാസ്‌ക്കുകൾ തമ്മിൽ എനിക്ക് വേർതിരിച്ചറിയാൻ കഴിയും.
• ഒരു ഹാലുസിനേഷൻ എന്താണെന്ന് എനിക്കറിയാം, പരിശോധന മാത്രമാണ് മറുമരുന്ന്.
• [ ] "നിർദ്ദേശിക്കുക, നിർമ്മിക്കുക, സ്ഥിരീകരിക്കുക" എന്ന സൈക്കിൾ ഞാൻ എൻ്റെ സ്വന്തം ജോലിക്ക് അനുയോജ്യമാക്കി.
• [ ] ശക്തമായ ഒരു പ്രോംപ്റ്റും ദുർബലമായ പ്രോംപ്റ്റും തമ്മിലുള്ള വ്യത്യാസം ഒരു വ്യക്തമായ ഉദാഹരണത്തിൽ എനിക്ക് കാണിക്കാൻ കഴിയും.