भविष्य को आकार देने वाली तकनीक पर गहन लेख।

AI कोडिंग असिस्टेंट: 5 मिथक, परखे हुए

AI कोडिंग असिस्टेंट टाइपिंग तेज़ करते हैं, सॉफ़्टवेयर की गुणवत्ता नहीं। डिज़ाइन, वेरिफ़िकेशन और जटिलता जैसी असली बाधाओं पर पाँच मिथक परखे गए।

एक रोबोटिक बाँह फ़ैक्टरी के फ़र्श पर चमकती ईंटों का अंबार लगा रही है, जो एक संकरे निरीक्षण द्वार पर जमा होती जा रही हैं।
पीढ़ी (generation) तेज़ हो गई। जाँच नहीं हुई — और थ्रूपुट हमेशा सबसे धीमे चरण से तय होता है।

जोनाथन ब्लो — Braid और The Witness के डिज़ाइनर, और ऐसे ज़िद्दी इंसान जिन्होंने एक दशक लगाकर अपनी खुद की प्रोग्रामिंग भाषा बना डाली — ने हाल ही में एक ऐसा सवाल पूछा जो AI कोडिंग असिस्टेंट बेचने वाली हर कंपनी को चुभना चाहिए: अगर AI ने कोडिंग सुलझा दी है, तो मेरा सॉफ़्टवेयर अब भी वैसा ही क्यों है? वही क्रैश। वही फूले हुए अपडेट। वही पुरानी शिकायतें कि ऐप्स RAM खा जाते हैं, और जितना काम वे उन टूल्स से करते हैं जिन्हें उन्होंने बदला, उससे कम करते हैं। आम जवाब — बस छह महीने रुक जाइए — इस बात को पूरी तरह नहीं समेटता, और मुझे नहीं लगता कि ब्लो ग़लत हैं जो इस दुखती रग को छेड़ रहे हैं।

मेरी राय यह है, कई साल ML सिस्टम बनाने और फिर इन टूल्स को असली टीमों में आते देखने के बाद: AI कोडिंग असिस्टेंट आज सचमुच अच्छे हैं, और फिर भी जिस सॉफ़्टवेयर को आप और मैं रोज़ इस्तेमाल करते हैं, उसकी तस्वीर इनसे ज़्यादा नहीं बदली है। दोनों बातें एक साथ सच हैं, और इसकी वजह यह है कि ये टूल कभी उस असली बाधा पर निशाना साधकर बने ही नहीं थे। इसे देखने का सबसे साफ़ तरीका है वो पाँच धारणाएँ लेना जो मैं सबसे ज़्यादा सुनता हूँ, और हर एक को परखना।

मिथक 1: सॉफ़्टवेयर डेवलपमेंट में टाइपिंग ही बाधा है

दावा सीधा-सा लगता है: कोडिंग का मतलब है कोड बनाना, तो जो मशीन कोड दस गुना तेज़ बनाए, वह सॉफ़्टवेयर को भी दस गुना तेज़ कर देगी। तर्क सुथरा है, बस एक खामी है — किसी का असली काम इस तरह नहीं दिखता। Clean Code से मशहूर एक पुराना अनुमान है कि डेवलपर कोड लिखने में जितना समय लगाते हैं, उससे दस गुना से भी ज़्यादा समय उसे पढ़ने में लगाते हैं। यह अनुपात LLM से पंद्रह साल पहले का है, पर इंजीनियरिंग के घंटे कहाँ खर्च होते हैं, इस पर हर गंभीर अध्ययन एक ही नतीजे पर पहुँचता है: मौजूदा सिस्टम को समझना, दूसरे इंसानों से तालमेल बिठाना, और फ़ैसलों का इंतज़ार करना। कीस्ट्रोक तो नगण्य हैं।

अपने हफ़्ते में यह आप खुद महसूस कर सकते हैं। ऑटोकम्प्लीट असली मिनट बचाता है — मैं इसे कभी नहीं छोड़ूँगा — पर मेरे कठिन दिन कभी इसलिए कठिन नहीं थे कि मैं तेज़ टाइप नहीं कर पाता था। वे इसलिए कठिन थे क्योंकि पेमेंट सर्विस में कोई ऐसी शर्त (invariant) थी जो किसी ने लिखी नहीं थी, या तीन टीमें इस पर असहमत थीं कि API क्या वादा करे। जो चरण धीमा था ही नहीं, उसे तेज़ करने से कुल थ्रूपुट पर लगभग कुछ असर नहीं पड़ता। जो फ़ैक्टरी पुर्ज़ों को जाँच लाइन से तेज़ ठप्पा लगाती है, वह ज़्यादा माल नहीं भेजती। वह पुर्ज़ों का और बड़ा ढेर बनाती है।

