AI ഉപയോഗിച്ച് കോഡിംഗും ജോടി പ്രോഗ്രാമിംഗും

നേട്ടങ്ങൾ:

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

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

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

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

നെറ്റ് കരാറുള്ള പ്രിൻ്റിംഗ് കോഡ്

ജോലി ആരംഭിക്കുന്നതിന് മുമ്പ് "നിങ്ങൾക്ക് എന്താണ് വേണ്ടത്" എന്ന് കൃത്യമായി നിർവ്വചിക്കുക എന്നതാണ് ഗുണനിലവാര കോഡിൻ്റെ അടിസ്ഥാനം. AI-ലേക്ക് ഒരു ഫംഗ്‌ഷൻ എഴുതുമ്പോൾ, അതിന് അഞ്ച് കാര്യങ്ങൾ നൽകുക: ഭാഷയും പതിപ്പും, ഇൻപുട്ട് തരങ്ങളും അർത്ഥങ്ങളും, ഔട്ട്‌പുട്ട്, പിശക് അവസ്ഥകൾ, നിയന്ത്രണങ്ങൾ (പ്രകടനം, ബാഹ്യ ലൈബ്രറി നിരോധനം, ശൈലി). ഇത് AI-യെ ഊഹിക്കുന്നതിൽ നിന്ന് തടയുന്നു.

1. കരാർ എഴുതുക. ഇൻപുട്ട്, ഔട്ട്പുട്ട്, പിശക്, നിയന്ത്രണം.
2. ഒരു ചെറിയ യൂണിറ്റ് ആവശ്യപ്പെടുക. ഒരൊറ്റ ഉത്തരവാദിത്തമുള്ള ഒരു പ്രവർത്തനം; അതൊരു വലിയ മൊഡ്യൂളല്ല.
3. ഒരു ടെസ്റ്റ് ബ്ലോക്ക് അഭ്യർത്ഥിക്കുക. കോഡിന് അടുത്തായി കുറച്ച് സാമ്പിൾ റൺ/ടെസ്റ്റുകൾ ചേർക്കുക.
4. സമാഹരിച്ച് പ്രവർത്തിപ്പിക്കുക. എഡ്ജ് കേസുകൾ ഉപയോഗിച്ച് ഇത് പരീക്ഷിക്കുക, കണ്ണ് ഉപയോഗിച്ച് ഔട്ട്പുട്ട് പരിശോധിക്കുക.
5. അടുത്ത ഘട്ടത്തിലേക്ക് പോകുക. ഒരു കഷണം സ്ഥിരീകരിച്ചുകഴിഞ്ഞാൽ, അതിൽ നിർമ്മിക്കുക.

കരാർ ചെയ്‌ത ഫംഗ്‌ഷൻ പ്രോംപ്റ്റ്: "ടൈപ്പ്‌സ്‌ക്രിപ്‌റ്റ് 5-ന് ഒരു ഫംഗ്‌ഷൻ എഴുതുക. ഉദ്ദേശ്യം: ഒരു ഷോപ്പിംഗ് കാർട്ടിലെ മൊത്തം ഇനങ്ങളുടെ അളവ് കണക്കാക്കുക. ഇൻപുട്ട്: {വില: നമ്പർ, അളവ്: നമ്പർ [] അറേ. ഔട്ട്‌പുട്ട്: നമ്പർ (ആകെ). നിയമങ്ങൾ: അളവോ വിലയോ നെഗറ്റീവ് ആണെങ്കിൽ പിശക് എറിയുക ലൈബ്രറി ഫംഗ്‌ഷന് താഴെ 5 ടെസ്റ്റ് കേസുകൾ ചേർക്കുക (സാധാരണ, ശൂന്യമായ, നെഗറ്റീവ് അളവ്, ദശാംശ വില, ഒറ്റ ഇനം).

AI-യെ ഒരു ജോഡിയായി നയിക്കുന്നു

ജോടി പ്രോഗ്രാമിംഗിലെ നല്ല പുരോഗതി ഒരു വലിയ അഭ്യർത്ഥനയെക്കാൾ ഒരു ഡയലോഗാണ്. ആദ്യം, അസ്ഥികൂടം അഭ്യർത്ഥിച്ച് പ്രവർത്തിപ്പിക്കുക; തുടർന്ന് ഒരു എഡ്ജ് സ്റ്റേറ്റ് ചേർക്കുക; അപ്പോൾ ഒരു ബഗ് പരിഹരിക്കുക. ഈ സമീപനം കോഡ് മനസ്സിലാക്കാവുന്ന തരത്തിൽ നിലനിർത്തുകയും ഓരോ ഘട്ടത്തിലും നിങ്ങളെ നിയന്ത്രിക്കുകയും ചെയ്യുന്നു.

