സ്ക്രിപ്റ്റിംഗും സ്വയം പൂർത്തീകരണവും

നേട്ടങ്ങൾ:

• ഇൻലൈൻ പൂർത്തീകരണത്തോടെ ടാസ്‌ക് തരം ശരിയാക്കാൻ ചാറ്റ് മോഡ് മാപ്പ് ചെയ്യാനുള്ള കഴിവ്
• ഇൻപുട്ട്/ഔട്ട്പുട്ട് കരാറുകൾ, എഡ്ജ് കേസുകൾ, സ്റ്റൈൽ നിയന്ത്രണങ്ങൾ എന്നിവ ഉൾപ്പെടുന്ന ശക്തമായ പ്രൊഡക്ഷൻ പ്രോംപ്റ്റുകൾ എഴുതാനുള്ള കഴിവ്
• ലയിപ്പിക്കുന്നതിന് മുമ്പ് ജനറേറ്റ് ചെയ്ത കോഡും ഏതെങ്കിലും പുതിയ നിർദ്ദേശിച്ച ഡിപൻഡൻസികളും സാധൂകരിക്കാനുള്ള കഴിവ്

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

നിങ്ങളുടെ ടൈപ്പിംഗ് മെഷീനെ വേഗത്തിലാക്കുന്ന ഒരു ടൂളിൽ നിന്ന് നിങ്ങൾ സജ്ജമാക്കിയ നിയന്ത്രണങ്ങൾക്കുള്ളിൽ പ്രവർത്തിക്കുന്ന ഒരു അപ്രൻ്റീസായി AI മാറ്റുക എന്നതാണ് ലക്ഷ്യം. നല്ല മാർഗനിർദേശമുള്ള അപ്രൻ്റീസ് സമയം ലാഭിക്കുന്നു; മാർഗനിർദേശമില്ലാത്ത ഒരു അപ്രൻ്റീസ് നിങ്ങൾ പിന്നീട് വൃത്തിയാക്കേണ്ട ഒരു കുഴപ്പമുണ്ടാക്കുന്നു.

രണ്ട് ഉപയോഗ രീതികൾ: ഇൻലൈൻ പൂർത്തിയാക്കലും ചാറ്റും

നിങ്ങളുടെ എഡിറ്ററിൽ ടൈപ്പ് ചെയ്യുമ്പോൾ ഇൻലൈൻ പൂർത്തീകരണം പ്രാബല്യത്തിൽ വരും; നിങ്ങൾ ഒരു ഫംഗ്‌ഷൻ സിഗ്‌നേച്ചറോ ഒരു കമൻ്റ് ലൈനോ ടൈപ്പ് ചെയ്യുക, ബാക്കിയുള്ളത് നിർദ്ദേശിക്കുന്നു. വേഗതയ്ക്ക് ഇത് മികച്ചതാണ്, പക്ഷേ ഇതിന് ഇടുങ്ങിയ സന്ദർഭമുണ്ട്: ഇത് അടുത്ത പ്രദേശത്ത് മാത്രമേ കോഡ് കാണൂ. അതുകൊണ്ടാണ് നിങ്ങളുടെ ഉദ്ദേശ്യം ഒരു അഭിപ്രായത്തിൽ വ്യക്തമായി എഴുതുമ്പോൾ അത് മികച്ച രീതിയിൽ പ്രവർത്തിക്കുന്നത്. ഉദാഹരണത്തിന്, //ഉപയോക്തൃ ഇമെയിൽ സാധൂകരിക്കുക, അസാധുവായ അഭിപ്രായം താഴെയുള്ള നിർദ്ദേശത്തെ ഗണ്യമായി മെച്ചപ്പെടുത്തുന്നുവെങ്കിൽ ValidationError ഇടുക.

ചാറ്റ് മോഡ് വലുതും ഘടനാപരവുമായ ജോലികൾക്കുള്ളതാണ്: "ഈ ക്ലാസിലേക്ക് പേജിനേഷൻ ചേർക്കുക", "ആ സേവനത്തിൻ്റെ ഒരു ഇൻ്റർഫേസ് എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്യുക". ഇവിടെ നിങ്ങൾക്ക് റോൾ, സന്ദർഭം, ഫോർമാറ്റ് എന്നിവ നൽകാനുള്ള ആഡംബരമുണ്ട്. പൊതുവായ നിയമം ഇതാണ്: ചെറുതും ഒഴുകുന്നതുമായ ജോലികൾക്കായി പൂർത്തീകരണം, ചിന്തയും ഘടനയും ആവശ്യമുള്ള ജോലികൾക്കുള്ള സംഭാഷണം.