एक जगह टाइपिंग सचमुच बाधा है: ग्रीनफ़ील्ड काम में, जहाँ सम्मान करने लायक कोई मौजूदा सिस्टम नहीं। बॉयलरप्लेट, प्रोटोटाइप, फेंक दिए जाने वाले स्क्रिप्ट, किसी भी चीज़ का पहला संस्करण। इसीलिए डेमो जादू जैसे लगते हैं — डेमो हमेशा ग्रीनफ़ील्ड होते हैं। प्रोडक्शन इंजीनियरिंग लगभग पूरी तरह ब्राउनफ़ील्ड है, और ब्राउनफ़ील्ड काम दरअसल पढ़ने का काम है।

मिथक 2: AI से बना कोड पहले से वेरिफ़ाइड आता है

आशावादी वर्कफ़्लो कुछ यूँ है: काम समझाइए, मॉडल कोड लिखे, टेस्ट पास हों, मर्ज कर दें। खामी बीच के चरण में है। टेस्ट पास होने का मतलब बस इतना है कि जो टेस्ट आपने सोचकर लिखे, वे उस कोड से मेल खाते हैं जो मॉडल ने सोचकर लिखा। दोनों एक ही दिशा में गलत हो सकते हैं, और LLM के आउटपुट में अक्सर ऐसा होता है — मॉडल धाराप्रवाह, मुहावरेदार, आत्मविश्वास से भरा कोड लिखता है, और यही धाराप्रवाहता रिव्यू को निहत्था कर देती है।

यह एक छोटा उदाहरण है जो मैंने असल दुनिया में देखा है, सार में, हूबहू नहीं। मासिक जॉब शेड्यूलर माँगिए, तो कुछ ऐसा मिलेगा:

from datetime import datetime
def next_monthly_run(day: int, hour: int = 9) -> datetime:
"""Next run time for a job that fires monthly on `day`."""
now = datetime.now()
candidate = now.replace(day=day, hour=hour, minute=0, second=0, microsecond=0)
if candidate <= now:
# Roll forward one month
month = now.month % 12 + 1
year = now.year + (1 if now.month == 12 else 0)
candidate = candidate.replace(year=year, month=month)
return candidate

इसे वैसे ही पढ़िए जैसे किसी साथी के pull request को पढ़ते हैं। यह मुहावरेदार है। साल बदलने को भी सँभालता है। डॉकस्ट्रिंग भी सही है। अब इसे 15 अप्रैल को day=31 के साथ चलाइए: now.replace(day=31) ValueError फेंकता है, क्योंकि अप्रैल में 31 तारीख होती ही नहीं। फ़ंक्शन ठीक सबसे आम शेड्यूलिंग अनुरोध पर — महीने के आख़िरी दिन — क्रैश होता है, और सिर्फ़ छोटे महीनों में, इसलिए यह प्रोडक्शन में हफ़्तों तक ठीक-ठाक चलता दिख सकता है इससे पहले कि कोई ध्यान दे। पूरे साल के now मानों पर चलने वाला एक टेस्ट इसे सेकंडों में पकड़ लेता है। एक सावधान इंसानी रिव्यूअर शायद आधी बार पकड़ पाता है। यही अंतर वेरिफ़िकेशन की समस्या का छोटा रूप है।

इसीलिए मैं लगातार कहता हूँ कि AI-भारी वर्कफ़्लो में कॉम्प्रिहेंशन चेक और टेस्ट के बीच का चुनाव कोई किताबी सवाल नहीं — यही पूरा खेल है। जो कोड आपने नहीं लिखा, उसे पढ़ना लिखने से पहले ही कठिन है। जो कोड कोई इंसान नहीं लिख रहा, और इन टूल्स की मात्रा में, उसे पढ़ना रिव्यू की अर्थव्यवस्था को पूरी तरह उलट देता है। जिन टीमों से मेरी बात होती है, उनके पास अब कोड की कमी नहीं है। कमी उन लोगों की है जो समझें कि कोड क्या करता है और उस पर अपना नाम लिखने को तैयार हों।