വർദ്ധിച്ചുവരുന്ന പുരോഗതി പ്രോംപ്റ്റ്: "ഞങ്ങൾ ഒരു CSV ഫയൽ വായിച്ച് വരികൾ ഒബ്‌ജക്‌റ്റാക്കി മാറ്റുന്ന ഒരു റീഡർ എഴുതും. ഓരോ ഘട്ടവും ഞാൻ സ്ഥിരീകരിക്കാതെ തന്നെ അടുത്ത ഘട്ടത്തിലേക്ക് നമുക്ക് പോകാം. ഘട്ടം 1: ഫയലിനെ വരികളായി വിഭജിച്ച് ഹെഡ്ഡർ ലൈൻ വേർതിരിക്കുന്ന അസ്ഥികൂടം എഴുതുക. ഇത് ഹ്രസ്വമായ രീതിയിൽ പരിവർത്തനം ചെയ്യുകയോ വിശദീകരിക്കുകയോ ചെയ്യരുത്."

കോഡ് പ്രോംപ്റ്റിനെ വിശദീകരിക്കുകയും ന്യായീകരിക്കുകയും ചെയ്യുക: "നിങ്ങൾ ഇപ്പോൾ എഴുതിയ ഫംഗ്‌ഷൻ, വരിയായി അല്ല, തീരുമാനമനുസരിച്ച് വിശദീകരിക്കുക: ഏത് ഡിസൈൻ തീരുമാനമാണ് നിങ്ങൾ എടുത്തത്, എന്തുകൊണ്ട്, ഏത് എഡ്ജ് കേസ് നിങ്ങൾ കൈകാര്യം ചെയ്തു, എങ്ങനെ, ഏതൊക്കെ കേസുകൾ നിങ്ങൾ മനഃപൂർവ്വം ഒഴിവാക്കി? എനിക്ക് നഷ്ടപ്പെടുത്താൻ പാടില്ലാത്ത 3 അനുമാനങ്ങൾ കോഡിലെ ലിസ്റ്റ് ചെയ്യുക."

നുറുങ്ങ്: AI സൃഷ്ടിച്ച കോഡ് മനസ്സിലാക്കാതെ അത് സ്വീകരിക്കരുത്. "ഇത് എന്നോട് വിശദീകരിക്കൂ, നിങ്ങൾ എന്ത് അനുമാനങ്ങളാണ് ഉണ്ടാക്കിയത്?" ചോദ്യം രണ്ടും മറഞ്ഞിരിക്കുന്ന പിശകുകൾ വെളിപ്പെടുത്തുകയും ആ കോഡിനെ പ്രതിരോധിക്കാൻ നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യുന്നു, കാരണം കോഡ് നിങ്ങളുടെ ഉത്തരവാദിത്തമായി തുടരുന്നു. നിർമ്മാണത്തിൽ നിങ്ങൾക്ക് മനസ്സിലാകാത്ത കോഡ് ഇടുന്നത് ഒരു കരാർ ഒപ്പിടാതെ അയയ്ക്കുന്നതിന് തുല്യമാണ്.

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

ദുർബലമായത്:"ഒരു സോർട്ടിംഗ് ഫംഗ്‌ഷൻ എഴുതുക."(ഫലം: ഏത് ഭാഷയാണ്, എന്താണ് അടുക്കുന്നത്, അത് സ്ഥിരതയുള്ളതാണോ, പ്രകടന പരിമിതി എന്താണ്, അവ്യക്തവും, ഒരുപക്ഷേ ആവശ്യകതയ്ക്ക് അനുയോജ്യമല്ലാത്തതുമായ കോഡ്.)STRONG:"Java 17-ന്, ഒരു ലിസ്റ്റ്<തൊഴിലാളി> ഒബ്ജക്റ്റ് ആദ്യം അടുക്കുന്ന രീതി എഴുതുക<തൊഴിലാളി> ഒബ്ജക്റ്റ് ആദ്യം ഡിപ്പാർട്ട്‌മെൻ്റ് പ്രകാരം (അക്ഷരക്രമം അനുസരിച്ച്) അവസാനിക്കുക. പട്ടിക, 4 സാമ്പിളുകളുള്ള ഒരു പ്രധാന ടെസ്റ്റ് ബ്ലോക്ക് വ്യക്തമാക്കുക.

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

എഡ്ജ് കേസുകളും ചെറിയ സാമ്പിളുകളും ഉപയോഗിച്ച് മൂല്യനിർണ്ണയം

സന്തോഷകരമായ സാഹചര്യത്തിൽ പ്രവർത്തിക്കുന്ന കോഡ് ശരിയായ കോഡല്ല. ഉൽപ്പാദിപ്പിക്കുന്ന ഓരോ പ്രവർത്തനവും ബോധപൂർവ്വം നിർബന്ധിക്കുക:

