ದಕ್ಷತೆಯ ಭ್ರಮೆ: AI ನ ಕೊನೆಯ ಹಂತವು ಏಕೆ ಎಲ್ಲವನ್ನೂ ದುಬಾರಿಯಾಗಿಸುತ್ತದೆ

ನೀವು AI ಕೋಡ್‌ನ 80/20 ನಿಯಮದ ಬಗ್ಗೆ ಓದುತ್ತೀರಿ ಮತ್ತು ತಲೆದೂಗುತ್ತೀರಿ.

AI ನಿಮ್ಮ ಕೋಡ್‌ನ ಮೊದಲ 80% ಅನ್ನು ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಬರೆಯುತ್ತದೆ. ಇದು ಪ್ರಗತಿಯಂತೆ ಕಾಣುತ್ತದೆ. ಇದು ವೇಗವಾಗಿ ಕೆಲಸ ಮಾಡんでいるಂತೆ ಭಾಸವಾಗುತ್ತದೆ.

ಇದು ಒಂದು ಬಲೆ.

ಕೆಲಸದ ಕೊನೆಯ 20% ಭಾಗವು ನಿಮ್ಮ ಸಮಯದ 80% ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಇಲ್ಲಿಯೇ ಯೋಜನೆಗಳು ವಿಫಲವಾಗುತ್ತವೆ. ಇಲ್ಲಿಯೇ ಡೆವಲಪರ್‌ಗಳು ತಲೆ ಕೆಡಿಸಿಕೊಳ್ಳುತ್ತಾರೆ.

AI ಸಂಭವನೀಯತೆಯ (probability) ಮೇಲೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಇದು ಮುಂದಿನ ಅತ್ಯಂತ ಸಾಧ್ಯವಿರುವ ಪದ ಅಥವಾ ಕೋಡ್ ಸಾಲನ್ನು ಊಹಿಸುತ್ತದೆ. ಇದು ತರ್ಕವನ್ನು (logic) ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದಿಲ್ಲ. ಇದು ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಸಿಸ್ಟಮ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದಿಲ್ಲ. ಇದು ಕೇವಲ ಪರಿಪೂರ್ಣ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಮಾತ್ರ ಕೆಲಸ ಮಾಡುವ "happy path" ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.

ನೀವು ಆ "happy path" ದಾಟಿದಾಗ, ನೀವು ಅಡೆತಡೆಗಳನ್ನು ಎದುರಿಸುತ್ತೀರಿ.

ನಾನು ಇದನ್ನು Verification Debt ಎಂದು ಕರೆಯುತ್ತೇನೆ.

Technical debt ಎಂಬುದು ಕ್ಷಿಪ್ರ ಪರಿಹಾರಗಳಿಂದ ಬರುತ್ತದೆ. Verification debt ಎಂಬುದು ತಿಳುವಳಿಕೆಯ ಕೊರತೆಯಿಂದ ಬರುತ್ತದೆ.

ನೀವು ಸ್ವತಃ ಕೋಡ್ ಬರೆಯುವಾಗ, ನೀವು ಒಂದು ಮಾನಸಿಕ ನಕ್ಷೆಯನ್ನು (mental map) ರೂಪಿಸಿಕೊಳ್ಳುತ್ತೀರಿ. ಪ್ರತಿಯೊಂದು ಸಾಲು ಏಕೆ ಇದೆ ಎಂಬುದು ನಿಮಗೆ ತಿಳಿದಿರುತ್ತದೆ. AI ಅದನ್ನು ಬರೆಯುವಾಗ, ನೀವು ನಿರ್ಮಿಸದ ಒಂದು ಸಿದ್ಧ ಉತ್ಪನ್ನವನ್ನು ನಿಮಗೆ ನೀಡಲಾಗುತ್ತದೆ. ಅದರ ತರ್ಕವು ನಿಮ್ಮದಲ್ಲ. ನಿಮಗೆ ಕೇವಲ ಫಲಿತಾಂಶ ಮಾತ್ರ ಸಿಗುತ್ತದೆ.

ನಿಮಗೆ ಕೋಡ್ ಅರ್ಥವಾಗದಿದ್ದರೆ, ನೀವು ಅದನ್ನು debug ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. AI ಕೇವಲ ಒಂದು ಸೆಕೆಂಡಿನಲ್ಲಿ ಮಾಡಿದ ತಪ್ಪನ್ನು ಸರಿಪಡಿಸಲು ನೀವು ಗಂಟೆಗಟ್ಟಲೆ ಸಮಯ ವ್ಯಯಿಸುತ್ತೀರಿ.

ಕೋಡ್ ಸೃಷ್ಟಿಸುವ ವೇಗವು ಕೆಲಸವು ಪೂರ್ಣಗೊಂಡಿದೆ ಎಂಬ ಭ್ರಮೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ನೀವು ಕೆಲಸ ಮುಗಿಯಿತು ಎಂದು ಭಾವಿಸುತ್ತೀರಿ. ನಂತರ edge casesಗಳು ಎದುರಾಗುತ್ತವೆ. Integration ವಿಫಲವಾಗುತ್ತದೆ. Security flawsಗಳು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ.