നുറുങ്ങ്: "ടാബ്" ഉപയോഗിച്ച് പൂർത്തിയാക്കാനുള്ള നിർദ്ദേശം അന്ധമായി സ്വീകരിക്കരുത്. നിർദ്ദേശിച്ച വരി ഒരു നിമിഷം വായിക്കുക; തെറ്റായ വേരിയബിൾ നാമമോ വിപരീത അവസ്ഥയോ ഇവിടെ നിന്ന് സാധാരണയായി ചോർന്നുപോകുന്നു.

ഉദ്ദേശ്യം കോഡിലേക്ക് വിവർത്തനം ചെയ്യുന്നതിനുള്ള നടപടികൾ

1. കരാർ നിർവചിക്കുക. ഫംഗ്‌ഷൻ്റെ ഇൻപുട്ട്, ഔട്ട്‌പുട്ട്, പിശക് സ്വഭാവം എന്താണ്? "ഇമെയിൽ നേടുക, സാധുതയുണ്ടെങ്കിൽ നോർമലൈസ് ചെയ്യുക, അസാധുവാണെങ്കിൽ പിശക് തള്ളുക" എന്നതുപോലെ.
2. നിയന്ത്രണങ്ങൾ പ്രസ്താവിക്കുക. ബാഹ്യ ആശ്രിതത്വം ഉപയോഗിക്കുന്നില്ലേ? ഒരു പ്രത്യേക ശൈലി ഗൈഡ്? പ്രകടന പരിധിയുണ്ടോ?
3. ഒരു ഉദാഹരണം പറയാം. ഒരു ഇൻപുട്ട്-ഔട്ട്‌പുട്ട് ജോടി (“ali@x.com → സാധുവായ, ali@ → പിശക്”) മോഡലിൻ്റെ ഉദ്ദേശ്യത്തെക്കുറിച്ചുള്ള ധാരണയെ പ്രവചനത്തിൽ നിന്ന് കൃത്യതയിലേക്ക് മാറ്റുന്നു.
4. ചെറിയ കഷണങ്ങൾ ആവശ്യപ്പെടുക. ഒരു പ്രവർത്തനം, ഒരു ഉത്തരവാദിത്തം. തുടർന്ന് അടുത്തതിലേക്ക് നീങ്ങുക.
5. സൃഷ്ടിച്ച കോഡ് വായിച്ച് പ്രവർത്തിപ്പിക്കുക. കംപൈലിംഗ് + ഒരു ദ്രുത മാനുവൽ ശ്രമമാണ് വിലകുറഞ്ഞ ഉറപ്പ് ഘട്ടം.

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

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

കേസ് 2 - ഒരു പതിപ്പ് വ്യക്തമാക്കാത്തത് ചെലവേറിയതാണ്. Node.js-നായി നിർമ്മിച്ച കോഡിലെ fs.promises മാറ്റിസ്ഥാപിക്കുന്ന ലെഗസി കോൾബാക്ക് അധിഷ്ഠിത API-യുമായി ഒരു ടീം ബുദ്ധിമുട്ടി. "Use Node 20, ESM, async/waiit" എന്ന ലൈൻ പ്രോംപ്റ്റിൽ ചേർത്തപ്പോൾ, പ്രൊഡക്ഷൻ ആദ്യമായി പ്രോജക്ടിനെ പിന്തുടർന്നു; തിരുത്തലിനായി ചെലവഴിച്ച ശരാശരി 12 മിനിറ്റ് റീസെറ്റ് ചെയ്തു.

കേസ് 3 - ബോയിലർ പ്ലേറ്റ് കോഡിലെ യഥാർത്ഥ നേട്ടം. ഒരു മൈക്രോസർവീസിന് 6 പുതിയ ഡിടിഒയും (ഡാറ്റ ട്രാൻസ്ഫർ ഒബ്ജക്റ്റ് - ലെയറുകൾക്കിടയിൽ ഡാറ്റ കൊണ്ടുപോകുന്ന ഒരു ലളിതമായ ഡാറ്റ ക്ലാസും) അവയുടെ മൂല്യനിർണ്ണയ നിയമങ്ങളും ആവശ്യമാണ്. AI നിർമ്മിച്ച് അവലോകനം ചെയ്യുമ്പോൾ ഏകദേശം 90 മിനിറ്റ് മാനുവൽ ജോലി 35 മിനിറ്റായി കുറച്ചു; കോഡ് ആവർത്തനം ഉയർന്നതും പാറ്റേൺ വ്യക്തവുമായതിനാൽ, AI അതിൻ്റെ ഏറ്റവും കാര്യക്ഷമമായ മേഖലയിൽ ഇവിടെ പ്രവർത്തിച്ചു.

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