എഡ്ജ് കേസ് തരം

സാമ്പിൾ ഇൻപുട്ട്

പ്രതീക്ഷിച്ച പെരുമാറ്റം

ശൂന്യമായ ഇൻപുട്ട്

ശൂന്യമായ അറേ/സ്ട്രിംഗ്

ഒരു പിശകല്ല, ലോജിക്കൽ ശൂന്യമായ ഫലം

പൂജ്യം/നെഗറ്റീവ്

0, -1

നിർവചിക്കപ്പെട്ടതും ശരിയായതുമായ പെരുമാറ്റം

വലിയ മൂല്യം

ദശലക്ഷക്കണക്കിന് റെക്കോർഡുകൾ

ഓവർഫ്ലോ/പ്രകടന നിയന്ത്രണം

ശൂന്യം/നിർവചിക്കാത്തത്

സ്ഥലം നഷ്ടപ്പെട്ടു

നിയന്ത്രിത പിശക് അല്ലെങ്കിൽ സ്ഥിരസ്ഥിതി

തനിപ്പകർപ്പ്/അസാധാരണം

ആവർത്തന, വിപരീത ക്രമം

ശരിയായ ഫലം

മിനി കേസുകൾ

കേസ് 1 - നിശബ്ദ റൗണ്ടിംഗ് പിശക്. ഡെസിമൽ (ഫ്ലോട്ട്) തരങ്ങൾ ഉപയോഗിച്ച് പണം ശേഖരിക്കുന്ന ഒരു ഫംഗ്ഷൻ AI എഴുതുന്നു; 0.1 + 0.2 എന്നത് 0.30000000000000004 നൽകുന്നു. എഞ്ചിനീയർ "2 അക്കങ്ങളിലേക്ക് റൗണ്ട് ചെയ്യുക, മുഴുവൻ പെന്നികൾ ഉപയോഗിക്കുക" എന്ന നിയമം ചേർക്കുമ്പോൾ പിശക് പരിഹരിക്കപ്പെടും. ഒരു 3-വരി നിയമം പ്രതിമാസ അനുരഞ്ജനത്തിൽ ആയിരക്കണക്കിന് പെന്നികളുടെ വ്യത്യാസം തടയുന്നു.

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

കേസ് 3 - പടിപടിയായി വരുമാനം. ഒരു ഡെവലപ്പർ ഒരേസമയം 150-വരി ഇറക്കുമതി മൊഡ്യൂൾ പ്രിൻ്റ് ചെയ്യുന്നു; ഒരു തെറ്റ് കണ്ടെത്തുമ്പോൾ, അത് എവിടെ നിന്നാണ് വന്നതെന്ന് അയാൾക്ക് കണ്ടെത്താൻ കഴിയില്ല. മറ്റൊരു ഡെവലപ്പർ അതേ ജോലിയെ 5 ചെറിയ ഘട്ടങ്ങളായി വിഭജിക്കുകയും ഓരോ ഘട്ടവും 2 മിനിറ്റിനുള്ളിൽ പരിശോധിക്കുകയും മൂന്നാം ഘട്ടത്തിൽ പിശക് ഉടനടി പിടിക്കുകയും ചെയ്യുന്നു.

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

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

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

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

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

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

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

• [ ] ഇൻപുട്ട്, ഔട്ട്പുട്ട്, പിശകുകൾ, നിയന്ത്രണങ്ങൾ എന്നിവ ഉൾപ്പെടുന്ന ഒരു കരാർ ഞാൻ എഴുതി.
• [ ] ഞാൻ ഒരു വലിയ ബ്ലോക്കിന് പകരം ചെറിയ ഘട്ടങ്ങളിലൂടെ കോഡ് സൃഷ്ടിച്ചു.
• [ ] ഞാൻ കോഡിന് അടുത്തായി ഒരു ടെസ്റ്റ്/സാമ്പിൾ റൺ ബ്ലോക്ക് ചേർത്തു.
• [ ] കുറഞ്ഞത് 5 എഡ്ജ് കേസുകളെങ്കിലും ഞാൻ ബോധപൂർവ്വം പരിശോധിച്ചിട്ടുണ്ട്.
• [ ] ഞാൻ AI-ക്ക് കോഡ് വിശദീകരിക്കുകയും അതിൻ്റെ അനുമാനങ്ങൾ അവലോകനം ചെയ്യുകയും ചെയ്തു.
• [ ] കണ്ടെത്തിയ പിശക് ഞാൻ തിരുത്തി, വീണ്ടും പരീക്ഷിച്ചുകൊണ്ട് തിരുത്തൽ സ്ഥിരീകരിച്ചു.