ಕೊನೆಯ 20% ಕೇವಲ "finishing touches" ಅಲ್ಲ. ಅದು ಗುಣಮಟ್ಟದ ಮೂಲಾಧಾರವಾಗಿದೆ. ಅದು ಟೆಸ್ಟಿಂಗ್, ಡಿಬಗ್ಗಿಂಗ್ ಮತ್ತು edge-case ನಿರ್ವಹಣೆಯಾಗಿದೆ.

ಇದನ್ನು ನೀವು ಹೇಗೆ ಸರಿಪಡಿಸಬಹುದು?

AI ನೀಡುವ ಫಲಿತಾಂಶವನ್ನು ಅಂತಿಮ ಉತ್ಪನ್ನವೆಂದು ಪರಿಗಣಿಸುವುದನ್ನು ನಿಲ್ಲಿಸಿ. ಅದನ್ನು ನಂಬಲಾಗದ ದತ್ತಾಂಶವೆಂದು (untrusted data) ಪರಿಗಣಿಸಿ.

  • ಮೊದಲು ಟೆಸ್ಟ್‌ಗಳನ್ನು ಬರೆಯಿರಿ. ಟೆಸ್ಟ್‌ಗಳನ್ನು ಸೃಷ್ಟಿಸುವ ಮೊದಲು ಎಂದಿಗೂ logic ಅನ್ನು ಸೃಷ್ಟಿಸಬೇಡಿ. AI ಪ್ರತಿಕ್ರಿಯಿಸುವ ಮೊದಲು ವೈಫಲ್ಯವು ಹೇಗಿರುತ್ತದೆ ಎಂಬುದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ.
  • ಭಾಗಗಳಾಗಿ ಪರಿಶೀಲಿಸಿ (Validate in segments). ದೋಷಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಪೂರ್ಣ ಸಿಸ್ಟಮ್ integration ಗಾಗಿ ಕಾಯಬೇಡಿ. ಪ್ರತಿಯೊಂದು ಸಣ್ಣ ಬ್ಲಾಕ್ ಅನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಪರೀಕ್ಷಿಸಿ.
  • ಪ್ಯಾಚ್ ಮಾಡುವ ಬದಲು ಕೈಬಿಡಿ. ಒಂದು AI ಫಂಕ್ಷನ್ ಟೆಸ್ಟ್‌ನಲ್ಲಿ ವಿಫಲವಾದರೆ, ಅದನ್ನು ಸಾಲು ಸಾಲಾಗಿ ಸರಿಪಡಿಸಲು ಪ್ರಯತ್ನಿಸಬೇಡಿ. ಅದನ್ನು ಅಳಿಸಿవేಸಿ ಮತ್ತು ಬೇರೆ prompt ಬಳಸಿ ಪ್ರಯತ್ನಿಸಿ. AI ತಪ್ಪುಗಳನ್ನು ಪ್ಯಾಚ್ ಮಾಡುವುದು ಹೆಚ್ಚಾಗಿ ಹೆಚ್ಚಿನ ತಪ್ಪುಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.

80/20 ನಿಯಮವು ಒಂದು ಎಚ್ಚರಿಕೆ. AI ನಿಮ್ಮ ವೇಗವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ಆದರೆ ಪರಿಶೀಲಿಸುವ ನಿಮ್ಮ ಜವಾಬ್ದಾರಿಯನ್ನು ಕೂಡ ಹೆಚ್ಚಿಸುತ್ತದೆ.

ನೀವು ನಿಮ್ಮೆಲ್ಲಾ ಸಮಯವನ್ನು AI ತಪ್ಪುಗಳನ್ನು ಸರಿಪಡಿಸಲು ಬಳಸುತ್ತಿದ್ದರೆ, ನೀವು ದಕ್ಷತೆಯನ್ನು ಪಡೆದಿಲ್ಲ ಎಂದರ್ಥ. ನೀವು ಕೇವಲ ಒಂದು ರೀತಿಯ ಕೆಲಸವನ್ನು ಮತ್ತೊಂದು ರೀತಿಯ ಕೆಲಸಕ್ಕೆ ಬದಲಾಯಿಸಿದ್ದೀರಿ ಅಷ್ಟೆ.

ಕೊನೆಯ ಹಂತವು (last mile) ಕೋಡ್ ನಿಜವಾಗಿಯೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ಸಾಬೀತುಪಡಿಸುವ ಸ್ಥಳವಾಗಿದೆ. ಪರಿಪೂರ್ಣವಾಗಿ ಕಾಣುವ ಸುಳ್ಳಿನಿಂದ ನೀವು ವಂಚಿತರಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ನೀವು ಇಲ್ಲಿ ಸಾಬೀತುಪಡಿಸುತ್ತೀರಿ.

Source: https://dev.to/amrree/the-illusion-of-efficiency-why-ais-last-mile-costs-everything-a7g

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