കരാർ അധിഷ്‌ഠിത പ്രവർത്തന ഉൽപ്പാദനം:

റോൾ: നിങ്ങളൊരു ഉത്സാഹമുള്ള {{ഭാഷ}} ഡെവലപ്പറാണ്. ഫംഗ്‌ഷൻ കരാർ:- പേര്: {{name}}- ഇൻപുട്ട്: {{തരങ്ങളും അവയുടെ അർത്ഥവും}}- ഔട്ട്‌പുട്ട്: {{തരവും അർത്ഥവും}}- പിശക് നില: {{എന്താണ് എറിഞ്ഞത്/തിരിച്ചെടുത്തത്}}നിയന്ത്രണം: {{ബാഹ്യ ആശ്രിതത്വമില്ല:-} {{output_1}}- {{entry_2}} -> {{error_2}}ആദ്യം ഒപ്പ് + ഷോർട്ട് പ്ലാൻ നൽകുക, തുടർന്ന് കോഡ് നൽകുക. ടെസ്റ്റുകൾ എഴുതുക, പ്രവർത്തനം മാത്രം.

നിലവിലുള്ള ശൈലിയുമായി പൊരുത്തപ്പെടുന്നതിന് (കോഡ് ബേസുമായി പൊരുത്തപ്പെടുക):

ഞങ്ങളുടെ പ്രോജക്‌റ്റിൽ നിന്നുള്ള ഒരു ഉദാഹരണ ഫംഗ്‌ഷൻ ചുവടെയുണ്ട്; പേരിടൽ, പിശക് കൈകാര്യം ചെയ്യൽ, കമൻ്റിംഗ് ശൈലി എന്നിവ ഇവിടെ പഠിക്കുക. അതേ ശൈലിയിൽ {{new_task}} എന്നതിനായി ഒരു ഫംഗ്‌ഷൻ എഴുതുക. ഉദാഹരണം: {{current_code}}

അസ്ഥികൂടം മുതൽ പൂരിപ്പിക്കൽ വരെ (അപൂർണ്ണം → നടപ്പിലാക്കൽ):

അഭിപ്രായങ്ങളിലെ TODOകൾ അനുസരിച്ച് ചുവടെയുള്ള ഫംഗ്‌ഷൻ അസ്ഥികൂടം പൂരിപ്പിക്കുക. ഒപ്പും റിട്ടേൺ തരവും മാറ്റുക. നിലവിലില്ലാത്ത ഒരു സഹായി പ്രവർത്തനം നടത്തരുത്; ആവശ്യമെങ്കിൽ, "ഈ സഹായിയെ ആവശ്യമുണ്ട്" എന്ന് എന്നെ അറിയിക്കുക. {{skelet_kod}}

ഇതര ആപ്പ് താരതമ്യം:

{{task}} എന്നതിനായി 2 വ്യത്യസ്ത നിർവ്വഹണങ്ങൾ നൽകുക: (എ) വായനാക്ഷമതയ്ക്ക് മുൻഗണന നൽകുക, (ബി) പ്രകടനത്തിന് മുൻഗണന നൽകുക. ഓരോന്നിൻ്റെയും കീഴിൽ "എപ്പോൾ അഭികാമ്യം" എന്ന 1 വാചകം എഴുതുക.

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

ദുർബലമായത്: "എനിക്ക് ഒരു ഇമെയിൽ സ്ഥിരീകരണ പ്രവർത്തനം എഴുതുക."

ശക്തമായത്: "ടൈപ്പ്‌സ്‌ക്രിപ്റ്റ് 5, സ്റ്റാൻഡേർഡ് ലൈബ്രറി മാത്രം. ValidEmail(ഇൻപുട്ട്: സ്ട്രിംഗ്) എന്ന് എഴുതുക. ബൂളിയൻ. സ്‌പെയ്‌സുകൾ ട്രിം ചെയ്യുക, ഇത് കേസ് സെൻസിറ്റീവ് ആക്കുക, a@b.co സാധുവാണ്, a@, @b.co, ശൂന്യമായ സ്‌ട്രിംഗ് അസാധുവാണ്. നിങ്ങൾ regex ഉപയോഗിക്കാൻ പോകുകയാണെങ്കിൽ, 2 വരികൾ കോംപ്ലക്‌സായി ചേർക്കരുത്."

ശക്തമായ പതിപ്പ്; ഭാഷ, പതിപ്പ്, ഒപ്പ്, എഡ്ജ് കേസുകൾ, ഒരു ശൈലി പരിമിതി എന്നിവ നൽകുന്നു. അങ്ങനെ, ജനറേറ്റുചെയ്‌ത കോഡ് നിങ്ങളുടെ പ്രോജക്‌റ്റിലേക്ക് പ്രവർത്തിക്കുകയും യോജിക്കുകയും ചെയ്യുന്നു.

സമീപിക്കുക

എപ്പോൾ ഉപയോഗിക്കണം

ശ്രദ്ധ

ഇൻലൈൻ പൂർത്തീകരണം

ഒഴുക്കിൽ ചെറിയ ഇൻസെർട്ടുകൾ

നിർദ്ദേശം വായിക്കാതെ സ്വീകരിക്കരുത്

ചാറ്റിൽ കരാർ അടിസ്ഥാനമാക്കിയുള്ള ഉത്പാദനം

പുതിയ ഫംഗ്‌ഷൻ/ക്ലാസ്

ഉദാഹരണവും എഡ്ജ് കേസും നൽകുക

സ്റ്റൈൽ മാതൃകയിലുള്ള ഉത്പാദനം

നിലവിലുള്ള കോഡിലേക്ക് ചേർക്കുന്നു

നിലവിലെ സാമ്പിൾ കോഡ് തിരഞ്ഞെടുക്കുക

അസ്ഥികൂടം മതേതരത്വത്തിൻ്റെ

ഒപ്പ് ഉറപ്പിച്ചു, ബോഡി ശൂന്യമാണ്

ഒപ്പ് മാറ്റുന്നു

കോഡ് ഡ്യൂപ്ലിക്കേഷനും ഡിപൻഡൻസി ട്രാപ്പും

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

മുന്നറിയിപ്പ്: AI നിർദ്ദേശിച്ച ഇറക്കുമതി ലൈനുകൾ അവലോകനം ചെയ്യുക. നിലവിലില്ലാത്ത ഒരു പാക്കേജ് നാമം ("ടൈപ്പോ-സ്ക്വാറ്റിംഗ്" എന്ന് വിളിക്കുന്ന വ്യാജ പാക്കേജുകളോട് സാമ്യമുള്ളതും) കംപൈലേഷനെ തകർക്കുകയും ഒരു സുരക്ഷാ അപകടമുണ്ടാക്കുകയും ചെയ്യുന്നു.

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

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

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

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

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

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

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

• [ ] ഇൻലൈൻ പൂർത്തീകരണത്തിനൊപ്പം ചാറ്റ് മോഡ് എവിടെ ഉപയോഗിക്കണമെന്ന് എനിക്കറിയാം.
• [ ] ഫംഗ്‌ഷൻ ജനറേഷനിലെ ഇൻപുട്ട്/ഔട്ട്‌പുട്ട് കരാറും എഡ്ജ് കേസുകളും ഞാൻ നിർണ്ണയിക്കുന്നു.
• [ ] പ്രോംപ്റ്റിലേക്ക് ഭാഷയുടെയും പതിപ്പിൻ്റെയും വിവരങ്ങൾ ചേർക്കുന്നത് ഞാൻ ഒരു ശീലമാക്കിയിട്ടുണ്ട്.
• [ ] നിർമ്മിക്കുന്ന ഓരോ ഭാഗവും കൂട്ടിച്ചേർക്കുന്നതിന് മുമ്പ് ഞാൻ കംപൈൽ ചെയ്യുകയും പരിശോധിക്കുകയും ചെയ്യുന്നു.
• AI നിർദ്ദേശിക്കുന്ന ഓരോ പുതിയ ആശ്രിതത്വവും അതിൻ്റെ നിലനിൽപ്പും ആവശ്യകതയും പരിശോധിച്ചുകൊണ്ട് ഞാൻ സ്ഥിരീകരിക്കുന്നു.
• [ ] ജനറേറ്റ് ചെയ്‌ത കോഡ് പ്രോജക്റ്റിൻ്റെ ശൈലിയുമായി പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് ഞാൻ പരിശോധിക്കുന്നു.