సామర్థ్యం యొక్క భ్రమ: AI యొక్క 'లాస్ట్ మైల్' (Last Mile) అంతా నష్టాన్ని కలిగిస్తుంది

మీరు AI కోడ్ యొక్క 80/20 నియమం గురించి చదివి తల ఊపుతారు.

AI మీ కోడ్‌లోని మొదటి 80%ని సెకన్లలో రాస్తుంది. అది పురోగతిలా కనిపిస్తుంది. అది వేగంలా అనిపిస్తుంది.

ఇది ఒక ఉచ్చు.

పనిలోని చివరి 20% పూర్తి చేయడానికి మీ సమయం 80% పడుతుంది. ఇక్కడే ప్రాజెక్టులు ఆగిపోతాయి. ఇక్కడే డెవలపర్లు విసిగిపోతారు.

AI సంభావ్యత (probability) ఆధారంగా పనిచేస్తుంది. ఇది తదుపరి వచ్చే పదం లేదా కోడ్ లైన్‌ను అంచనా వేస్తుంది. దీనికి లాజిక్ అర్థం కాదు. దీనికి మీ నిర్దిష్ట సిస్టమ్ ఆర్కిటెక్చర్ అర్థం కాదు. ఇది కేవలం అనుకూల పరిస్థితుల్లో మాత్రమే పనిచేసే ఒక "హ్యాపీ పాత్" (happy path)ను సృష్టిస్తుంది.

మీరు ఆ హ్యాపీ పాత్ దాటినప్పుడు, సమస్యలు ఎదురవుతాయి.

నేను దీనిని 'వెరిఫికేషన్ డెట్' (Verification Debt) అని పిలుస్తాను.

టెక్నికల్ డెట్ (Technical debt) త్వరిత పరిష్కారాల వల్ల వస్తుంది. వెరిఫికేషన్ డెట్ అవగాహన లేకపోవడం వల్ల వస్తుంది.

మీరు స్వయంగా కోడ్ రాసినప్పుడు, మీరు ఒక మానసిక నమూనాను (mental map) నిర్మించుకుంటారు. ప్రతి లైన్ ఎందుకు ఉందో మీకు తెలుస్తుంది. AI కోడ్ రాసినప్పుడు, మీరు నిర్మించని ఒక పూర్తి ఉత్పత్తి మీకు అందుతుంది. ఆ లాజిక్ మీది కాదు. మీకు కేవలం ఫలితం మాత్రమే తెలుస్తుంది.

మీకు కోడ్ అర్థం కాకపోతే, మీరు దానిని డీబగ్ (debug) చేయలేరు. AI కేవలం ఒక సెకనులో చేసిన తప్పును సరిదిద్దడానికి మీరు గంటల కొద్దీ సమయం వెచ్చిస్తారు.

కోడ్ జనరేషన్ వేగం పని పూర్తయిందనే భ్రమను కలిగిస్తుంది. మీరు దాదాపు పని ముగిసిందని అనుకుంటారు. కానీ అప్పుడు ఎడ్జ్ కేసెస్ (edge cases) వస్తాయి. ఇంటిగ్రేషన్ (Integration) విఫలమవుతుంది. సెక్యూరిటీ లోపాలు కనిపిస్తాయి.

చివరి 20% అనేది కేవలం "ఫినిషింగ్ టచ్‌లు" మాత్రమే కాదు. అది నాణ్యత యొక్క మూలం. అది టెస్టింగ్, డీబగ్గింగ్ మరియు ఎడ్జ్-కేస్ హ్యాండ్లింగ్.

దీనిని మీరు ఎలా సరిదిద్దాలి?

AI అవుట్‌పుట్‌ను తుది ఉత్పత్తిగా చూడటం ఆపండి. దానిని నమ్మలేని డేటాగా (untrusted data) పరిగణించండి.

  • మొదట టెస్ట్‌లను రాయండి. టెస్ట్‌లను రూపొందించే ముందు ఎప్పుడూ లాజిక్‌ను జనరేట్ చేయకండి. AI సమాధానం చెప్పకముందే వైఫల్యం (failure) ఎలా ఉంటుందో నిర్వచించండి.
  • విభాగాల వారీగా ధృవీకరించండి (Validate). లోపాలను కనుగొనడానికి పూర్తి సిస్టమ్ ఇంటిగ్రేషన్ కోసం వేచి చూడకండి. ప్రతి చిన్న బ్లాక్‌ను విడిగా పరీక్షించండి.
  • ప్యాచ్ చేసే బదులు తొలగించండి. ఒకవేళ 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