एक आवर्धक लेंस पॉलिश किए संगमरमर की स्लैब पर एक बाल जितनी पतली दरार दिखाता है।
धाराप्रवाह कोड उसी तरह फेल होता है जैसे संगमरमर फेल होता है: एक ऐसी दरार से जो तभी दिखती है जब आप ध्यान से देखें।

मिथक 3: सस्ता कोड सॉफ़्टवेयर डिज़ाइन को भी सस्ता बना देता है

एक बारीक धारणा: अगर कोड लगभग मुफ़्त है, तो आर्किटेक्चर कम मायने रखता है, क्योंकि हम हमेशा फिर से लिख सकते हैं। ख़राब एब्स्ट्रैक्शन? उसे फिर से जनरेट कर दो। गलत डेटा मॉडल? वह भी फिर से जनरेट कर दो। मैंने सीनियर इंजीनियरों को यह बात पूरी गंभीरता से कहते सुना है, और यह टेक्स्ट बदलने की लागत को फ़ैसले बदलने की लागत के साथ उलझा देता है।

सॉफ़्टवेयर का कठिन हिस्सा कभी कोड था ही नहीं। कठिन है यह तय करना कि बनाने लायक क्या है, किसी उलझे इंसानी डोमेन को मशीन-चलाने-योग्य रूप में ढालना, और ऐसे आर्किटेक्चरल दाँव लगाना जो तब न टूटें जब ज़रूरतें बदलें — और वे हमेशा बदलती हैं। ये इरादे और मूल्यों की समस्याएँ हैं, पैटर्न पूरा करने की नहीं। मौजूदा सॉफ़्टवेयर के कॉर्पस पर प्रशिक्षित मॉडल बता सकता है कि आपके जैसे सिस्टम आम तौर पर कैसे दिखते हैं। वह यह नहीं बता सकता कि आपका सिस्टम कैसा होना चाहिए, क्योंकि वह जवाब आपके यूज़र्स, आपकी सीमाओं और आपकी संस्था की जोखिम-सहनशीलता में छिपा है। इस मोर्चे पर हमने लगभग कोई प्रगति नहीं की है, और मेरा तर्क है कि यह कोई क्षमता का अंतर नहीं जिसे स्केल करके पाटा जा सके। यह श्रेणी का बेमेल है।

रीराइट भी मुफ़्त नहीं होते। इंजीनियरिंग का ज़्यादातर पैसा मौजूदा सिस्टम बदलने में ख़र्च होता है, और सिस्टम बदलने से पहले उसमें बसे इरादे को रिवर्स-इंजीनियर करना पड़ता है — वे शर्तें जो किसी ने दस्तावेज़ नहीं कीं, वह एज केस जो किसी एक बड़े ग्राहक के लिए ज़रूरी निकलता है। मॉडल वह इरादा नहीं जानता। अक्सर टीम भी नहीं जानती। यही वह स्पेसिफ़िकेशन और इम्प्लीमेंटेशन के बीच का अंतर है जहाँ बग असल में रहते हैं, और जब तक कोई स्पेसिफ़िकेशन को कसकर न थामे रहे, ज़्यादा इम्प्लीमेंटेशन जनरेट करने से यह अंतर और चौड़ा होता है।

फ़्रेड ब्रूक्स ने सॉफ़्टवेयर को सुसंगत बनाने वाली चीज़ के लिए एक शब्द दिया था: कॉन्सेप्चुअल इंटीग्रिटी — यह एहसास कि फ़ैसले एक दिमाग ने, या कुछ एक-दिशा वाले दिमागों ने लिए। धाराप्रवाह कोड जनरेशन हमें उस ओर नहीं ले जाता। उल्टा, यह हज़ारों बेमेल छोटे फ़ैसलों को सस्ता कर देता है, और इसी से ऐसे सिस्टम बनते हैं जो डिज़ाइन किए हुए दिखते हैं पर महसूस जोड़-तोड़ वाले होते हैं।

मिथक 4: जो सॉफ़्टवेयर नहीं बदला, वह साबित करता है कि AI कोडिंग असफल रही

