Developer vs Architect: कब कौन सा रोल जीतता है
Developer vs architect सिर्फ़ टाइटल का मामला नहीं, असली सवाल है कि आर्किटेक्चर के फ़ैसले किसके हाथ में हैं। ADR, coupling और reversibility के साथ।

पिछले महीने मैंने एक diff review किया जहाँ एक AI coding assistant ने browser add-on के नए installs लॉग करने के लिए try/catch blocks की एक चेन लिख दी थी। पहले वह यूज़र का email लेने की कोशिश करता था। अगर वह throw होता, तो user ID पर fallback करता। अगर वह भी throw होता, तो एक हताश लॉग लिख देता: कोई install हुआ, पता नहीं कौन। कोड चल गया। पर कोड गलत था, क्योंकि platform ने हाल ही में यह सख़्त कर दिया था कि add-on कौन-सा identity data माँग सकता है। Developer vs architect वाला सवाल ठीक ऐसे ही diffs में छिपा होता है, और किसी ने आपको यह नहीं बताया कि अब आप इसमें किस तरफ़ हैं।
सही जवाब बेहतर catch block नहीं था। सही जवाब था timestamp लॉग करना, welcome screen दिखाना, और marketing को बताना कि install के वक़्त email नहीं मिलेगा, जब तक यूज़र खुद बाद में न दे। कोई model यह फ़ैसला नहीं ले सकता, क्योंकि model आपके users, platform की policies, या marketing के quarterly goals नहीं जानता। वह वही करता है जो आप माँगते हैं, और डरावनी रफ़्तार से करता है। यानी सवाल पूछने वाले, यानी आप, अब कोड से बड़ी किसी चीज़ के ज़िम्मेदार बन गए हैं। प्रमोशन की बधाई। माफ़ कीजिए, किसी ने बताया नहीं।
एक वाजिब दलील भी है: कई engineers कहेंगे कि हर नौकरी में उनसे requirements पर सवाल उठाने और जो भी ticket उठाएँ उसका data model डिज़ाइन करने की उम्मीद रही है। सच है, अच्छी टीमों में यह हमेशा काम का हिस्सा था। पर कुछ असली बदलाव हुआ है। टाइपिंग की रफ़्तार बुरे विचारों पर एक प्राकृतिक brake थी। जब एक औसत plan को implement करने में तीन दिन लगते थे, तो लोग पहले सोचते थे। जब उसमें नब्बे सेकंड लगते हैं, तो किसी के सोचने से पहले ही plan बन चुका होता है। जो घर्षण architectural सोच को मजबूर करता था, वह ख़त्म हो गया है, और उसकी जगह कुछ नहीं आया सिवाय आपके।
Developer vs Architect: दो अलग काम
सबसे साफ़ तरीका जो मुझे दिखता है: developer किसी ticket को लेकर पूछता है कैसे। Architect उसी ticket को देखकर पूछता है क्या इसे होना चाहिए, और किस रूप में। Developer constraints के भीतर optimize करता है। Architect constraints चुनता है, और सबसे अहम बात, अगले दो साल तक उस चुनाव के नतीजों की ज़िम्मेदारी लेता है। दोनों असली engineering हैं। बस दोनों काम अलग हैं और उनकी विफलता भी अलग तरह की होती है। Developer की गलती एक bug होती है। Architect की गलती वह data model होती है जिसमें बेमतलब की tables हों, और जब तक किसी को पता चले, तीन टीमें उसके ऊपर काम बना चुकी हों।
AI coding tools चुपचाप developer की सीट पर बैठ गए हैं। ये अब तक के सबसे तेज़ junior हैं: बिना थके, धाराप्रवाह, और यह कहने को बिल्कुल तैयार नहीं कि असली समस्या आपकी requirement है। प्रति-यूज़र install logging माँगिए, तो आपको वही मिलेगा, साथ में fallbacks की लंबी चेन ताकि वह "काम करे", भले platform ऐसा न चाहता हो। Model को आपके app के latency budget, privacy posture, या on-call rotation की कोई परवाह नहीं। यह tool की खामी नहीं है। यह उस सीट का job description है जिस पर वह बैठ गया है, और दूसरी सीट, जो "नहीं" कहती है, तब तक ख़ाली है जब तक आप खुद उस पर न बैठें।
तो उस सीट पर बैठना असल में कैसा दिखता है? मुख्यतः तीन चीज़ें। अपने users को इतनी अच्छी तरह जानना कि पहचान सकें कि कोई requirement उनके हितों से टकरा रही है। अपने system का coupling इतना समझना कि एक लाइन के बदलाव का blast radius दिख जाए। और उस इंसान से मुश्किल बातचीत करने को तैयार रहना जिसने requirement लिखी है, कोड बनने से पहले, postmortem में नहीं। इनमें से किसी में भी wiki में बने box-and-arrow diagrams शामिल नहीं हैं, जिन्हें कोई पढ़ता नहीं। इन सबके लिए वह judgment चाहिए जो ऐसे tool को नहीं सौंपा जा सकता जो कभी पलटकर सवाल नहीं करता।
Architecture के वे फ़ैसले जो आप पहले से ले रहे हैं
टाइटल होने की ज़रूरत नहीं है कि आप architecture के फ़ैसले लें, आप हर हफ़्ते साधारण tickets के भीतर ही ये फ़ैसले ले रहे होते हैं। Validation कहाँ रहेगी (client, API, या database में)। कोई call synchronous होगा या queue में जाएगा। क्या लॉग होगा और क्या जानबूझकर नहीं होगा। नई table का आकार और वह किससे foreign key करेगी। इनमें से हर एक भविष्य पर लगाया गया दांव है, और हर एक अगली दस tickets को या तो सीमित करता है या आसान बनाता है। Install-logging वाला diff एक monitoring task जैसा लग रहा था। असल में वह एक privacy फ़ैसला था, एक security फ़ैसला, और एक product फ़ैसला था जो एक लाइन के भेष में आया था।
यह रहा पहले वाला संस्करण, assistant ने ईमानदारी से "log who installed" लागू किया:
async function logInstall(req, res) {
let identity = null;
try {
identity = { email: await getUserEmail(req) };
} catch {
try {
identity = { userId: await getUserId(req) };
} catch {
identity = { note: "install without identity" };
}
}
await db.installs.insert({ ...identity, at: new Date() });
res.redirect("/welcome");
}
पंद्रह लाइनें, तीन failure modes, और एक schema जिसे हमेशा के लिए email-या-userId-या-कुछ-नहीं को संभालना पड़ेगा। हर fallback चुपचाप install path को एक identity API से जोड़ता है, तो एक consent-gated service का outage अब आपके onboarding funnel को धीमा या तोड़ सकता है। और वह row जो कहती है "कोई install हुआ, पता नहीं कौन", विश्लेषण के लिए बेकार है। Marketing को उससे कुछ करने लायक नहीं मिलता। Requirement शाब्दिक रूप से पूरी हुई और भावना में हार गई।
async function logInstall(req, res) {
await db.installs.insert({ at: new Date() });
res.redirect("/welcome");
// Email is collected on the welcome screen, with consent,
// posted asynchronously — and never gates the install path.
}
बाद वाला संस्करण चार लाइनों का है। पर ध्यान दीजिए कि असल में क्या बदला: कोड नहीं, requirement। लक्ष्य कभी "email लेना" था ही नहीं। लक्ष्य था "installs मापना और नए users को follow up करना"। Timestamp installs मापता है। Welcome screen, जहाँ यूज़र पहले से consent वाली सतह देख रहा है, email माँगने की सही जगह है, asynchronously, जहाँ विफलता की कोई कीमत नहीं। Architect की चाल कम कोड लिखना नहीं थी। वह यह दोबारा तय करना थी कि कोड किसलिए है।
एक आदत बनाने लायक है: किसी भी गैर-मामूली बदलाव से पहले दो मिनट का coupling inventory लें। पूछें कि यह कोड किसे call करेगा, इसे कौन call करेगा, और जब इनमें से कोई धीमा हो, बंद हो, या deprecated हो तो क्या टूटेगा। पहले वाले संस्करण में install path दो identity services पर निर्भर था, जिनसे उसका कोई लेना-देना नहीं था। बाद वाले में वह सिर्फ़ एक table पर निर्भर है। वह dependency count, line count या cyclomatic complexity नहीं, वह संख्या है जो आपकी भविष्य की incidents की भविष्यवाणी करती है। यही पैटर्न मैंने AI coding assistants कैसे predictable, testable तरीके से फ़ेल होते हैं में भी देखा है: आउटपुट स्थानीय रूप से सही लगता है और वैश्विक रूप से coupled होता है।
ADRs बनाम Tribal Knowledge: कब कौन जीतता है
Architecture Decision Record जानबूझकर उबाऊ है: एक पन्ना, जिसमें संदर्भ, फ़ैसला, विचार किए गए विकल्प, और स्वीकार किए गए परिणाम लिखे होते हैं। बस इतना। कोई तामझाम नहीं, कोई sign-off workflow नहीं, जब तक आप न चाहें। AI युग में ADRs "अच्छा होता है" से "अनिवार्य" क्यों बन गए, इसकी वजह याददाश्त है। Model की कोई याददाश्त नहीं होती। छह महीने बाद कोई किसी assistant को install module पर लगाएगा और बदलाव माँगेगा, और consent व platform policy पर किया गया सावधान तर्क गायब हो चुका होगा, जब तक वह ऐसी जगह लिखा न हो जहाँ इंसान और tools दोनों उसे खोज सकें। Repo में रखा ADR उसे पढ़ता है जो भी अगली बार कोड छुए, चाहे वह इंसान हो या मशीन।
कुछ स्थितियों में Tribal knowledge सचमुच जीतता है, और इसे नकारना ही ADRs को उनकी नौकरशाही वाली छवि देता है। दो लोगों की टीम जो कुछ हफ़्तों की उम्र वाला prototype बना रही है, उसे decision records की ज़रूरत नहीं। फ़ैसला लेने वाले एक-दूसरे के बगल में बैठे हैं और कोड वैसे भी दोबारा लिखा जाएगा। उस पैमाने पर मौखिक संदर्भ तेज़, समृद्ध और सस्ता है। दिक्कत यह है कि टीमें अक्सर उस क्षण को नहीं पहचानतीं जब वे सीमा पार कर लेती हैं: पहला नया hire, पहली टीम जो आपका API इस्तेमाल करती है, पहली incident जहाँ "हमने ऐसा क्यों किया?" का जवाब नहीं होता।
- इस फ़ैसले को पलटना महँगा है: live data पर schema बदलाव, public API contracts, vendor lock-in।
- यह फ़ैसला टीम की सीमा पार करता है, इसलिए जिन लोगों पर असर होगा, वे फ़ैसला लेते समय कमरे में नहीं होते।
- भविष्य का सवाल अभी से सुनाई दे रहा है: "आखिर हमने ऐसा क्यों किया?"
- Implementation AI tool ने बनाया, इसलिए किसी इंसान को तर्क को ज़ोर से बोलकर समझाना नहीं पड़ा।
- Trade-off स्पष्ट नहीं है: आप जानबूझकर एक असली कीमत (latency, privacy सतह, operational बोझ) स्वीकार कर रहे हैं।
चौथा बिंदु ही नया है। जब इंसान कोड लिखता है, तो तर्क के निशान छूट जाते हैं: commit messages, PR की बहसें, प्रयास का ढाँचा खुद। जब assistant कोड लिखता है, तो तर्क सिर्फ़ आपके दिमाग में कुछ देर के लिए रहता है, फिर कहीं नहीं। ADR वह artifact है जो review को संभव बनाता है, क्योंकि यह reviewers को कोड को जाँचने के लिए कुछ देता है। उसके बिना review style की छोटी-मोटी बातों में सिमट जाता है और architecture चुपचाप बहकता रहता है।

