AI ಕೋಡ್‌ನ 80/20 ನಿಯಮ

AI ನನ್ನ ಫೀಚರ್‌ನ 80% ಅನ್ನು 10 ನಿಮಿಷಗಳಲ್ಲಿ ಬರೆಯಿತು. ಕೋಡ್ ಸ್ವಚ್ಛವಾಗಿತ್ತು. ಲಾಜಿಕ್ ಅರ್ಥವಾಗುವಂತಿತ್ತು. ಅದು ಮೊದಲ ಪ್ರಯತ್ನದಲ್ಲೇ ಕೆಲಸ ಮಾಡಿತು. ನನಗೆ ತುಂಬಾ ಸಂತೋಷವಾಯಿತು.

ಆದರೆ AI ಮೊದಲ 80% ಕ್ಕೆ ಉಪಯುಕ್ತವಾಗಿದೆ ಮತ್ತು ಕೊನೆಯ 20% ಕ್ಕೆ ಪ್ರಯೋಜನವಿಲ್ಲದಂತಿದೆ.

AI 'ಹ್ಯಾಪಿ ಪಾತ್' (happy path) ಗಾಗಿ ಆಪ್ಟಿಮೈಸ್ ಮಾಡುತ್ತದೆ. ಎಲ್ಲವೂ ಸರಿಯಾಗಿ ನಡೆಯುವ ಪ್ರಪಂಚಕ್ಕಾಗಿ ಇದು ನಿರ್ಮಿಸುತ್ತದೆ. ಆದರೆ ನೈಜ ಸಾಫ್ಟ್‌ವೇರ್ ಎಲ್ಲವೂ ತಪ್ಪಾಗುವ ಪ್ರಪಂಚದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ನಾನು ಇತ್ತೀಚೆಗೆ ಒಂದು Sol Email Worker ಅನ್ನು ನಿರ್ಮಿಸಿದೆ. AI ಕೇವಲ 20 ನಿಮಿಷಗಳಲ್ಲಿ ಅದರ ಕೋರ್ ಲಾಜಿಕ್, ಥ್ರೆಡಿಂಗ್ ಮತ್ತು ರೂಟಿಂಗ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸಿತು. ಅದು ಸುಲಭವಾದ ಭಾಗವಾಗಿತ್ತು.

ಕೊನೆಯ 20% ಕ್ಕೆ ನನ್ನ ನೈಜ ಪರಿಣತಿಯ ಅಗತ್ಯವಿತ್ತು:

• ಡ್ಯೂಪ್ಲಿಕೇಶನ್ (Deduplication): ಡ್ಯೂಪ್ಲಿಕೇಟ್ ಸಂದೇಶಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು. • ಸೆಂಡರ್-ಸ್ಕಿಪ್ ಲಾಜಿಕ್ (Sender-skip logic): ಸ್ವಂತ ಸಂದೇಶಗಳನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸುವುದು. • ಎರರ್ ರಿಕವರಿ (Error recovery): ಅನಿರೀಕ್ಷಿತ API ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು. • ಲಾಗ್ ಔಟ್‌ಪುಟ್ (Log output): ಮಧ್ಯರಾತ್ರಿ 2 ಗಂಟೆಯಲ್ಲೂ ಡೆಬಗ್ ಮಾಡುವುದನ್ನು ಸಾಧ್ಯವಾಗಿಸುವುದು.

ನಾನು ಕೇಳಿದ್ದನ್ನು AI ಮಾಡಿತು. ಆದರೆ ನಾನು ಎಡ್ಜ್ ಕೇಸ್‌ಗಳ (edge cases) ಬಗ್ಗೆ ಕೇಳಲು ವಿಫಲನಾದೆ, ಏಕೆಂದರೆ ನಾನು ಅವುಗಳ ಬಗ್ಗೆ ಇನ್ನೂ ಯೋಚಿಸಿರಲಿಲ್ಲ.

ನಮಗೆ ಅಳತೆ ಮಾಡುವಲ್ಲಿ ಸಮಸ್ಯೆಯಿದೆ. ನಾವು ಕೋಡ್‌ನ ಸಾಲುಗಳು (lines of code) ಮತ್ತು ಕ್ಲೋಸ್ ಮಾಡಿದ ಟಿಕೆಟ್‌ಗಳನ್ನು ಮಾತ್ರ ಗಮನಿಸುತ್ತೇವೆ. ಈ ಮಾಪನಗಳು ವೇಗವಾಗಿ ಮಾಡುವ 80% ಕೆಲಸಕ್ಕೆ ಪ್ರತಿಫಲ ನೀಡುತ್ತವೆ. ಆದರೆ ಎರರ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಅಥವಾ ನಲ್ ಚೆಕ್‌ಗಳಿಗಾಗಿ (null checks) ವ್ಯಯಿಸುವ ಸಮಯವನ್ನು ಯಾರೂ ಗಮನಿಸುವುದಿಲ್ಲ.

