సాఫ్ట్వేర్ ఇంజనీరింగ్ అంతమైపోయింది. టెక్ ట్విట్టర్లోని అత్యంత ప్రభావవంతమైన గొంతులు మిమ్మల్ని నమ్మించాలనుకుంటున్నది ఇదే. ఒకే ఒక పేరాగ్రాఫ్ ప్రాంప్ట్తో AI టూల్స్ పూర్తి అప్లికేషన్లను ఎలా తయారు చేస్తున్నాయో చూపిస్తూ, కోడ్ రాయడానికి మనుషులకు ఎందుకు ఇంకా డబ్బులు చెల్లిస్తారో అని వారు ప్రశ్నిస్తున్నారు. ఈ ఆందోళన అర్థం చేసుకోదగినదే, కానీ ఇది అసలు విషయాన్ని పూర్తిగా విస్మరిస్తోంది.
AI ఇంజనీర్ల ఉద్యోగాలను లాక్కోవడానికి రావడం లేదు. టైపింగ్ వేగాన్ని సాంకేతిక నిర్ణయ సామర్థ్యంగా (technical judgment) పొరబడే ఎవరి కోసమైనా అది వస్తోంది. కోడింగ్ మరియు ఇంజనీరింగ్ మధ్య ఒక పెద్ద వ్యత్యాసం ఉంది, ఆ వ్యత్యాసమే ఈ వృత్తి యొక్క అసలు ఉనికి.
మీరు కాఫీ సిప్ చేసేలోపు ఒక ఫీచర్ను అమలు చేయడానికి ఒక AI అసిస్టెంట్ ఐదు రకాల మార్గాలను చూపించగలదు. ఇప్పుడు సమస్య యొక్క స్వభావం మారింది. మనం ఎలా మొదలుపెట్టాలి అని ఆలోచిస్తూ ఖాళీ ఫైల్ను చూస్తూ కూర్చోవడం లేదు. బదులుగా, నిజమైన ట్రాఫిక్ వచ్చినప్పుడు ఏ పరిష్కారం కుప్పకూలిపోకుండా ఉంటుందో అని ఆలోచిస్తూ ఐదు సాధ్యమయ్యే పరిష్కారాలను చూస్తున్నాము. ఆ నిర్ణయమే ఇంజనీరింగ్. మిగిలినదంతా కేవలం సింటాక్స్ (syntax) మాత్రమే.
డెమో అనేది ఉత్పత్తి (Product) కాదు
ఏదైనా AI కోడింగ్ డెమోను గమనిస్తే, నిమిషాల్లో ఒక అందమైన ఇంటర్ఫేస్ తయారైపోవడం మీరు చూస్తారు. కానీ లోడ్ పెరిగినప్పుడు డేటాబేస్ కనెక్షన్ పూల్ (database connection pool) ఎలా ఖాళీ అయిపోతుందో మీరు చూడలేరు. API ఎండ్పాయింట్పై రేట్ లిమిట్స్ (rate limits) లేకపోవడం, ఆడిట్ లాగ్స్ (audit logs) లేకపోవడం, లేదా AI తన సౌలభ్యం కోసం ప్రతి యూజర్ ఇంటరాక్షన్ను ఒక ఆబ్జెక్ట్ బకెట్లోకి సేవ్ చేయడం వల్ల కలిగే స్టోరేజ్ ఖర్చులను కూడా మీరు చూడలేరు.
ప్రొడక్షన్ సిస్టమ్స్కు స్కేలబిలిటీ (scalability), సెక్యూరిటీ (security), పెర్ఫార్మెన్స్ (performance) మరియు ఖర్చు నియంత్రణ (cost control) అవసరం. ఈ లక్షణాలు స్プリント రివ్యూలో (sprint review) కనిపించవు. అసలైన వినియోగదారులు తమ అంచనా వేయలేని ప్రవర్తనతో, ఎడ్జ్ కేస్లతో (edge cases) వచ్చినప్పుడు మాత్రమే ఇవి బయటపడతాయి. QAలో అంతా బాగున్నట్లు కనిపించిన అనేక AI-అసిస్టెడ్ ప్రాజెక్ట్లు, లాంచ్ అయిన వారం తర్వాత భారీ నష్టాలను ఎలా మిగిల్చాయో నేను చూశాను.
పనిచేసే కోడ్ ఇప్పుడు చౌకైపోయింది. కానీ మంచి ఇంజనీరింగ్ కాదు.
ఇప్పుడు ఏది ముఖ్యం
ఈ మార్పులో రాణిస్తున్న ఇంజనీర్లు వేగంగా టైప్ చేసేవారు కాదు. ఒకే ఒక్క లైన్ కోడ్ జనరేట్ కావడానికి ముందే ఏ ప్రశ్నలు అడగాలో తెలిసినవారే వారు.
వారు సమస్యలను స్పష్టంగా నిర్వచిస్తారు. మీరు అనుమతిస్తే, ఒక AI మోడల్ సంతోషంగా తప్పు సమస్యను పరిష్కరిస్తుంది. కేవలం ఆరుగురు అంతర్గత అనలిస్టులు మాత్రమే ఉపయోగించే డ్యాష్బోర్డ్ కోసం అది ఒక సంక్లిష్టమైన క్యాషింగ్ లేయర్ను (caching layer) నిర్మిస్తుంది. అసలు సమస్య డేటాబేస్ ఇండెక్స్ లేకపోవడమా లేదా ప్రాథమికంగా దెబ్బతిన్న డేటా మోడల్ (data model) గురించా అని అది అడగదు. ఒక నైపుణ్యం కలిగిన ఇంజనీర్, పరిష్కారం కోడింగ్తో సంబంధం లేకుండా, సమస్య స్పష్టమయ్యే వరకు దానిని మళ్ళీ మళ్ళీ నిర్వచిస్తారు.
వారు పెద్ద వ్యవస్థలను చిన్న భాగాలుగా విభజిస్తారు. AI లోకల్ కాంటెక్స్ట్లో (local context) అద్భుతంగా పనిచేస్తుంది. అది ఒకే ఫంక్షన్, ఒకే కాంపోనెంట్ లేదా ఒకే టెస్ట్ను రాయగలదు. కానీ మొత్తం డిస్ట్రిబ్యూటెడ్ ఆర్కిటెక్చర్ను (distributed architecture) అర్థం చేసుకోవడంలో అది ఇబ్బంది పడుతుంది. ఒక మోనోలిత్ (monolith) వ్యవస్థను విడగొట్టగలిగే, సర్వీసుల చుట్టూ సరిహద్దులను గీయగలిగే మరియు టీమ్ల మధ్య ఒప్పందాలను (contracts) నిర్వచించగలిగే ఇంజనీర్లే, జనరేట్ చేయబడిన కోడ్ ముక్కలను స్థిరమైన వ్యవస్థలుగా మారుస్తారు.
వారు AI సూచనలను సవాలు చేస్తారు. మోడల్ యొక్క ఆత్మవిశ్వాసం ఒక భ్రమ మాత్రమే. అది నెట్వర్క్ లాటెన్సీని (network latency) విస్మరించే ఆర్కిటెక్చర్లను ప్రతిపాదించవచ్చు, ఏళ్ల క్రితమే నిలిపివేసిన (deprecated) లైబ్రరీలను సిఫార్సు చేయవచ్చు లేదా అవసరాల్లో లేని ఫీచర్లను పరిష్కరించడానికి ప్రయత్నించవచ్చు.