Reversible बनाम Irreversible फ़ैसले: System Design में
Architect के औज़ार में सबसे काम का सवाल यह है: अपना मन बदलने की कीमत कितनी है? कुछ फ़ैसले दो-तरफ़ा दरवाज़े होते हैं। Log format, internal function signature, caching TTL, इनमें से किसी को भी किसी भी दोपहर वापस लिया जा सकता है। कुछ एक-तरफ़ा दरवाज़े होते हैं। बाहरी clients जिस public API contract से जुड़ते हैं। वह database schema जिसमें छह महीने का production data जमा है। वह consent flow जिस पर आपकी legal स्थिति अब टिकी है। एक बार एक-तरफ़ा दरवाज़े से निकल गए, तो दोबारा सोचने की कीमत refactor नहीं होती, वह एक migration, एक deprecation schedule और एक माफ़ी होती है।
बनाने से पहले दरवाज़े का वर्गीकरण कीजिए, क्योंकि AI ने बनाना सस्ता कर दिया है, पर वापस लेना आज भी उतना ही महँगा है। बिना रोक-टोक के, एक assistant खुशी-खुशी आपका data model डिज़ाइन कर देगा, और विफलता का तरीका होगा बेमतलब tables, दोहराए गए columns, और migration कोड के ऊपर migration कोड, क्योंकि हर prompt model पर दोबारा सोचने के बजाय एक नई table जोड़ देता है। तीन services द्वारा पढ़ी जा रही live data वाली table मिटाना हमारी इंडस्ट्री के सबसे दुखदायी कामों में से एक है। Schema का सस्ता generation ही वजह है कि schema पर महँगी सोच ज़रूरी है। अपना सोच-विचार का बजट कोड लिखने में लगने वाले समय के अनुपात में नहीं, बल्कि वापस न लौटने की प्रकृति के अनुपात में खर्च कीजिए। यह अनुपात उलट चुका है।
मेरा काम करने का नियम: अगर कोई फ़ैसला ऐसे data को छूता है जिसे आप दोबारा नहीं बना सकते, या ऐसे interface को जिस पर आपकी टीम के बाहर का कोई निर्भर करेगा, तो implementation शुरू होने से पहले उसे ADR और दूसरी जोड़ी आँखें चाहिए। बाकी सब कुछ ship करके iterate किया जाता है। यह नियम एक solo project से लेकर platform team तक बिना बदलाव के चलता है, और यही फ़र्क है तेज़ चलने और ऐसी दिशा में तेज़ चलने में जहाँ से आप लौट नहीं सकते।
Architect की तरह requirements पर सवाल उठाना
Architect के काम का असहज केंद्र उन लोगों को "नहीं" कहना है जिनका पद आपसे ऊँचा है। "Log who installed" एक requirement जैसा लगता था; असल में वह किसी का पहले से सोचा हुआ solution था, लक्ष्य "installs मापना और नए users को follow up करना" के लिए। Architects solutions को वापस लक्ष्यों में बदलते हैं, फिर लक्ष्य तक पहुँचने का सस्ता रास्ता सुझाते हैं। यही अनुवाद पूरी चाल है, और कोई tool यह नहीं करता, क्योंकि tool का पूरा डिज़ाइन ही मानना है। कुछ engineers अपने assistant को user context देकर उससे ठीक-ठाक judgment निकाल लेते हैं। यह किनारों पर मदद करता है, पर model फिर भी मीटिंग में जाकर marketing से यह नहीं कहेगा कि उनका follow-up email install के वक़्त नहीं भेजा जाएगा।
- Solution नहीं, लक्ष्य वापस दोहराइए: "हम installs मापना चाहते हैं और नए users तक पहुँचना चाहते हैं।"
- सस्ता रास्ता और उसका नतीजा सुझाइए: timestamp logging installs को सटीक रूप से मापता है।
- महँगे रास्ते की असली कीमत बताइए: consent की रुकावट, coupled install path, ऐसी rows जो marketing इस्तेमाल नहीं कर सकता।
- उन्हें एक असली विकल्प दीजिए: "अगर email ज़रूरी है, तो हम welcome screen पर पूछते हैं, यह उसका एक-दिन वाला संस्करण है।"
- जो भी तय हो, लिखकर रखिए, ताकि अगला व्यक्ति उसे शून्य से दोबारा बहस न करे।
अब ईमानदार आपत्ति, क्योंकि उसे भी जगह मिलनी चाहिए: किसी को प्रमोशन नहीं मिला। ज़्यादा संभावित कहानी यह है कि आप एक model के लिए लिए गए फ़ैसलों की liability का ठिकाना बन रहे हैं, उसी तनख़्वाह पर, मज़े वाले हिस्से के बिना। मुझे नहीं लगता कि यह गलत है। मुझे लगता है कि यह documentation की आदत को गंभीरता से लेने का कारण है, उसे छोड़ने का नहीं। ADR का रास्ता एक paper trail भी है। फ़ैसला करने वाला इंसान होना तभी liability है जब आप अपना तर्क दिखा न सकें। जिसने लिखा कि "हमने email capture के बजाय timestamps चुने क्योंकि platform identity data को सीमित करता है", वह सुरक्षित है। जिसने assistant का जो भी आउटपुट था उसे merge कर दिया, वह सुरक्षित नहीं है।
Developer vs Architect: कब कौन जीतता है
यह कोई रैंकिंग नहीं है, यह मोड बदलने का मामला है, और कौशल यह जानने में है कि सामने वाले काम को कौन-सा मोड चाहिए। मेरी अपनी backlog के कुछ ठोस उदाहरण:
- अच्छी तरह से परिभाषित bug fix, जानी-पहचानी blast radius: developer मोड जीतता है। Reproduce करें, ठीक करें, test करें, ship करें। यहाँ architectural सोच-विचार टालमटोल है, बस ब्लेज़र पहनकर।
- माँग परखने वाला prototype: developer मोड। काम करे तो कोड दोबारा लिखा जाएगा, न करे तो मिटा दिया जाएगा। एक throwaway के लिए ADR बर्बादी है।
- धुंधली requirements वाला greenfield feature: पहले architect मोड, भले सिर्फ़ एक घंटे के लिए। धुंधलापन ही वह जगह है जहाँ AI-generated रफ़्तार सबसे ज़्यादा नुकसान करती है।
- पैसे, identity या consent को छूने वाली कोई भी चीज़: architect मोड, बिना अपवाद। बनाने और वापस लेने की कीमत की असमानता यहाँ सबसे बुरी होती है।
- Live data पर schema बदलाव या public API बदलाव: reversibility नियम के अनुसार ADR के साथ architect मोड।
- दो लोगों की टीम, codebase छह महीने से छोटा: running notes फ़ाइल के साथ developer मोड। अभी पूरा ताम-झाम कुछ नहीं जोड़ेगा।
- Regulated domain या कई उपभोक्ता टीमें: records के साथ architect मोड, क्योंकि "क्यों" का सवाल auditors और अजनबी पूछेंगे, दोस्त नहीं।
दोनों दिशाओं में विफलता का कारण एक ही मोड में अटके रहना है। जो developers कभी मोड नहीं बदलते, वे गलत चीज़ का खूबसूरत implementation बनाते हैं। जो architects कभी नीचे नहीं उतरते, वे ऐसे systems के diagrams बनाते हैं जो मौजूद ही नहीं हैं। जिन लोगों को मैं टीम में सबसे कम खोना चाहूँगा, वे वही हैं जो एक ही दोपहर में दोनों करते हैं: सुबह 10 बजे data model पर बहस, फिर दोपहर 2 बजे off-by-one ठीक करना, बिना यह शिकायत किए कि यह उनके स्तर से नीचे है। अगर आप अपनी review प्रक्रिया AI आउटपुट के इर्द-गिर्द बना रहे हैं, तो agentic coding tools loops, context और permissions कैसे संरचित करते हैं यह पढ़ना उपयोगी है, क्योंकि मोड का बदलना उस loop के भीतर होना चाहिए, उसके बाद नहीं।
AI हमेशा के लिए, बहुत तेज़ रफ़्तार से, गलत चीज़ बनाता रहेगा। Architect का काम तय करना है कि सही चीज़ क्या है, और यह भी लिखकर रखना कि क्यों, इससे पहले कि तर्क गायब हो जाए।

