𝗦𝗽𝗲𝗰-𝗗𝗿𝗶𝘃𝗲𝗻 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁 𝗗𝗶𝗱𝗻'𝘁 𝗦𝗼𝗹𝘃𝗲 𝗧𝗵𝗲 𝗥𝗲𝗮𝗹 𝗣𝗿𝗼𝗯𝗹𝗲𝗺
AI ఏజెంట్లు తప్పు కోడ్ను రాస్తున్నాయనే సమస్యకు Spec-driven development (SDD) ఒక కొత్త పరిష్కారం.
దీని వర్క్ఫ్లో చాలా సరళమైనది. మీరు ఒక స్ట్రక్చర్డ్ స్పెక్ను (structured spec) రాస్తారు. ఒక ఏజెంట్ ఆ ప్లాన్ను అమలు చేస్తుంది. మీరు ఫలితాన్ని సమీక్షిస్తారు. GitHub Spec Kit, OpenSpec, మరియు Kiro వంటి సాధనాలు ఈ మార్పుకు నాయకత్వం వహిస్తున్నాయి.
ఈ విధానం సాధారణ ప్రాంప్టింగ్ (raw prompting) కంటే మెరుగ్గా పనిచేస్తుంది. కానీ ఇందులో ఒక పెద్ద లోపం ఉంది.
స్పెక్ అనేది ఎప్పుడూ 'source of truth' గానే ఉండాలని ఇది భావిస్తుంది. కానీ ఇది నిజం కాదు.
గత 20 ఏళ్లుగా, డాక్యుమెంటేషన్ను కోడ్తో సింక్ (sync) లో ఉంచడానికి మేము ప్రయత్నించాము. డిజైన్ డాక్స్, వికీలు మరియు READMEలు అన్నీ విఫలమయ్యాయి. ఎందుకు? ఎందుకంటే కోడ్ను ఎడిట్ చేయడం వేగంగా ఉంటుంది మరియు తక్షణ విలువను అందిస్తుంది. డాక్యుమెంట్ను ఎడిట్ చేయడం నెమ్మదిగా ఉంటుంది మరియు దాని వల్ల కనిపించే ఫలితం ఏమీ ఉండదు. వేగం ముందు డాక్యుమెంటేషన్ ఎప్పుడూ ఓడిపోతుంది.
SDD కూడా ఇదే సమస్యను ఎదుర్కొంటోంది.
ఒక ఏజెంట్ ఏదైనా పరిమితిని (constraint) ఎదుర్కొన్నప్పుడు, అది పని చేయడానికి కోడ్ను సరిచేస్తుంది. ఇప్పుడు కోడ్ మరియు స్పెక్ సరిపోలవు. కొన్ని రోజుల్లోనే ఆ స్పెక్ పనికిరాకుండా పోతుంది. దీనిని సరిచేయడానికి "discipline" పాటించాలని చాలా ఫ్రేమ్వర్క్లు చెబుతాయి. కానీ గతంలో ప్రతిసారీ ఆ డిసిప్లిన్ మాకు విఫలమైంది.
కోడింగ్ ప్రారంభించకముందే పూర్తి స్పెక్ను రాయడం అంటే, ఇంప్లిమెంటేషన్ సమయంలో మీరు ఏమీ నేర్చుకోరు అని అర్థం. ఇది ఫీడ్బ్యాక్ లూప్ను దెబ్బతీస్తుంది. ఇది అజైల్ డెవలప్మెంట్ను (agile development) ఒక భారమైన, ముందస్తు ప్రక్రియగా మారుస్తుంది.
ఒక డెవలపర్ SDDని ఉపయోగించి నెలల తరబడి సాగే ప్రాజెక్ట్ను నిర్వహించారు. ఏజెంట్ ప్రతి స్పెక్ను ఖచ్చితంగా పాటించింది. అయినప్పటికీ సిస్టమ్ విఫలమైంది. బిల్డింగ్ సమయంలో మాత్రమే తెలిసే జ్ఞానాన్ని స్పెక్ అందుకోలేకపోయింది. ఒక చిన్న infra మార్పు మొత్తం spec graphను దెబ్బతీసింది.
మరొక టీమ్ SDDని ప్రయత్నించి, అది 10 రెట్లు నెమ్మదిగా ఉందని కనుగొంది. వారికి ఎక్కువ ఫార్మాలిటీలు (ceremony) ఉన్నాయి కానీ బగ్స్ సంఖ్య మాత్రం మారలేదు.
లక్ష్యం ఎక్కువ డాక్యుమెంట్లు తయారు చేయడం కాకూడదు.
అసలు సమస్య స్పెక్లను ఎలా సజీవంగా ఉంచాలనేది. మనకు తమను తాము అప్డేట్ చేసుకునే స్పెక్లు కావాలి. కోడ్ మరియు రన్నింగ్ సిస్టమ్ నుండి స్పెక్ను గ్రహించే (infer) సాధనాలు మనకు కావాలి. ఇది ఒక lockfile లాగా పనిచేయాలి. ఇది ఆటోమేటిక్గా జరగాలి.
ఇది ఇప్పటికి సాధ్యమేనా అని నాకు తెలియదు. ప్రొడక్షన్లో పని చేస్తున్న వారి నుండి నేను వినాలనుకుంటున్నాను.
- మీ స్పెక్ మూడవ వారం తర్వాత కూడా కొనసాగుతుందా?
- అది మారినప్పుడు (drifts), దానికి కారణం ఏమిటి?
- కోడ్ లేదా టెలిమెట్రీ (telemetry) నుండి స్పెక్లను రూపొందించడానికి ప్రయత్నించారా?
- ఈ కఠినత్వం (rigor) విలువను ఇస్తుందా లేదా కేవలం ఫార్మాలిటీగా మిగిలిపోతుందా?
Optional learning community: https://t.me/GyaanSetuAi