अनेक लोकांचे म्हणणे आहे की AI मुळे सॉफ्टवेअर डेव्हलपमेंट खूप स्वस्त होईल. त्यांना वाटते की मॉडेल्स इंजिनिअर्सची जागा घेतील आणि कामे मिनिटांत पूर्ण करतील. ही गोष्ट ऐकायला आकर्षक वाटते, पण ती पूर्णपणे सत्य नाही. सॉफ्टवेअर बनवण्याचे अर्थशास्त्र बदलले आहे, नाहीसे झाले नाही. पहिला कोडिंग असिस्टंट आल्यावर तांत्रिक कर्ज (technical debt) नाहीसे झाले नाही. आम्ही फक्त त्याला वित्तपुरवठा करण्याचा एक नवीन मार्ग शोधला आहे.
जुने बिल: कर्मचारी संख्या (Head Count)
दशकांपासून, तांत्रिक कर्जाने एक ओळखीचे दुष्टचक्र (doom loop) निर्माण केले होते. कोडबेस हळूहळू ठिसूळ होत जात असे. ज्या फीचर्ससाठी एकेकाळी काही दिवस लागायचे, त्यासाठी आता आठवडे लागू लागले. डेडलाईन्स चुकल्यामुळे, नेतृत्वाने अधिक भरतीसाठी जागा (requisitions) काढल्या. मोठ्या टीममुळे कामाचा वेग आणखी मंदावला. समन्वयाचा भार (coordination overhead) वाढला, स्टँड-अप्स वाढले आणि कॉनवेचा नियम (Conway’s Law) लागू झाला: सॉफ्टवेअर बनवणाऱ्या लोकांच्या संवादहीनतेचे प्रतिबिंब सॉफ्टवेअरमध्ये दिसू लागले. अधिक बग्स (bugs) राहून जाऊ लागले. प्रत्येक पॅचमुळे जटिलतेचे नवीन स्तर वाढले. कंपन्यांनी या सडलेल्या प्रक्रियेसाठी त्यांच्याकडे असलेल्या एकमेव चलनाद्वारे पैसे दिले: मानवी पगार. हा खर्च स्पष्ट होता. तो प्रत्येक त्रैमासिक बजेट रिव्ह्यूमध्ये दिसून येत असे.
नवीन बिल: टोकन्स आणि कॉन्टेक्स्ट (Tokens and Context)
जनरेटिव्ह AI ने हे चक्र तोडले नाही. याने फक्त एक पर्यायी पेमेंट प्लॅन आणला आहे. अडथळे दूर करण्यासाठी पाच इंजिनिअर्सना कामावर घेण्याऐवजी, कंपनी आता अधिक कम्प्युटसाठी (compute) क्रेडिट कार्ड वापरते. लक्षणे वेगळी दिसत असली तरी, मूळ आजार तोच आहे.
जेव्हा एखादे मॉडेल अपयशी होऊ लागते—अंतर्गत APIs चे भास (hallucinating) निर्माण करणे, महत्त्वाच्या edge cases कडे दुर्लक्ष करणे, किंवा चुकीच्या कारणांसाठी पास होणारे टेस्ट्स तयार करणे—तेव्हा सुधारणा (refactor) करण्याचा विचार क्वचितच केला जातो. त्याऐवजी इन्फरन्सवर (inference) पैसे खर्च करण्याची प्रवृत्ती असते. टीम्स कॉन्टेक्स्ट-विंडो अपग्रेड्स खरेदी करतात, मल्टी-एजंट रिट्राय लूप्स तयार करतात, वर्कलोड्स मोठ्या फ्रंटियर मॉडेल्सकडे वळवतात, किंवा जोपर्यंत 'diff' स्वीकारार्ह दिसत नाही तोपर्यंत 'regenerate' बटण दाबून ठेवतात. या युक्त्या एका-दोन स्प्रिंटसाठी कामाचा वेग टिकवून ठेवतात. जिरा (Jira) बोर्ड हिरवा दिसतो. दरम्यान, प्रत्यक्ष आर्किटेक्चर तसे तसे राहते: तेच गुंतागुंतीचे डिपेंडन्सीज, तोच बदलता जाणारा ग्लोबल स्टेट, तोच मोनोलिथ (monolith) जो सध्याच्या टीममधील कोणालाही पूर्णपणे समजलेला नाही.
अस्वच्छ कोडमुळे (Dirty Code) टोकन्स का खर्च होतात?
लार्ज लँग्वेज मॉडेल्स स्वच्छ ॲब्स्ट्रॅक्शन्सच्या (clean abstractions) आधारे सर्वोत्तम तर्क लावतात. मात्र, बहुतेक एंटरप्राइझ रिपॉझिटरीज (repositories) हे पुरातत्व स्थळांसारख्या आहेत. त्यामध्ये सर्कुलर पॅकेज डिपेंडन्सीज, इनिशियलायझेशन स्क्रिप्ट्समध्ये दडलेले छुपे परिणाम (side effects) आणि डेटाबेस ट्रिगर्स, मिडलवेअर लेयर्स आणि फ्रंट-एंड कंपोनंट्समध्ये पसरलेले बिझनेस लॉजिक असते. अशा वातावरणात, मॉडेल आपली ऊर्जा नवीन लॉजिक लिहिण्यासाठी खर्च करत नाही. ते समजून घेण्यासाठी (comprehension) टोकन्स खर्च करते.
१२८,०००-टोकन कॉन्टेक्स्ट विंडोचा मोठा भाग केवळ सिस्टमची रचना मेमरीमध्ये धरून ठेवण्यासाठी खर्च होऊ शकतो. प्रत्यक्ष समस्या सोडवण्यासाठी उरलेला भाग खूपच कमी असतो. हे एखाद्या स्ट्रक्चरल इंजिनिअरला नवीन मजला डिझाइन करायला सांगण्यासारखे आहे, पण प्रत्येक गणनेपूर्वी त्याला इमारतीचे जुने ब्लूप्रिंट्स स्मरणातून पुन्हा काढायला लावणे. परिणाम म्हणजे वरवरची उपाययोजना. मॉडेल जे गोंधळ पाहते त्याचेच प्रतिबिंब दाखवते, कारण खोली आधी स्वच्छ करण्यासाठी त्याच्याकडे अधिकार किंवा आर्किटेक्चरल कॉन्टेक्स्ट नसतो.
वेगवान आउटपुट, पण संथ डिलिव्हरी (Slower Shipping)
केवळ निर्मितीचा वेग (generation speed) हा डिलिव्हरीच्या वेगामध्ये रूपांतरित होत नाही. जर तुमच्या आर्किटेक्चरमध्ये मॉड्युलॅरिटी (modularity) नसेल, तर AI ने केलेल्या प्रत्येक बदलासाठी सखोल मानवी पुनरावलोकन (human review) आणि रिग्रेशन टेस्टिंगची गरज असते. मॉडेल एका दुपारी दहा 'pull requests' तयार करू शकते, पण त्या 'pull requests' ला तरीही इंटिग्रेशन एन्व्हायरनमेंट, सिक्युरिटी स्कॅनर्स, कंप्लायन्स चेकलिस्ट आणि प्रोडक्शन कॅनेरीजमधून जावे लागते. स्पष्ट मॉड्यूल सीमांशिवाय, AI मशीनच्या वेगाने बग्स निर्माण करते. ते एखादे शेअर केलेले युटिलिटी बदलू शकते, सूक्ष्म चुकीच्या गृहितकांसह तीन दूरच्या कॉल साइट्स अपडेट करू शकते आणि अशा 'race conditions' निर्माण करू शकते ज्या मानवांना पहाटे ३ वाजता येणाऱ्या कॉलमध्ये (page) समजतात. अडथळा (bottleneck) कीबोर्डकडून व्हॅलिडेशन पाइपलाइनकडे सरकतो, आणि ती पाइपलाइन बदलांच्या दहापट वाढीला हाताळण्यासाठी डिझाइन केलेली नसते.
अदृश्य मर्यादा (The Hidden Ceiling)
AI-पूर्व युगात, मर्यादा तुमची भरती बजेट होती. ते किमान स्प्रेडशीटवर वाचणे सोपे होते. आता ही मर्यादा अशा गोष्टींमध्ये दडलेली आहे ज्यांचा मागोवा बहुतेक फायनान्स टीम्स घेत नाहीत: इन्फरन्स खर्च, एम्बेडिंग स्टोरेज, कॉन्टेक्स्ट-विंडो विस्तार आणि ऑटोमेटेड-टेस्टिंगमुळे निर्माण होणारा अडथळा जो CI रनर्सना रोखून धरतो. प्रॉडक्टिव्हिटी डॅशबोर्ड्स हिरवेगार दिसतात, तर प्रत्येक नवीन फीचरचा खरा खर्च शांतपणे वाढत जातो.
Architectural entropy is the real villain here. LLMs scale code production beautifully, but they do not reduce complexity. They do not untangle microservices, eliminate dead code, or collapse inheritance hierarchies. Once a system crosses the threshold where humans struggle to reason about it, AI struggles too. At that inflection point, costs curve upward whether you