AI కోడింగ్ టూల్స్ గురించి ఇప్పటివరకు ఎక్కువగా డెవలపర్ అసిస్టెంట్లుగానే చర్చ జరిగింది: కొంత కోడ్ రాయడం, ఒక ఎర్రర్ను వివరించడం, టెస్ట్లు తయారు చేయడం, లేదా ఒక మార్పును రివ్యూ చేయడంలో సహాయపడటం.
ఆ హద్దు ఇప్పుడు కదలడం మొదలైంది.
OpenAI ఇటీవల తన Agents APIని పరిచయం చేసింది, ఇది ఫైల్స్తో పనిచేయగల, కోడ్ రన్ చేయగల, టూల్స్ వాడగల, ఇతర ఏజెంట్లను సమన్వయం చేయగల దీర్ఘకాలం పనిచేసే ఏజెంట్లను నిర్మించే మార్గాన్ని డెవలపర్లకు ఇస్తుంది. ఈ ఏజెంట్లు కేవలం ఒక ప్రాంప్ట్-అండ్-రెస్పాన్స్ పనిని మాత్రమే కాకుండా, ఎక్కువ కాలం పాటు పనిచేస్తూనే ఉండగలవని OpenAI చెబుతోంది.
అదే సమయంలో, మరో పరిణామం నా దృష్టిని వేరే కారణంతో ఆకర్షించింది: OpenAI తన సొంత pull requestలకు AIని తప్పనిసరి సెక్యూరిటీ రివ్యూయర్గా వాడుతున్నట్లు తెలుస్తోంది. ఈ రివ్యూలో సెక్యూరిటీ సమస్య కనిపిస్తే, మెర్జ్ను నిలిపివేయవచ్చు.
ఇది AI కోడ్ రివ్యూకు ఒక చిన్న పొడిగింపులా అనిపించవచ్చు.
కానీ అది కాదు.
ఇది డెవలపర్కు సహాయం చేసే AI నుండి కోడ్ ముందుకు వెళ్లగలదా లేదా అనే నిర్ణయంలో భాగమయ్యే AIకి మారే మార్పును సూచిస్తుంది.
CI/CDలో ఆటోమేషన్ను మనం ఇప్పటికే నమ్ముతున్నాం
సాఫ్ట్వేర్ ఆటోమేటిక్గా బ్లాక్ కావడంలో అసాధారణమైనది ఏమీ లేదు.
ఒక pull request ఇప్పటికే ఈ కారణాల వల్ల ఆగిపోవచ్చు:
- బిల్డ్ విఫలమైంది;
- యూనిట్ టెస్ట్లు విఫలమయ్యాయి;
- సెక్యూరిటీ స్కానర్ ఒక వల్నరబిలిటీని కనుగొంది;
- అవసరమైన రివ్యూయర్ మార్పును ఆమోదించలేదు;
- ఒక పాలసీ చెక్ పాస్ కాలేదు.
కాబట్టి పైప్లైన్లో మరో గేట్గా AI రివ్యూ రావడం పూర్తిగా కొత్త ఆలోచనేమీ కాదు.
తేడా నిర్ణయం ఎలా తీసుకోబడుతుందో అనే దానిలో ఉంది.
ఒక టెస్ట్ సాధారణంగా ఒక నిర్దిష్ట పరిస్థితిని చెక్ చేస్తుంది. ఆశించిన ఫలితం ముందే తెలిసి ఉంటుంది.
ఒక AI రివ్యూయర్ కోడ్ను చదవాల్సి రావచ్చు, చుట్టూ ఉన్న లాజిక్ను అర్థం చేసుకోవాల్సి రావచ్చు, ఏదైనా అసురక్షితంగా అనిపిస్తే నిర్ణయించాల్సి రావచ్చు. ఇది మరింత తీర్పు-ఆధారిత నిర్ణయం.
ఈ తీర్పు మెర్జ్ను ఆపగలిగితే, AI ఇక కేవలం సలహా ఇచ్చేది మాత్రమే కాదు. డెలివరీ ప్రాసెస్లో దానికి కొంత అధికారం ఇవ్వబడింది.
దీని అర్థం AI ప్రతిదాన్ని ఆమోదించాలి అని కాదు
ఇక్కడ ఒక ముఖ్యమైన తేడా ఉంది.
అనుమానాస్పదమైన మార్పును AI బ్లాక్ చేయడానికి అనుమతించడం, ఒక మార్పు సురక్షితం అని AI ప్రకటించడానికి అనుమతించడం ఒకటి కాదు.
మోడల్కు అథెంటికేషన్ లేదా అథరైజేషన్ సమస్యలా అనిపించేది కనిపిస్తే, pull requestను ఆపి మరోసారి పరిశీలించమని అడగడం ఉపయోగకరంగా ఉంటుంది.
కానీ మోడల్కు ఏమీ కనిపించకపోతే, దాని అర్థం ఇది కాదు:
కోడ్ సురక్షితం.
దీని అర్థం ఈ నిర్దిష్ట రివ్యూలో ఏ సమస్యా కనిపించలేదు అని మాత్రమే.
మామూలుగా ఉండే నియంత్రణలు—టెస్ట్లు, సెక్యూరిటీ స్కానింగ్, కోడ్ ఓనర్షిప్, హ్యూమన్ రివ్యూ—ఇంకా వాటి పాత్రను కొనసాగిస్తాయి.
AI తప్పు చేస్తే ఏమి జరుగుతుంది?
ఇక్కడే CI/CD గవర్నెన్స్ ముఖ్యమవుతుంది.
ఒక AI రివ్యూయర్ ఒక pull requestను బ్లాక్ చేసిందని అనుకుందాం, కానీ ఆ ఫైండింగ్ ఒక ఫాల్స్ పాజిటివ్ అని ఇంజనీర్కు తెలుసు అనుకుందాం.
కొన్ని సాధారణ ప్రశ్నలకు స్పష్టమైన సమాధానం ఉండాలి:
బ్లాక్ను ఎవరు ఓవరైడ్ చేయగలరు?
ఈ మినహాయింపును మరొక వ్యక్తి రివ్యూ చేయాల్సిన అవసరం ఉందా?
కారణం రికార్డ్ చేయబడుతుందా?
AIని ఎంత తరచుగా ఓవరైడ్ చేస్తున్నారో టీమ్లు చూడగలవా?
AI ప్రత్యేకంగా ప్రమాదకరమైనది కాబట్టి ఈ నియంత్రణలు అవసరం కాదు. తప్పులను ఎదుర్కోవడానికి ఏ తప్పనిసరి నియంత్రణకైనా ఒక మార్గం అవసరం కాబట్టి ఇవి అవసరం.
దీనికి మరో కోణం కూడా ఉంది.
AI ఎక్కువ కోడ్ను రాస్తూ, మరో AI దాన్ని రివ్యూ చేస్తే, రెండు AI దశలు స్వతంత్ర వెరిఫికేషన్ను ఆటోమేటిక్గా ఇస్తాయని టీమ్లు అనుకోకూడదు. రెండు సిస్టమ్లు ఇంకా అదే రకమైన సమస్యలను మిస్ చేయవచ్చు.
ఏజెంట్ గవర్నెన్స్ ఆచరణాత్మకంగా మారడం ఇక్కడే మొదలవుతుంది
Atlassian AIని సాఫ్ట్వేర్-డెవలప్మెంట్ లైఫ్సైకిల్లోకి మరింత లోతుగా తీసుకెళుతూ, ఇప్పటికే “గవర్న్డ్ ఏజెంట్ లూప్స్” అనే పదాన్ని వాడుతోంది.
ఈ దిశ అర్థవంతంగా ఉంది.
కోడ్ రాయడం, టూల్స్ రన్ చేయడం, pull requestలు తయారు చేయడం, డెవలప్మెంట్ సిస్టమ్ల మధ్య పనిచేయడం వంటివి ఏజెంట్లు చేయగలిగే స్థితికి చేరుకుంటున్నప్పుడు, ఇక ప్రశ్న కేవలం ఇది కాదు:
ఏజెంట్ ఏమి చేయగలదు?
టీమ్లు మరో ప్రశ్న కూడా అడగాలి:
ఏజెంట్ ఏమి నిర్ణయించడానికి అనుమతించబడింది?
చాలా సంస్థలకు, తగిన పురోగతి క్రమంగా ఉండవచ్చు:
AI ఒక మార్పును సూచిస్తుంది.
తర్వాత AI ఒక మార్పును తయారు చేస్తుంది.
తర్వాత AI ఒక మార్పును రివ్యూ చేస్తుంది.
బహుశా తర్వాత, కొన్ని మార్పులను బ్లాక్ చేయడానికి AIని అనుమతించవచ్చు.
ప్రతి అడుగు సిస్టమ్కు కొంచెం ఎక్కువ బాధ్యతను ఇస్తుంది.
ఒక ఏజెంట్ను వెంటనే కోడ్ రాయనివ్వడం, దాన్ని ఆమోదించనివ్వడం, డిప్లాయ్ చేయనివ్వడం కంటే ఇది చాలా భిన్నమైనది.
ముఖ్యమైన మార్పు
OpenAI Agents APIలో ఆసక్తికరమైన భాగం, ఏజెంట్లు ఎక్కువ కాలం, మరింత సంక్లిష్టమైన పని చేయగలగడం మాత్రమే కాదు.
ఆ పని చుట్టూ ఉన్న నియంత్రణల్లో ఈ ఏజెంట్లు భాగమైనప్పుడు ఏమి జరుగుతుందో అనేదే మరింత ముఖ్యమైన మార్పు.
డెవలపర్కు సహాయం చేసే AI ఇప్పటికే మనకు పరిచయమే.
“ఈ మార్పు ముందుకు సాగకూడదు” అని చెప్పగలిగే AI అనేది వేరే విషయం.
AI ఏజెంట్లు CI/CD పైప్లైన్లలో భాగమవుతున్న కొద్దీ, టీమ్లు సామర్థ్యాన్ని ఎంత జాగ్రత్తగా చూస్తారో అధికారాన్ని కూడా అంతే జాగ్రత్తగా ఆలోచించాల్సి ఉంటుంది.
ఇక ప్రశ్న AI ఆ పనిని చేయగలదా అనేది మాత్రమే కాదు.
దానికి బదులు, ఆ నిర్ణయంలో ఎంత భాగాన్ని మనం దానికి ఇవ్వడానికి సిద్ధంగా ఉన్నాం అనేది కూడా ప్రశ్నే.