अब प्रतिवाद, क्योंकि ब्लो का फ़्रेमिंग भी पूरी तरह अटूट नहीं है। बड़े बाज़ार के व्यावसायिक सॉफ़्टवेयर से आगे देखिए, तो चीज़ें सचमुच आगे बढ़ रही हैं। इंडी गेम दुनिया ने छोटी टीमों के बनाए कस्टम इंजन वाले स्ट्रैटेजी गेम दिए हैं, जिनके लिए एक दशक पहले Blizzard जितनी हेडकाउंट चाहिए होती। इससे भी ज़्यादा चौंकाने वाला मेरे लिए है व्यक्तिगत सॉफ़्टवेयर का चुपचाप उभरना: लोग अपने ईमेल क्लाइंट, कैलेंडर ऐप, फ़ाइनेंस ट्रैकर और git फ़्रंटएंड खुद बना रहे हैं, ठीक वैसे जैसे वे सोचते हैं। ये टूल खुरदुरे हैं और दस हज़ार अजनबियों तक पहुँचाए जाने पर कभी नहीं टिकेंगे। पर ये मौजूद हैं, रोज़ इस्तेमाल होते हैं, और पहले इन्हें बनाना आर्थिक रूप से व्यावहारिक ही नहीं था।

संस्थाएँ भी ऐसे बदल रही हैं जिन्हें हेडलाइन मेट्रिक नहीं पकड़ता। मैं ऐसी संस्थाओं को जानता हूँ जिनकी आधुनिकीकरण योजना कुल मिलाकर यह है: पुराने सिस्टम को ठीक-ठाक API के ज़रिए खोल दो, और स्टाफ़ को एजेंटिक कोडिंग टूल की मदद से उनके ऊपर अपने एंडपॉइंट और इंटरफ़ेस बनाने दो। यह "मेरा सॉफ़्टवेयर वैसा ही दिखता है" नहीं है। यह सॉफ़्टवेयर का कुछ ज़्यादा निजी रूप में घुल जाना है — अगर आप सिर्फ़ ऐप स्टोर के चार्ट देख रहे हैं तो यह अदृश्य है।

फिर भी ब्लो का अवलोकन सच क्यों लगता है, उसकी गहरी वजह तकनीकी से ज़्यादा संगठनात्मक है। व्यावसायिक सॉफ़्टवेयर वही आकार लेता है जिसे कंपनियाँ ऑप्टिमाइज़ करती हैं — एंगेजमेंट, लॉक-इन, रिलीज़ की रफ़्तार, सपोर्ट की लागत — और AI आपको वही चीज़ तेज़ी से ज़्यादा देता है जो आप पहले से चाहते थे। यह चाहत नहीं बदलता। जो कंपनी इसलिए फूला हुआ सॉफ़्टवेयर भेजती थी क्योंकि फूलापन उसकी लागत-तालिका में नहीं था, वह अब छोटे डेवलपमेंट चक्र में वैसा ही फूला सॉफ़्टवेयर भेजेगी। हज़ारों यूज़र्स तक जाने वाले सॉफ़्टवेयर का गुणवत्ता-स्तर प्रोत्साहनों, टेस्टिंग के अनुशासन और रुचि से तय होता है — इनमें से कोई भी मॉडल का आउटपुट नहीं।

एक सीधा लैग तर्क भी है। सचमुच भरोसेमंद AI कोडिंग शायद अभी एक साल पुरानी है; उससे पहले का दौर अस्थिर था, और उससे भी पहले यह खिलौना था। उत्पाद सोचने, बनाने और शिप करने में सालों लेते हैं। इन टूल्स का शिप्ड सॉफ़्टवेयर पर असर अभी आँकना ऐसा है जैसे नया हल ईजाद होने के एक महीने बाद की फ़सल देखकर उसका मूल्यांकन करना।

मिथक 5: अगला मॉडल अंतर पाट देगा

आशावादी का सबसे मज़बूत तर्क: ऊपर की हर आपत्ति आज के मॉडलों का वर्णन करती है, और आज के मॉडल वे सबसे खराब मॉडल हैं जो हम कभी इस्तेमाल करेंगे। आंशिक रूप से सच। कॉन्टेक्स्ट विंडो बढ़ेंगी, गढ़े गए API घटेंगे, एजेंट अपने टेस्ट चलाने में बेहतर होंगे। मुझे सचमुच के लाभ की उम्मीद है, खासकर अच्छी तरह स्पेसिफ़ाइड कामों पर।