ಆ 20% ಕೆಲಸವು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಲ್ಲಿ ಕಾಣಿಸುವುದಿಲ್ಲ, ಆದರೆ ನೈಜ ಕೆಲಸ ನಡೆಯುವುದು ಅಲ್ಲಿಯೇ. ನಾನು ಈಗ 'ಪ್ರಾಂಪ್ಟ್-ಟು-ಶಿಪ್' (prompt-to-ship) ಸಮಯವನ್ನು ಗಮನಿಸುತ್ತಿದ್ದೇನೆ. ಅಂದರೆ ಮೊದಲ ಪ್ರಾಂಪ್ಟ್‌ನಿಂದ ಹಿಡಿದು ಸ್ಥಿರವಾದ ಪ್ರೊಡಕ್ಷನ್ ಫೀಚರ್ ಸಿದ್ಧವಾಗುವವರೆಗೆ ಬೇಕಾಗುವ ಸಮಯ. ಈ ಸಂಖ್ಯೆಯು ಯಾವಾಗಲೂ AI ಜನರೇಟ್ ಮಾಡಿದ ಸಮಯಕ್ಕಿಂತ ಕನಿಷ್ಠ 4 ಪಟ್ಟು ಹೆಚ್ಚಿರುತ್ತದೆ.

ಈಗ ನಾನು ಕೆಲಸ ಮಾಡುವ ವಿಧಾನ ಹೀಗಿದೆ:

  • ಪ್ರತಿ ಕೆಲಸಕ್ಕೂ AI ತೆಗೆದುಕೊಳ್ಳುವ ಸಮಯಕ್ಕಿಂತ 4 ಪಟ್ಟು ಹೆಚ್ಚು ಸಮಯವನ್ನು ನಾನು ಮೀಸಲಿಡುತ್ತೇನೆ.
  • ನಾನು 'ಅನ್‌ಹ್ಯಾಪಿ ಪಾತ್' (unhappy path) ಗಾಗಿ ಪ್ರಾಂಪ್ಟ್ ನೀಡುತ್ತೇನೆ. ನೆಟ್‌ವರ್ಕ್ ಫೇಲ್ ಆಗುತ್ತದೆ ಅಥವಾ API ನಲ್ (null) ಅನ್ನು ರಿಟರ್ನ್ ಮಾಡುತ್ತದೆ ಎಂದು ಭಾವಿಸಲು ನಾನು AI ಗೆ ಹೇಳುತ್ತೇನೆ.
  • ಮೊದಲ ಡ್ರಾಫ್ಟ್ ಅನ್ನು ಕೇವಲ ಆರಂಭಿಕ ಬಿಂದುವನ್ನಾಗಿ ಪರಿಗಣಿಸುತ್ತೇನೆಯೇ ಹೊರತು, ಅದು ಮುಕ್ತಾಯದ ಗೆರೆಯಲ್ಲ.

30 ಸೆಕೆಂಡುಗಳ ಜನರೇಶನ್ ನಂತರ ಎರರ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್‌ಗಾಗಿ ನಾನು ಕಳೆದ 3 ಗಂಟೆಗಳು ವ್ಯರ್ಥವಾಗಿರಲಿಲ್ಲ. ಅದುವೇ ನಿಜವಾದ ಕೆಲಸವಾಗಿತ್ತು. AI ಕೆಲಸವನ್ನು ಕೇವಲ ರಚನೆಯನ್ನು (structure) ಬರೆಯುವುದರಿಂದ, ಕೋಡ್ ಅನ್ನು ನೈಜವಾಗಿಸುವತ್ತ ಬದಲಾಯಿಸಿದೆ.

ಕೋಡ್ ಅನ್ನು ನೈಜವಾಗಿಸುವುದು ನಿಧಾನವಾದ ಪ್ರಕ್ರಿಯೆ. ಇದಕ್ಕೆ ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭ (context), ನಿಮ್ಮ ಬಳಕೆದಾರರು ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್‌ಬೇಸ್ ಇತಿಹಾಸದ ಅಗತ್ಯವಿದೆ. ಪರಿಣತಿಯೆಂದರೆ ಇದೇ.

AI ಪರಿಚಿತ ಪ್ರದೇಶಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಆದರೆ ಎಡ್ಜ್ ಕೇಸ್‌ಗಳು (edge cases) ಯಾವಾಗಲೂ ಅಪರಿಚಿತ ಪ್ರದೇಶಗಳಾಗಿರುತ್ತವೆ.

ಮುಂದಿನ ಬಾರಿ ಯಾವುದಾದರೂ AI ಡೆಮೊ ನಿಮ್ಮನ್ನು ಪ್ರಭಾವಿಸಿದರೆ, ಡೆಮೊ ಮುಗಿದ ನಂತರ ಏನಾಯಿತು ಎಂದು ಕೇಳಿ.

Source: https://dev.to/amrree/the-8020-rule-of-ai-code-id

Optional learning community: https://t.me/GyaanSetuAi