చాలా మంది ఇంజనీర్లు AIని ఉపయోగిస్తారు. కొద్దిమంది మాత్రమే దానితో ఇంజనీరింగ్ చేస్తారు.
ప్రస్తుతం చాలా మంది సాఫ్ట్వేర్ ఇంజనీర్లు AIని ఉపయోగిస్తున్నారు.
వారు దీనిని డీబగ్గింగ్ (debugging), టెస్ట్లు రాయడం లేదా SQL క్వెరీలను (SQL queries) రూపొందించడానికి ఉపయోగిస్తారు. AIని ఉపయోగించడం సులభం. కానీ AIతో ఇంజనీరింగ్ చేయడం చాలా కష్టం.
రియల్ రిపోజిటరీ టాస్క్లపై (real repository tasks) AIని ఉపయోగిస్తున్నప్పుడు నేను ఒక సమస్యను గమనించాను. ఒక తప్పు మార్పు కేవలం తప్పుడు అవుట్పుట్ను మాత్రమే ఇవ్వదు. అది మీ స్ట్రక్చర్ను, మీ టెస్ట్లను మరియు భవిష్యత్తులో మెయింటెనెబిలిటీని (maintainability) దెబ్బతీస్తుంది.
కోడ్ జనరేషన్ (code generation) భాగం సులభం. ఒక సాధారణ ప్రాంప్ట్ (prompt) త్వరగా కోడ్ను అందిస్తుంది. మొదటి చూపులో అది చాలా క్లీన్గా కనిపిస్తుంది.
మీరు ముందుగా బోరింగ్ పనులను చేసినప్పుడు మాత్రమే ఉపయోగకరమైన ఫలితాలు వస్తాయి. మీరు తప్పనిసరిగా:
- అవసరాలను (requirement) నిర్వచించాలి.
- పరిధిని (scope) పరిమితం చేయాలి.
- పరిమితులను (constraints) వివరించాలి.
- మార్పును ఎలా ధృవీకరించాలో (verify) నిర్ణయించుకోవాలి.
నైపుణ్యం అనేది ప్రాంప్టింగ్ (prompting) లో లేదు. నైపుణ్యం అనేది పనిని సరైన రూపంలోకి తీసుకురావడంలో (shaping the work) ఉంది.
AI అవుట్పుట్ వేగాన్ని పెంచుతుంది. కానీ అది వెరిఫికేషన్ (verification) నాణ్యతను పెంచదు. కోడ్ వేగంగా జనరేట్ అవుతుంటే, అస్పష్టమైన అవసరాలు (unclear requirements) మరింత ఖరీదైనవిగా మారుతాయి. బలహీనమైన రివ్యూలు (weak reviews) మరింత ప్రమాదకరంగా మారుతాయి.
AI మీ ప్రస్తుత ఇంజనీరింగ్ లూప్ను (engineering loop) మరింత పెంచుతుంది.
అవసరాలు అస్పష్టంగా ఉంటే, AI ఏదో ఒకటి ఉత్పత్తి చేస్తుంది. ఆర్కిటెక్చర్ (architecture) గందరగోళంగా ఉంటే, AI కూడా అదే గందరగోళాన్ని కాపీ చేస్తుంది. మీరు అవుట్పుట్ను రివ్యూ చేయలేకపోతే, వేగం అనేది ఒక రిస్క్గా మారుతుంది.
AI ఇంజనీర్ల స్థానాన్ని భర్తీ చేస్తుందా లేదా అనేది ప్రశ్న కాదు. కోడ్ చౌకగా దొరుకుతున్నప్పుడు, ఇంజనీరింగ్లో ఏ భాగాలు మరింత ముఖ్యమైనవి అవుతాయి? అనేదే అసలు ప్రశ్న.
నా సమాధానం: ఇంప్లిమెంటేషన్ (implementation) కంటే ముందు స్పష్టంగా ఆలోచించడం.
AI పాత సలహాలను మరింత ముఖ్యమైనవిగా మారుస్తుంది:
- రెండుసార్లు ఆలోచించండి, ఒక్కసారి మాత్రమే కోడ్ చేయండి.
- AIని నిర్మించమని అడగకముందే సమస్యను నిర్వచించండి.
- ఒక సమాధానాన్ని అంగీకరించే ముందు ట్రేడ్ఆఫ్స్ను (tradeoffs) తనిఖీ చేయండి.
- మెర్జ్ (merge) చేసే ముందు ప్రవర్తనను (behavior) ధృవీకరించండి.
ఇంజనీరింగ్ అనేది కోడ్ రాయడం నుండి సరైన మార్పును రూపొందించడం (shaping the right change) వైపు మారుతోంది.
AIని ఒక స్ట్రక్చర్ అవసరమయ్యే సహకారిగా (collaborator) పరిగణించండి. ఒక మంచి లూప్ ఇలా ఉంటుంది: Requirement → Gaps → Plan → Small change → Review → Checks → Notes.
నిజమైన ఇంజనీరింగ్ అంటే కోడ్ను ఉత్పత్తి చేయడం కాదు. అది నమ్మదగిన మార్పును (reliable change) ఉత్పత్తి చేయడం.
ఎక్కువ కోడ్ను జనరేట్ చేయడంలో లాభం లేదు. ఏమి నిర్మించాలో మరియు అది మీ సిస్టమ్కు ఎలా సరిపోతుందో తెలుసుకోవడంలోనే అసలైన లాభం ఉంది.
విజేతలు వేగంగా ప్రాంప్ట్ రాసే ఇంజనీర్లు కాలేరు. వారు ఆ టూల్ చుట్టూ మెరుగైన వర్క్ఫ్లోలను (workflows) రూపొందించే వారు అవుతారు.
Source: https://dev.to/jeelvankhede/most-engineers-use-ai-few-engineer-with-it-3pd
Optional learning community: https://t.me/GyaanSetuAi