GitHub Copilot, ChatGPT, లేదా Cursor ఉపయోగించడం ప్రారంభించిన డెవలపర్లు తరచుగా ఒకే రకమైన 'హనీమూన్ ఫేజ్' (honeymoon phase) గురించి వివరిస్తారు. ఒకప్పుడు రెండు గంటలు పట్టే పనులు ఇప్పుడు ఇరవై నిమిషాల్లో పూర్తవుతున్నాయి. ఒక ట్యాబ్ కీతో బాయిలర్ప్లేట్ కోడ్ మాయమైపోతుంది. అయితే, త్వరలోనే ఫోరమ్లు మరియు Slack ఛానెల్లలో ఒక నిశ్శబ్ద ఫిర్యాదు వినిపించడం మొదలవుతుంది: అలసట (exhaustion). టూల్ కోడ్ను రాస్తుంది, కానీ ఆ ప్రక్రియలో ఏదో ఒకటి మిమ్మల్ని నీరసపరుస్తుంది. సమస్య కోడ్తో సంబంధం లేదు. అది ఆ కోడ్ను అర్థం చేసుకోవడం మరియు తనిఖీ చేయడంలో ఉన్న శ్రమ.
ఎవరూ ఊహించని అడ్డంకి
దశాబ్దాలుగా, సాఫ్ట్వేర్ ఇంజనీరింగ్లో పరిమితి టైపింగ్ వేగం. మీరు ఎంత వేగంగా ఆలోచించినా, మీ వేళ్లు మరియు మీ సింటాక్స్ (syntax) పరిజ్ఞానం ఒక గరిష్ట స్థాయిని నిర్ణయించేవి. AI అసిస్టెంట్లు ఆ గరిష్ట స్థాయిని కూల్చివేశాయి. మీరు మొదటి బ్లాక్ను చదవడం పూర్తి చేయకముందే, అవి బహుళ ఫైళ్లలో వందలాది లైన్లను ఉత్పత్తి చేయగలవు. ఆ వేగం స్వేచ్ఛలా అనిపించవచ్చు, కానీ అది ఊహించని ట్రాఫిక్ జామ్ను సృష్టిస్తుంది. అకస్మాత్తుగా, పైప్లైన్లో అత్యంత నెమ్మదైన భాగం స్క్రీన్పై కనిపించిన దానిని చదవడం, అర్థం చేసుకోవడం మరియు ధృవీకరించడం (verify) అనే మీ సామర్థ్యం అవుతుంది. మీరు మీ స్వంత ప్రాజెక్ట్కు పూర్తి స్థాయి కోడ్ రివ్యూయర్గా మారిపోయారు, అయితే ఇక్కడ రచయిత ఎప్పుడూ నిద్రపోని, ఎప్పుడూ అలసిపోని ఒక అల్గారిథమ్.
ఈ శ్రమ యొక్క విలోమం కోడింగ్ సెషన్ యొక్క స్వభావాన్ని మారుస్తుంది. సృష్టి (creation) మరియు తేలికపాటి ధృవీకరణ (verification) మధ్య మారుతూ ఉండటానికి బదులుగా, మీరు సుదీర్ఘమైన వ్యాలిడేషన్ మోడ్లో చిక్కుకుపోతారు. మరియు వ్యాలిడేషన్ అనేది కేవలం చదవడం మాత్రమే కాదు. అది అనుమానంతో కూడిన చురుకైన విశ్లేషణ. ప్రతి వేరియబుల్ పేరు, ప్రతి బౌండరీ కండిషన్ మరియు ప్రతి ఇంపోర్ట్ స్టేట్మెంట్ మానసిక వడపోత (mental filter) ద్వారా వెళ్లాలి, ఎందుకంటే AIకి ఆ పనిలో ఎటువంటి వ్యక్తిగత బాధ్యత ఉండదు. ప్రొడక్షన్ జాబ్ విఫలమైనప్పుడు రాత్రి 3 గంటలకు ఎవరూ దానిని పిలవరు.
మీ మెదడు ఎందుకు విఫలమవుతుంది
ఈ అలసట సోమరితనం కాదు. ఇది భారీ స్థాయిలో వచ్చే అవుట్పుట్ మరియు పరిమిత మానవ సామర్థ్యం మధ్య జరిగే ఊహించదగిన ఘర్షణ.
పరిమాణం వల్ల కలిగే ఒత్తిడి (Volume overload). ఒక సాధారణ AI సూచనలో ఒక పూర్తి React కాంపోనెంట్, దాని స్టైలింగ్ లాజిక్, యుటిలిటీ ఫంక్షన్లు మరియు యూనిట్ టెస్ట్లు అన్నీ ఒకేసారి ఉండవచ్చు. మీ వర్కింగ్ మెమరీ ఒకేసారి పరిమిత సమాచారాన్ని మాత్రమే నిల్వ చేయగలదు. స్క్రీన్ డజన్ల కొద్దీ కొత్త లైన్లతో నిండినప్పుడు, మీ మెదడు వాటిని అబ్స్ట్రాక్ట్ ప్యాటర్న్లుగా కుదించాలి లేదా వాటిని వరుసగా స్కాన్ చేయాలి. ఈ రెండు పద్ధతులు కూడా మీ ఏకాగ్రతను ఖర్చు చేస్తాయి. ఇలాంటి బ్లాక్లను రివ్యూ చేసిన తర్వాత, మానసిక అలసట మొదలవుతుంది. మీరు చదువుతున్నారు, కానీ మీరు ఇక నిజంగా అర్థం చేసుకోవడం లేదు.
నమ్మకంలో లోటు (The trust gap). AI-జనరేటెడ్ కోడ్ చూడటానికి చాలా నమ్మదగినదిగా ఉంటుంది. ఇండెంటేషన్ (Indentation) పర్ఫెక్ట్గా ఉంటుంది. వేరియబుల్ పేర్లు అర్థవంతంగా ఉంటాయి. కామెంట్లు కూడా సరైన చోట కనిపిస్తాయి. కానీ నమ్మదగినదిగా కనిపించినంత మాత్రాన అది ఖచ్చితమైనది అని కాదు. ఆ కోడ్ పాతబడిన (deprecated) APIని ఉపయోగించవచ్చు, null ఇన్పుట్లతో కూడిన ఎడ్జ్ కేస్ను (edge case) వదిలివేయవచ్చు లేదా సూక్ష్మమైన SQL ఇంజెక్షన్ వెక్టార్ను పరిచయం చేయవచ్చు. ఇది జరగవచ్చని మీకు తెలుసు కాబట్టి, మీరు దానిని త్వరగా చదివి వదిలేయలేరు. మీరు ప్రతి రిటర్న్ స్టేట్మెంట్ మరియు ప్రతి లాజిక్ బ్రాంచ్ను సెక్యూరిటీ ఆడిట్ లాగా చాలా జాగ్రత్తగా పరిశీలించాలి. గంటల తరబడి కొనసాగే ఆ స్థాయి పరిశీలన మానసిక శక్తిని అధికంగా ఖర్చు చేస్తుంది. విమానాశ్రయ భద్రతా స్క్రీనర్లు తక్కువ సమయం మాత్రమే పని చేసే కారణం కూడా ఇదే: నిరంతర అప్రమత్తత త్వరగా క్షీణిస్తుంది.
పని విధానంలో అసమతుల్యత (Workflow mismatch). చాలా డెవలప్మెంట్ ఎన్విరాన్మెంట్లు మరియు టీమ్ ప్రక్రియలు ఇప్పటికీ మనిషి రాసి, ఆపై టెస్ట్ చేసే క్రమాన్ని అనుసరిస్తాయి. కోడ్బేస్ మానవ వేగంతో పెరుగుతుంది మరియు కోడ్ రివ్యూలు షెడ్యూల్ చేయబడిన బ్యాచ్లలో జరుగుతాయి. AIని ఆ పైప్లైన్లోకి నెట్టినప్పుడు, ఆ ప్రవాహం దెబ్బతింటుంది. మీరు ఇరవై లైన్లను జనరేట్ చేస్తారు, ధృవీకరించడానికి ఆగుతారు, సవరణ కోసం అడుగుతారు, మళ్ళీ ధృవీకరిస్తారు, తదుపరి ఫంక్షన్కు వెళ్తారు మరియు మొత్తం ఆర్కిటెక్చర్ యొక్క సారాంశాన్ని కోల్పోతారు. సృజనాత్మక జనరేషన్ మరియు సందేహాస్పద ధృవీకరణ మధ్య నిరంతరం జరిగే కాంటెక్స్ట్ స్విచ్చింగ్ (context switching) ఘర్షణను కలిగిస్తుంది. మీ IDE రచయితల కోసం రూపొందించబడింది, నిరంతర డెడ్లైన్ కింద పనిచేసే ఎడిటర్ల కోసం కాదు.
అలసట చక్రం
ఈ అంశాలు రోజు గడిచేకొద్దీ మరింత తీవ్రమయ్యే ఒక చక్రానికి దారితీస్తాయి.
అసిస్టెంట్ సెకన్లలో ఒక ఫీచర్ ఇంప్లిమెంటేషన్ను అందిస్తుంది. మీరు ఆపై ఇంపోర్ట్లను ట్రాస్ చేయడానికి, టైప్ కాంపాటబిలిటీని తనిఖీ చేయడానికి మరియు ఎడ్జ్ కేస్ల మానసిక అనుకరణలను (mental simulations) చేయడానికి పదిహేను నిమిషాలు గడుపుతారు. మూడవ లేదా నాల్గవ రౌండ్ వచ్చేసరికి, మీ ఏకాగ్రత తగ్గుతుంది. "చాలా వరకు సరిగ్గా ఉన్నట్లు" అనిపించే స్నిప్పెట్లను మీరు అంగీకరించడం ప్రారంభిస్తారు. తప్పులు జారిపోతాయి. దీనిని భర్తీ చేయడానికి, మీరు వేగాన్ని తగ్గిస్తారు, ఇది మీరు మొదట పొందిన వేగాన్ని వృధా చేస్తుంది. మీరు రోజు చివరలో సాధారణం కంటే ఎక్కువ కోడ్తో ముగిస్తారు కానీ దానిపై తక్కువ నమ్మకంతో ఉంటారు మరియు మీరు తెలివిగా కాకుండా కష్టపడి పనిచేశారని చెప్పే తలనొప్పితో బాధపడతారు.
వేగం ప్రమాదకరంగా మారినప్పుడు
ఈ విధానం అలవాటుగా మారితే, నష్టం కేవలం ఒక చెడు మధ్యాహ్నానికే పరిమితం కాదు.
బర్న్అవుట్ (Burnout) నిశ్శబ్దంగా వస్తుంది. ప్రాజెక్ట్ను ఓపెన్ చేసినప్పుడు కలిగే భయం లేదా చిరాకు లేకుండా మరో కోడ్ బ్లాక్ను చూడలేకపోవడం వంటి లక్షణాలతో ఇది కనిపిస్తుంది. మీకు సహాయం చేయాల్సిన ప్రధాన సాధనమే అలసటకు ప్రధాన కారణం అయినప్పుడు, దాని పట్ల అసహనం మొదలవుతుంది.
ఆ తర్వాత నైపుణ్య క్షీణత (skill atrophy) ఉంటుంది. మీరు దానిని చేయడం ఆపివేసినప్పుడు, ఉద్దేశ్యాన్ని (intent) సింటాక్స్గా (syntax) మార్చే సామర్థ్యం బలహీనపడుతుంది. మీరు ఇప్పటికీ సిస్టమ్స్ను చక్కగా ఆర్కిటెక్ట్ చేయవచ్చు, కానీ సూక్ష్మమైన ప్రావీణ్యం — అంటే ఒక నిర్దిష్ట లూప్ స్ట్రక్చర్ ఎందుకు సరిగ్గా లేదని తెలుసుకోవడం లేదా లోడ్ ఉన్నప్పుడు ఒక నిర్దిష్ట లైబ్రరీ ఎలా ప్రవర్తిస్తుందో గుర్తుంచుకోవడం వంటివి — ఆటోకంప్లీట్ లేయర్ వివరాలను చూసుకున్నప్పుడు క్రమంగా తగ్గిపోతాయి. కాలక్రమేణా, మీరు ఒక క్రియాశీల ఇంజనీర్ కంటే కేవలం ఒక నిష్క్రియ క్యూరేటర్ గా మారే ప్రమాదం ఉంది.
అయితే, అత్యంత తక్షణ ప్రమాదం ఏమిటంటే అజాగ్రత్తగా డిప్లాయ్ చేయడం (sloppy deployment). వేగాన్ని కొనసాగించాలనే ఒత్తిడిలో మరియు గంటల తరబడి మెషిన్ అవుట్పుట్ను చదవడం వల్ల అలసిపోయి, డెవలపర్లు కొన్నిసార్లు తాము పూర్తిగా ధృవీకరించని కోడ్ను డిప్లాయ్ చేస్తారు.