సాఫ్ట్వేర్ ప్రపంచాన్ని ఆక్రమించింది. ఇప్పుడు AI ఒక్కో ఫైల్ను ఒక్కొక్కటిగా సాఫ్ట్వేర్ను తన వశం చేసుకుంటోంది. మీరు జీవనోపాధి కోసం కోడ్ రాస్తుంటే, మీ కీబోర్డ్ కింద నేల కదులుతున్నట్లు మీరు బహుశా అనుభూతి చెంది ఉండవచ్చు. ఒక డెవలపర్ ఒకే సంవత్సరంలో దీనిని రెండుసార్లు అనుభవించారు. మొదట, యంత్రం కోడ్ రాయడాన్ని (writing) తీసుకుంది. ఆ తర్వాత అది తనిఖీ చేయడాన్ని (checking) కూడా తీసుకుంది. ఆయనకు ఇంకా ఉద్యోగం ఉంది, కానీ ఆయన తన పనిని పూర్తిగా మార్చుకున్నందువల్లే అది సాధ్యమైంది.
ఇది వినాశనానికి సంబంధించిన హెచ్చరిక కాదు. ఇది ఈ పరివర్తన ప్రక్రియ మధ్య నుండి వస్తున్న ఒక ఫీల్డ్ రిపోర్ట్.
మొదటి మార్పు: టైపింగ్ నుండి ప్రూఫ్ రీడింగ్ వరకు
ఒకప్పుడు ఆయన వృత్తిని వివరించడం చాలా సులభం: ఆలోచించడం, టైప్ చేయడం, టెస్ట్ చేయడం, షిప్ చేయడం. ఆయన ప్రతి ఫంక్షన్ను స్వయంగా రాసేవారు. వేరియబుల్స్కు పేర్లు పెట్టడం, నెస్టెడ్ లూప్స్ రాయడం మరియు ప్రయత్నం మరియు తప్పుల (effort and error) ద్వారా ఎడ్జ్ కేస్లను (edge cases) గుర్తించడం ఆయన పని. కోడ్ను చదవడం అనేది ఒక ప్రత్యేకమైన పని కాదు. అది సృజన ప్రక్రియలో ఒక భాగం, నెమ్మదిగా పరిశీలించబడే ప్రక్రియ. క్వాలిటీ కంట్రోల్ మరియు ప్రొడక్షన్ ఒకే ప్రక్రియలో జరిగేవి.
ఆ తర్వాత ఆటోకంప్లీట్ (autocomplete) కేవలం చిన్న సహాయంగా ఉండటం ఆగిపోయింది.
AI కోడింగ్ అసిస్టెంట్లు కేవలం తదుపరి కీవర్డ్ను సూచించడం మానేసి, పూర్తి క్లాస్లు (classes), డేటాబేస్ మైగ్రేషన్లు (database migrations) మరియు API రాపర్లను (API wrappers) అందించడం ప్రారంభించాయి. డెవలపర్ చేతులు అరో కీస్ (arrow keys) నుండి రివ్యూ పేన్ (review pane) వైపు మళ్ళాయి. ఆయన కోడ్ రాసే ప్రక్రియను కోల్పోయారు, కానీ తాను సురక్షితంగా ఉన్నానని తనను తాను నమ్మారు. ఆయన ఇంకా ప్రతి లైన్ను చదివేవారు. లాజిక్ యొక్క రూపాన్ని విశ్లేషించేవారు. ఆయన ఒక ఎడిటర్, ఒక గేట్కీపర్, మరియు 'హ్యూమన్ ఇన్ ది లూప్' (human in the loop).
నియంత్రణ మన చేతుల్లోనే ఉందనే భ్రమ వల్ల ఈ మార్పును తట్టుకోగలమని అనిపిస్తుంది. మీరు ఇంకా కోడ్ను తాకుతున్నారు. మీరు ఇంకా 'ఆఫ్-బై-వన్' (off-by-one) ఎర్రర్ల కోసం వెతుకుతున్నారు. కానీ మీ పాత్ర ఇప్పటికే మారిపోయింది. మీరు ఇక రచయిత కాదు. యంత్రం చేసే తప్పుల (hallucinations) నుండి రక్షణ కల్పించే మొదటి వరుస మీరు.
రెండవ మార్పు: చదవడం నుండి నమ్మడం వరకు
రెండవ మార్పు మరింత బలంగా తగిలింది.
మానవ ప్రమేయం లేకుండా గంటల తరబడి పనిచేయగలిగేంత వేగంగా AI ఏజెంట్లు అభివృద్ధి చెందాయి. ఆయన కాఫీ తాగడానికి వెళ్ళినంత సేపు, అవి స్క్యాఫోల్డింగ్ (scaffolding) సిద్ధం చేయడం, లెగసీ మాడ్యూల్స్ను రీఫ్యాక్టర్ (refactor) చేయడం మరియు డిపెండెన్సీలను (dependencies) సరిచేయడం వంటి పనులు చేయగలవు. అవుట్పుట్ (throughput) సమస్య కాదు. ఆయన చదివే వేగమే సమస్యగా మారింది.
ప్రాజెక్ట్ను ముందుకు తీసుకెళ్లడానికి, ఆయన ప్రతి లైన్ను చదవడం ఆపాల్సి వచ్చింది. వేరే దారి లేదు. ఆయన ఆమోదించే వేగం కంటే ఫ్యాక్టరీ వేగంగా ఉత్పత్తి చేయగలదు. నమ్మకం అనేది ఒక గుణం కాదు, అది ఒక అవసరంగా మారింది. ఆయన ప్రూఫ్ రీడర్ నుండి ఆపరేషన్స్ మేనేజర్గా మారారు, ఒక స్ప్రింట్లో (sprint) ఆయన ఏడాదిలో రాసే దానికంటే ఎక్కువ కోడ్ను ఉత్పత్తి చేసే వ్యవస్థను ఆయన పర్యవేక్షిస్తున్నారు.
ఆయన ఆ అనుభవాన్ని నిజాయితీగా ఇలా వివరించారు: ఆయన ఇక కోడర్ కాదు. ఆయన కళ్ళ కంటే వేగంగా కన్వేయర్ బెల్టులు కదిలే ఒక మెషిన్ ఫ్యాక్టరీని నిర్వహిస్తున్నారు.
అడ్డంకి (Bottleneck) పైకి మారుతోంది
ఇక్కడ మనం గమనించని విషయం ఏమిటంటే, అడ్డంకి మాయం కాలేదు, అది కేవలం స్థానాన్ని మార్చుకుంది.
మనుషులు కోడ్ రాసినప్పుడు, ఆలస్యం అనేది మెదడు మరియు IDE మధ్య ఉండేది. డెవలపర్ అత్యంత నెమ్మదిగా పనిచేసే భాగం, అది అప్పట్లో ఆమోదయోగ్యమే. AI కోడ్ రాయడం ప్రారంభించగానే, అడ్డంకి 'హ్యూమన్ రివ్యూ' (human review) వద్దకు మారింది. ఆ తర్వాత, ఏజెంట్లు గంటల తరబడి స్వయంగా పనిచేయగలిగినప్పుడు, అడ్డంకి 'హ్యూమన్ డిసిషన్ మేకింగ్' (human decision-making) వద్దకు మారింది. ఏజెంట్లు దేనిపై పని చేయాలి? దేనిని ఆటోమేట్ చేయడం సురక్షితం? దేనిని మళ్ళీ ఒకసారి పరిశీలించాలి?
మేనేజర్ ఆమోదించే వేగం కంటే ఫ్యాక్టరీ వేగంగా ఉత్పత్తి చేస్తుంది. సమస్య ఇప్పుడు యంత్రం యొక్క వేగం కాదు. సమాచారాన్ని గ్రహించి, తీర్పునిచ్చి, దిశానిర్దేశం చేసే మానవ సామర్థ్యం.
ఈ అడ్డంకి యొక్క మార్పును మీరు గమనించకపోతే, తదుపరి టూల్ తొలగించడానికి రూపొందించబడే అడ్డంకిగా మీరు మారిపోతారు.
మూడు పునర్నిర్మాణాలు, ఒకే కెరీర్
ఈ రెండు దశలను తట్టుకోవడానికి ఆయన తన పాత్రను మూడు సార్లు పునర్నిర్మించుకోవాల్సి వచ్చింది.
మొదటిది, ఆయన కోడ్ రాయడం నుండి కోడ్ చదవడం వైపు మళ్లారు. అంటే, ఓపెన్ సోర్స్ రిపోజిటరీలు (open-source repos) మరియు ఫోరమ్ థ్రెడ్లపై శిక్షణ పొందిన మోడల్ ద్వారా సృష్టించబడిన బాయిలర్ప్లేట్ (boilerplate) కోడ్లో సూక్ష్మమైన బగ్ల కోసం వెతుకుతూ, అనుమానంతో చదవడం నేర్చుకోవడం. ఒక సూచన సరిగ్గా ఉన్నట్లు అనిపించినా, అందులో ఏదో తేడా ఉందని గుర్తించే నైపుణ్యాన్ని పెంపొందించుకోవడం, ఇది మొదటి నుండి కోడ్ రాసే నైపుణ్యం కంటే పూర్తిగా భిన్నమైనది.
తర్వాత, ఆయన కోడ్ చదవడం నుండి వర్క్ఫ్లోలను (workflows) నిర్మించడం వైపు మళ్లారు. ప్రస్తుతం చాలా మంది డెవలపర్లు ఇక్కడే ఉన్నారు. మీరు ఫంక్షన్లను సరిచేయడం లేదు; ఫంక్షన్లు సరిచేయబడే వాతావరణాన్ని (environment) మీరు రూపొందిస్తున్నారు. మీరు ప్రాంప్ట్లను (prompts) రాస్తారు, సిస్టమ్ సూచనలను (system instructions) రూపొందిస్తారు, గార్డ్రైల్స్ను (guardrails) సెట్ చేస్తారు మరియు CI గేట్లను (CI gates) కాన్ఫిగర్ చేస్తారు. మీరు ఏజెంట్ను కంపైలర్ (compiler), లీంటర్ (linter) మరియు టెస్ట్ సూట్కు (test suite) అనుసంధానించే వ్యవస్థను నిర్మిస్తారు. మీ అవుట్పుట్ సింటాక్స్ (syntax) కంటే ఆర్కెస్ట్రేషన్ (orchestration) పై ఎక్కువగా ఉంటుంది.
చివరగా, ఆయన వర్క్ఫ్లోలను నిర్మించడం నుండి ఏమి నిర్మించాలో నిర్ణయించడం వైపు మళ్లారు. ఇది అత్యున్నత స్థాయి. మొదటి ఫైల్ సృష్టించబడకముందే మీరు ఆర్కిటెక్చర్ను (architecture) ఎంచుకుంటారు. AI నింపే పరిమితులు (constraints), ఇంటర్ఫేస్లు (interfaces) మరియు బిజినెస్ లాజిక్ (business logic) ను మీరు నిర్వచిస్తారు. మీరు సిస్టమ్స్ భాషలో మాట్లాడే ఒక ప్రొడక్ట్ థింకర్ (product thinker) గా మారారు.
అతను మొదటి దశలోనే ఉండిపోయి ఉంటే, అతనికి పూర్తిగా బదులు వచ్చేది. అతను ఇంకా జీతం పొందుతున్నాడంటే దానికి ఏకైక కారణం అతను మూడవ దశకు చేరుకోవడం.
కానీ ఆ ఎదుగుదల...