पर ध्यान दीजिए कि कौन-सी बाधाएँ क्षमता की समस्याएँ हैं और कौन-सी नहीं। मॉडल जैसे-जैसे अधिक भरोसेमंद होते हैं, वेरिफ़िकेशन आसान होता है — यह क्षमता है। यह तय करना कि क्या बनाने लायक है, कॉन्सेप्चुअल इंटीग्रिटी बनाए रखना, संस्था के ऑप्टिमाइज़ेशन लक्ष्य बदलना — ये किसी मॉडल के रोडमैप पर नहीं हैं, क्योंकि ये मॉडल की समस्याएँ ही नहीं हैं। और बेंचमार्क की प्रगति को सबूत मानने में सावधानी रखें: बेंचमार्क असली काम के ज़्यादातर हिस्से को पकड़ ही नहीं पाते, और असली काम ठीक वही है जो अधूरा स्पेसिफ़ाइड और इरादों से भरा होता है।

तो मेरी शर्त, दर्ज कर रहा हूँ: टूल्स व्यक्तिगत बिल्डरों और मज़बूत रुचि वाली छोटी टीमों के लिए नाटकीय रूप से बेहतर होंगे, और बाज़ार के सॉफ़्टवेयर में मामूली सुधार होगा, अगर होगा तो — क्योंकि वहाँ बाधा कभी कोड थी ही नहीं। अगर यह निराशावादी लगे, तो ऐसा नहीं है। इसका मतलब है कि लीवरेज आपके और आपके ऑर्ग चार्ट के हाथ में है, किसी लैब के अगले रिलीज़ में नहीं।

एक माली धूप वाली वर्कबेंच पर हाथ के औज़ारों से बोनसाई पेड़ की छंटाई कर रहा है।
सॉफ़्टवेयर की गुणवत्ता अब भी देखभाल की समस्या है, प्रोडक्शन की नहीं।

सॉफ़्टवेयर की गुणवत्ता असल में क्या सुधारता है

अगर जनरेशन सस्ता है और वेरिफ़िकेशन महँगा, तो तार्किक जवाब है निवेश को बदलना। ठोस रूप से:

  • टेस्ट और टाइप्स को प्रोडक्शन इंफ़्रास्ट्रक्चर मानिए। प्रॉपर्टी-बेस्ड टेस्ट, इन्वेरिएंट चेक और तेज़ CI ही सस्ते जनरेशन को सस्ते सही जनरेशन में बदलते हैं। इनके लिए वैसे ही बजट रखिए जैसे कंप्यूट के लिए रखते हैं।
  • प्रॉम्प्ट से पहले स्पेसिफ़िकेशन लिखिए। स्पेसिफ़िकेशन अब किसी टीम का सबसे उच्च-लीवरेज आर्टिफ़ैक्ट है, क्योंकि यही वह चीज़ है जो मॉडल नहीं दे सकता और जिसके विरुद्ध रिव्यूअर जाँच करते हैं।
  • AI का उपयोग वहाँ कीजिए जहाँ वह सचमुच मज़बूत है: ग्रीनफ़ील्ड प्रोटोटाइप, माइग्रेशन, बॉयलरप्लेट, व्यक्तिगत टूलिंग, डिज़ाइन स्पेस को तेज़ी से खंगालना। जिन लोड-बेयरिंग लीगेसी पाथ में इरादा दस्तावेज़ित नहीं है, वहाँ इस पर शक कीजिए।
  • डिज़ाइन के समय की रक्षा कीजिए। जब जनरेशन की रफ़्तार तीन गुना होती है, तो रोडमैप को तीन गुना भरने का दबाव आता है। उसका विरोध कीजिए। फ़ैसला करना ही काम है।

टाइपिंग कभी बाधा नहीं थी। बाधा हमेशा फ़ैसला करना था — और साबित करना।

ब्लो के सवाल का जवाब है, और सही पढ़ें तो वह आशाजनक है। सॉफ़्टवेयर वैसा ही दिखता है क्योंकि उसकी गुणवत्ता हमेशा फ़ैसला करने, वेरिफ़ाई करने और परवाह करने से तय होती रही है — और AI कोडिंग असिस्टेंट, अपनी सारी वास्तविक उपयोगिता के बावजूद, उस हिस्से को तेज़ करते हैं जो कभी धीमा था ही नहीं। यानी बेहतर सॉफ़्टवेयर बनाने के औज़ार वही हैं जो हमेशा थे: रुचि, स्पेसिफ़िकेशन, और चीज़ों को साबित करने का अनुशासन। मॉडलों ने बस इसे अनदेखा करना नामुमकिन बना दिया है।