सिफ़ारिश: प्रमोशन स्वीकार कीजिए
मेरी स्थिति यह है, और यह "यह निर्भर करता है" नहीं है: अपने data model, किसी बाहरी contract, या अपनी security posture को छूने वाली हर चीज़ के लिए डिफ़ॉल्ट रूप से architect मोड अपनाइए, और जो कुछ सीमित है उसमें developer मोड में रहिए। यह बँटवारा 50/50 नहीं होगा। ज़्यादातर engineers के लिए यह 20% architecting, 80% building है, जैसा हमेशा रहा है। जो बदला है वह यह कि building तेज़ हो गई है और 20% छोड़ने की कीमत उसी रफ़्तार-गुणक के हिसाब से बढ़ गई है। आप जितनी टाइपिंग सौंपेंगे, आपकी कीमत उतनी ही उस हिस्से में सिमटेगी जिसे कोई और नहीं कर सकता।
स्टार्टर किट में तीन आदतें हैं, और ये तीनों इसी हफ़्ते लागू की जा सकती हैं। पहली, अपने repo में एक ADR template रखिए: संदर्भ, फ़ैसला, विकल्प, परिणाम, आधा पन्ना। और अगली बार जब आप कोई असली trade-off स्वीकार करें, तो एक लिखिए। दूसरी, हर epic में दो मिनट का coupling inventory जोड़िए: यह क्या call करता है, इसे कौन call करता है, इनके फ़ेल होने पर क्या टूटता है। तीसरी, अपने ticket template में reversibility वाला सवाल डालिए: "अगर यह गलत निकला, तो अपना मन बदलने की कीमत क्या है?" अगर जवाब है "एक migration और एक माफ़ी", तो रुकिए। अगर जवाब है "एक दोपहर", तो मत रुकिए।
कोडिंग का काम ख़त्म नहीं हो रहा, टाइपिंग का काम हो रहा है। ये दोनों कभी एक चीज़ नहीं थे, और चुपचाप घबरा रहे लोग वे हैं जिनकी भूमिका tickets को syntax में बदलने तक सिमट गई थी। अगर आप diffs पढ़ते हुए पूछ रहे हैं कि "यह identity API से coupled क्यों है", तो आप पहले से architect का काम कर रहे थे। असली बदलाव बस इतना है कि अब यह आधिकारिक है, दस्तावेज़ में है, और आपका है। प्रमोशन स्वीकार कीजिए।


